projects / hashcat.git / blob
? search:


f289bb17f52b2f2dff659ce1ad2d5891e0de50e9
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * oclHashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 double speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 speed_cnt += device_param->speed_cnt[i];
811 speed_ms += device_param->speed_ms[i];
812 }
813
814 speed_cnt /= SPEED_CACHE;
815 speed_ms /= SPEED_CACHE;
816
817 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
818 }
819
820 /**
821 * exec time
822 */
823
824 fprintf (out, "EXEC_RUNTIME\t");
825
826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
827 {
828 hc_device_param_t *device_param = &data.devices_param[device_id];
829
830 if (device_param->skipped) continue;
831
832 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
833
834 fprintf (out, "%f\t", exec_ms_avg);
835 }
836
837 /**
838 * words_cur
839 */
840
841 u64 words_cur = get_lowest_words_done ();
842
843 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
844
845 /**
846 * counter
847 */
848
849 u64 progress_total = data.words_cnt * data.salts_cnt;
850
851 u64 all_done = 0;
852 u64 all_rejected = 0;
853 u64 all_restored = 0;
854
855 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
856 {
857 all_done += data.words_progress_done[salt_pos];
858 all_rejected += data.words_progress_rejected[salt_pos];
859 all_restored += data.words_progress_restored[salt_pos];
860 }
861
862 u64 progress_cur = all_restored + all_done + all_rejected;
863 u64 progress_end = progress_total;
864
865 u64 progress_skip = 0;
866
867 if (data.skip)
868 {
869 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
870
871 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
872 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
873 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
874 }
875
876 if (data.limit)
877 {
878 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
879
880 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
881 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
882 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
883 }
884
885 u64 progress_cur_relative_skip = progress_cur - progress_skip;
886 u64 progress_end_relative_skip = progress_end - progress_skip;
887
888 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
889
890 /**
891 * cracks
892 */
893
894 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
895 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
896
897 /**
898 * temperature
899 */
900
901 #ifdef HAVE_HWMON
902 if (data.gpu_temp_disable == 0)
903 {
904 fprintf (out, "TEMP\t");
905
906 hc_thread_mutex_lock (mux_adl);
907
908 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
909 {
910 hc_device_param_t *device_param = &data.devices_param[device_id];
911
912 if (device_param->skipped) continue;
913
914 int temp = hm_get_temperature_with_device_id (device_id);
915
916 fprintf (out, "%d\t", temp);
917 }
918
919 hc_thread_mutex_unlock (mux_adl);
920 }
921 #endif // HAVE_HWMON
922
923 /**
924 * flush
925 */
926
927 #ifdef _WIN
928 fputc ('\r', out);
929 fputc ('\n', out);
930 #endif
931
932 #ifdef _POSIX
933 fputc ('\n', out);
934 #endif
935
936 fflush (out);
937 }
938
939 void status_display ()
940 {
941 if (data.devices_status == STATUS_INIT) return;
942 if (data.devices_status == STATUS_STARTING) return;
943 if (data.devices_status == STATUS_BYPASS) return;
944
945 if (data.status_automat == 1)
946 {
947 status_display_automat ();
948
949 return;
950 }
951
952 char tmp_buf[1000] = { 0 };
953
954 uint tmp_len = 0;
955
956 log_info ("Session.Name...: %s", data.session);
957
958 char *status_type = strstatus (data.devices_status);
959
960 uint hash_mode = data.hash_mode;
961
962 char *hash_type = strhashtype (hash_mode); // not a bug
963
964 log_info ("Status.........: %s", status_type);
965
966 /**
967 * show rules
968 */
969
970 if (data.rp_files_cnt)
971 {
972 uint i;
973
974 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
975 {
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
977 }
978
979 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
980
981 log_info ("Rules.Type.....: %s", tmp_buf);
982
983 tmp_len = 0;
984 }
985
986 if (data.rp_gen)
987 {
988 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
989
990 if (data.rp_gen_seed)
991 {
992 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
993 }
994 }
995
996 /**
997 * show input
998 */
999
1000 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1001 {
1002 if (data.wordlist_mode == WL_MODE_FILE)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1005 }
1006 else if (data.wordlist_mode == WL_MODE_STDIN)
1007 {
1008 log_info ("Input.Mode.....: Pipe");
1009 }
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_COMBI)
1012 {
1013 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1014 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1015 }
1016 else if (data.attack_mode == ATTACK_MODE_BF)
1017 {
1018 char *mask = data.mask;
1019
1020 if (mask != NULL)
1021 {
1022 uint mask_len = data.css_cnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1025
1026 if (mask_len > 0)
1027 {
1028 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1029 {
1030 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1031 {
1032 mask_len -= data.salts_buf[0].salt_len;
1033 }
1034 }
1035
1036 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1037
1038 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1039 }
1040
1041 if (data.maskcnt > 1)
1042 {
1043 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1044
1045 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1046 }
1047
1048 log_info ("Input.Mode.....: %s", tmp_buf);
1049 }
1050
1051 tmp_len = 0;
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1054 {
1055 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1056 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1057 }
1058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1059 {
1060 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1062 }
1063
1064 if (data.digests_cnt == 1)
1065 {
1066 if (data.hash_mode == 2500)
1067 {
1068 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1069
1070 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1071 (char *) data.salts_buf[0].salt_buf,
1072 wpa->orig_mac1[0],
1073 wpa->orig_mac1[1],
1074 wpa->orig_mac1[2],
1075 wpa->orig_mac1[3],
1076 wpa->orig_mac1[4],
1077 wpa->orig_mac1[5],
1078 wpa->orig_mac2[0],
1079 wpa->orig_mac2[1],
1080 wpa->orig_mac2[2],
1081 wpa->orig_mac2[3],
1082 wpa->orig_mac2[4],
1083 wpa->orig_mac2[5]);
1084 }
1085 else if (data.hash_mode == 5200)
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else if (data.hash_mode == 9000)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else
1098 {
1099 char out_buf[HCBUFSIZ] = { 0 };
1100
1101 ascii_digest (out_buf, 0, 0);
1102
1103 // limit length
1104 if (strlen (out_buf) > 40)
1105 {
1106 out_buf[41] = '.';
1107 out_buf[42] = '.';
1108 out_buf[43] = '.';
1109 out_buf[44] = 0;
1110 }
1111
1112 log_info ("Hash.Target....: %s", out_buf);
1113 }
1114 }
1115 else
1116 {
1117 if (data.hash_mode == 3000)
1118 {
1119 char out_buf1[32] = { 0 };
1120 char out_buf2[32] = { 0 };
1121
1122 ascii_digest (out_buf1, 0, 0);
1123 ascii_digest (out_buf2, 0, 1);
1124
1125 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1126 }
1127 else
1128 {
1129 log_info ("Hash.Target....: File (%s)", data.hashfile);
1130 }
1131 }
1132
1133 log_info ("Hash.Type......: %s", hash_type);
1134
1135 /**
1136 * speed new
1137 */
1138
1139 u64 speed_cnt[DEVICES_MAX] = { 0 };
1140 double speed_ms[DEVICES_MAX] = { 0 };
1141
1142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1143 {
1144 hc_device_param_t *device_param = &data.devices_param[device_id];
1145
1146 if (device_param->skipped) continue;
1147
1148 speed_cnt[device_id] = 0;
1149 speed_ms[device_id] = 0;
1150
1151 for (int i = 0; i < SPEED_CACHE; i++)
1152 {
1153 speed_cnt[device_id] += device_param->speed_cnt[i];
1154 speed_ms[device_id] += device_param->speed_ms[i];
1155 }
1156
1157 speed_cnt[device_id] /= SPEED_CACHE;
1158 speed_ms[device_id] /= SPEED_CACHE;
1159 }
1160
1161 float hashes_all_ms = 0;
1162
1163 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1164
1165 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1166 {
1167 hc_device_param_t *device_param = &data.devices_param[device_id];
1168
1169 if (device_param->skipped) continue;
1170
1171 hashes_dev_ms[device_id] = 0;
1172
1173 if (speed_ms[device_id])
1174 {
1175 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1176
1177 hashes_all_ms += hashes_dev_ms[device_id];
1178 }
1179 }
1180
1181 /**
1182 * exec time
1183 */
1184
1185 double exec_all_ms[DEVICES_MAX] = { 0 };
1186
1187 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1188 {
1189 hc_device_param_t *device_param = &data.devices_param[device_id];
1190
1191 if (device_param->skipped) continue;
1192
1193 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1194
1195 exec_all_ms[device_id] = exec_ms_avg;
1196 }
1197
1198 /**
1199 * timers
1200 */
1201
1202 double ms_running = 0;
1203
1204 hc_timer_get (data.timer_running, ms_running);
1205
1206 double ms_paused = data.ms_paused;
1207
1208 if (data.devices_status == STATUS_PAUSED)
1209 {
1210 double ms_paused_tmp = 0;
1211
1212 hc_timer_get (data.timer_paused, ms_paused_tmp);
1213
1214 ms_paused += ms_paused_tmp;
1215 }
1216
1217 #ifdef WIN
1218
1219 __time64_t sec_run = ms_running / 1000;
1220
1221 #else
1222
1223 time_t sec_run = ms_running / 1000;
1224
1225 #endif
1226
1227 if (sec_run)
1228 {
1229 char display_run[32] = { 0 };
1230
1231 struct tm tm_run;
1232
1233 struct tm *tmp = NULL;
1234
1235 #ifdef WIN
1236
1237 tmp = _gmtime64 (&sec_run);
1238
1239 #else
1240
1241 tmp = gmtime (&sec_run);
1242
1243 #endif
1244
1245 if (tmp != NULL)
1246 {
1247 memset (&tm_run, 0, sizeof (tm_run));
1248
1249 memcpy (&tm_run, tmp, sizeof (tm_run));
1250
1251 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1252
1253 char *start = ctime (&data.proc_start);
1254
1255 size_t start_len = strlen (start);
1256
1257 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1258 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1259
1260 log_info ("Time.Started...: %s (%s)", start, display_run);
1261 }
1262 }
1263 else
1264 {
1265 log_info ("Time.Started...: 0 secs");
1266 }
1267
1268 /**
1269 * counters
1270 */
1271
1272 u64 progress_total = data.words_cnt * data.salts_cnt;
1273
1274 u64 all_done = 0;
1275 u64 all_rejected = 0;
1276 u64 all_restored = 0;
1277
1278 u64 progress_noneed = 0;
1279
1280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1281 {
1282 all_done += data.words_progress_done[salt_pos];
1283 all_rejected += data.words_progress_rejected[salt_pos];
1284 all_restored += data.words_progress_restored[salt_pos];
1285
1286 // Important for ETA only
1287
1288 if (data.salts_shown[salt_pos] == 1)
1289 {
1290 const u64 all = data.words_progress_done[salt_pos]
1291 + data.words_progress_rejected[salt_pos]
1292 + data.words_progress_restored[salt_pos];
1293
1294 const u64 left = data.words_cnt - all;
1295
1296 progress_noneed += left;
1297 }
1298 }
1299
1300 u64 progress_cur = all_restored + all_done + all_rejected;
1301 u64 progress_end = progress_total;
1302
1303 u64 progress_skip = 0;
1304
1305 if (data.skip)
1306 {
1307 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1308
1309 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1312 }
1313
1314 if (data.limit)
1315 {
1316 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1317
1318 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1321 }
1322
1323 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1324 u64 progress_end_relative_skip = progress_end - progress_skip;
1325
1326 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1327 {
1328 if (data.devices_status != STATUS_CRACKED)
1329 {
1330 #ifdef WIN
1331 __time64_t sec_etc = 0;
1332 #else
1333 time_t sec_etc = 0;
1334 #endif
1335
1336 if (hashes_all_ms)
1337 {
1338 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1339
1340 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1341
1342 sec_etc = ms_left / 1000;
1343 }
1344
1345 if (sec_etc == 0)
1346 {
1347 //log_info ("Time.Estimated.: 0 secs");
1348 }
1349 else if ((u64) sec_etc > ETC_MAX)
1350 {
1351 log_info ("Time.Estimated.: > 10 Years");
1352 }
1353 else
1354 {
1355 char display_etc[32] = { 0 };
1356
1357 struct tm tm_etc;
1358
1359 struct tm *tmp = NULL;
1360
1361 #ifdef WIN
1362
1363 tmp = _gmtime64 (&sec_etc);
1364
1365 #else
1366
1367 tmp = gmtime (&sec_etc);
1368
1369 #endif
1370
1371 if (tmp != NULL)
1372 {
1373 memset (&tm_etc, 0, sizeof (tm_etc));
1374
1375 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1376
1377 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1378
1379 time_t now;
1380
1381 time (&now);
1382
1383 now += sec_etc;
1384
1385 char *etc = ctime (&now);
1386
1387 size_t etc_len = strlen (etc);
1388
1389 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1390 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1391
1392 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1393 }
1394 }
1395 }
1396 }
1397
1398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1399 {
1400 hc_device_param_t *device_param = &data.devices_param[device_id];
1401
1402 if (device_param->skipped) continue;
1403
1404 char display_dev_cur[16] = { 0 };
1405
1406 strncpy (display_dev_cur, "0.00", 4);
1407
1408 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1409
1410 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1411 }
1412
1413 char display_all_cur[16] = { 0 };
1414
1415 strncpy (display_all_cur, "0.00", 4);
1416
1417 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1418
1419 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1420
1421 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1422 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1423
1424 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1425
1426 // crack-per-time
1427
1428 if (data.digests_cnt > 100)
1429 {
1430 time_t now = time (NULL);
1431
1432 int cpt_cur_min = 0;
1433 int cpt_cur_hour = 0;
1434 int cpt_cur_day = 0;
1435
1436 for (int i = 0; i < CPT_BUF; i++)
1437 {
1438 const uint cracked = data.cpt_buf[i].cracked;
1439 const time_t timestamp = data.cpt_buf[i].timestamp;
1440
1441 if ((timestamp + 60) > now)
1442 {
1443 cpt_cur_min += cracked;
1444 }
1445
1446 if ((timestamp + 3600) > now)
1447 {
1448 cpt_cur_hour += cracked;
1449 }
1450
1451 if ((timestamp + 86400) > now)
1452 {
1453 cpt_cur_day += cracked;
1454 }
1455 }
1456
1457 double ms_real = ms_running - ms_paused;
1458
1459 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1460 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1461 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1462
1463 if ((data.cpt_start + 86400) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_cur_hour,
1468 cpt_cur_day,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else if ((data.cpt_start + 3600) < now)
1474 {
1475 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_cur_min,
1477 cpt_cur_hour,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else if ((data.cpt_start + 60) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else
1491 {
1492 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 }
1498
1499 // Restore point
1500
1501 u64 restore_point = get_lowest_words_done ();
1502
1503 u64 restore_total = data.words_base;
1504
1505 float percent_restore = 0;
1506
1507 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1508
1509 if (progress_end_relative_skip)
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1514 float percent_rejected = 0.0;
1515
1516 if (progress_cur)
1517 {
1518 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1519 }
1520
1521 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1522 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1523
1524 if (data.restore_disable == 0)
1525 {
1526 if (percent_finished != 1)
1527 {
1528 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1529 }
1530 }
1531 }
1532 }
1533 else
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539
1540 if (data.restore_disable == 0)
1541 {
1542 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1543 }
1544 }
1545 else
1546 {
1547 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1548 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1549
1550 // --restore not allowed if stdin is used -- really? why?
1551
1552 //if (data.restore_disable == 0)
1553 //{
1554 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1555 //}
1556 }
1557 }
1558
1559 #ifdef HAVE_HWMON
1560 if (data.gpu_temp_disable == 0)
1561 {
1562 hc_thread_mutex_lock (mux_adl);
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hc_device_param_t *device_param = &data.devices_param[device_id];
1567
1568 if (device_param->skipped) continue;
1569
1570 #define HM_STR_BUF_SIZE 255
1571
1572 if (data.hm_device[device_id].fan_supported == 1)
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1577
1578 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1579 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1580
1581 if (device_param->vendor_id == VENDOR_ID_AMD)
1582 {
1583 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1584 }
1585 else if (device_param->vendor_id == VENDOR_ID_NV)
1586 {
1587 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1588 }
1589
1590 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1591 }
1592 else
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596
1597 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1598 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1599
1600 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1601 }
1602 }
1603
1604 hc_thread_mutex_unlock (mux_adl);
1605 }
1606 #endif // HAVE_HWMON
1607 }
1608
1609 static void status_benchmark ()
1610 {
1611 if (data.devices_status == STATUS_INIT) return;
1612 if (data.devices_status == STATUS_STARTING) return;
1613
1614 if (data.words_cnt == 0) return;
1615
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 float hashes_all_ms = 0;
1630
1631 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 hashes_dev_ms[device_id] = 0;
1640
1641 if (speed_ms[device_id])
1642 {
1643 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1644
1645 hashes_all_ms += hashes_dev_ms[device_id];
1646 }
1647 }
1648
1649 /**
1650 * exec time
1651 */
1652
1653 double exec_all_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1662
1663 exec_all_ms[device_id] = exec_ms_avg;
1664 }
1665
1666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667 {
1668 hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670 if (device_param->skipped) continue;
1671
1672 char display_dev_cur[16] = { 0 };
1673
1674 strncpy (display_dev_cur, "0.00", 4);
1675
1676 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1677
1678 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1679 }
1680
1681 char display_all_cur[16] = { 0 };
1682
1683 strncpy (display_all_cur, "0.00", 4);
1684
1685 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1686
1687 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1688 }
1689
1690 /**
1691 * oclHashcat -only- functions
1692 */
1693
1694 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1695 {
1696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1697 {
1698 if (attack_kern == ATTACK_KERN_STRAIGHT)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_COMBI)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_BF)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1704 }
1705 else
1706 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1707 }
1708
1709 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1710 {
1711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1712 {
1713 if (attack_kern == ATTACK_KERN_STRAIGHT)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_COMBI)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_BF)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 }
1720 else
1721 {
1722 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 }
1724 }
1725
1726 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1727 {
1728 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1729 {
1730 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1731 }
1732 else
1733 {
1734 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1735 }
1736 }
1737
1738 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1739 {
1740 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1741 {
1742 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1743 }
1744 else
1745 {
1746 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1747 }
1748 }
1749
1750 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1753 }
1754
1755 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1756 {
1757 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1758 }
1759
1760 static uint convert_from_hex (char *line_buf, const uint line_len)
1761 {
1762 if (line_len & 1) return (line_len); // not in hex
1763
1764 if (data.hex_wordlist == 1)
1765 {
1766 uint i;
1767 uint j;
1768
1769 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1770 {
1771 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1772 }
1773
1774 memset (line_buf + i, 0, line_len - i);
1775
1776 return (i);
1777 }
1778 else if (line_len >= 6) // $HEX[] = 6
1779 {
1780 if (line_buf[0] != '$') return (line_len);
1781 if (line_buf[1] != 'H') return (line_len);
1782 if (line_buf[2] != 'E') return (line_len);
1783 if (line_buf[3] != 'X') return (line_len);
1784 if (line_buf[4] != '[') return (line_len);
1785 if (line_buf[line_len - 1] != ']') return (line_len);
1786
1787 uint i;
1788 uint j;
1789
1790 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1791 {
1792 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1793 }
1794
1795 memset (line_buf + i, 0, line_len - i);
1796
1797 return (i);
1798 }
1799
1800 return (line_len);
1801 }
1802
1803 static void clear_prompt ()
1804 {
1805 fputc ('\r', stdout);
1806
1807 for (size_t i = 0; i < strlen (PROMPT); i++)
1808 {
1809 fputc (' ', stdout);
1810 }
1811
1812 fputc ('\r', stdout);
1813
1814 fflush (stdout);
1815 }
1816
1817 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1818 {
1819 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1820 }
1821
1822 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1823 {
1824 char *outfile = data.outfile;
1825 uint quiet = data.quiet;
1826 FILE *pot_fp = data.pot_fp;
1827 uint loopback = data.loopback;
1828 uint debug_mode = data.debug_mode;
1829 char *debug_file = data.debug_file;
1830
1831 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1832 int debug_rule_len = 0; // -1 error
1833 uint debug_plain_len = 0;
1834
1835 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1836
1837 // hash
1838
1839 char out_buf[HCBUFSIZ] = { 0 };
1840
1841 ascii_digest (out_buf, salt_pos, digest_pos);
1842
1843 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1844
1845 // plain
1846
1847 plain_t plain;
1848
1849 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1850
1851 uint gidvid = plain.gidvid;
1852 uint il_pos = plain.il_pos;
1853
1854 u64 crackpos = device_param->words_off;
1855
1856 uint plain_buf[16] = { 0 };
1857
1858 u8 *plain_ptr = (u8 *) plain_buf;
1859 unsigned int plain_len = 0;
1860
1861 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1862 {
1863 u64 gidd = gidvid;
1864 u64 gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.i[j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 const uint off = device_param->innerloop_pos + il_pos;
1878
1879 if (debug_mode > 0)
1880 {
1881 debug_rule_len = 0;
1882
1883 // save rule
1884 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1885 {
1886 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1887
1888 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1889 }
1890
1891 // save plain
1892 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1895
1896 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1897
1898 debug_plain_len = plain_len;
1899 }
1900 }
1901
1902 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1903
1904 crackpos += gidvid;
1905 crackpos *= data.kernel_rules_cnt;
1906 crackpos += device_param->innerloop_pos + il_pos;
1907
1908 if (plain_len > data.pw_max) plain_len = data.pw_max;
1909 }
1910 else if (data.attack_mode == ATTACK_MODE_COMBI)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1927 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1928
1929 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1930 {
1931 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1932 }
1933 else
1934 {
1935 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1936
1937 memcpy (plain_ptr, comb_buf, comb_len);
1938 }
1939
1940 plain_len += comb_len;
1941
1942 crackpos += gidvid;
1943 crackpos *= data.combs_cnt;
1944 crackpos += device_param->innerloop_pos + il_pos;
1945
1946 if (data.pw_max != PW_DICTMAX1)
1947 {
1948 if (plain_len > data.pw_max) plain_len = data.pw_max;
1949 }
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_BF)
1952 {
1953 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1954 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1955
1956 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1957 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1958
1959 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1960 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1961
1962 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1963 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1964
1965 plain_len = data.css_cnt;
1966
1967 crackpos += gidvid;
1968 crackpos *= data.bfs_cnt;
1969 crackpos += device_param->innerloop_pos + il_pos;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.i[j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1988
1989 uint start = 0;
1990 uint stop = device_param->kernel_params_mp_buf32[4];
1991
1992 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1993
1994 plain_len += start + stop;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.i[j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 memmove (plain_ptr + stop, plain_ptr, plain_len);
2027
2028 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041
2042 if (data.attack_mode == ATTACK_MODE_BF)
2043 {
2044 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2045 {
2046 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2047 {
2048 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2049 {
2050 plain_len = plain_len - data.salts_buf[0].salt_len;
2051 }
2052 }
2053
2054 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2055 {
2056 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2057 {
2058 plain_ptr[j] = plain_ptr[i];
2059 }
2060
2061 plain_len = plain_len / 2;
2062 }
2063 }
2064 }
2065
2066 // if enabled, update also the potfile
2067
2068 if (pot_fp)
2069 {
2070 lock_file (pot_fp);
2071
2072 fprintf (pot_fp, "%s:", out_buf);
2073
2074 format_plain (pot_fp, plain_ptr, plain_len, 1);
2075
2076 fputc ('\n', pot_fp);
2077
2078 fflush (pot_fp);
2079
2080 unlock_file (pot_fp);
2081 }
2082
2083 // outfile
2084
2085 FILE *out_fp = NULL;
2086
2087 if (outfile != NULL)
2088 {
2089 if ((out_fp = fopen (outfile, "ab")) == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2092
2093 out_fp = stdout;
2094 }
2095 lock_file (out_fp);
2096 }
2097 else
2098 {
2099 out_fp = stdout;
2100
2101 if (quiet == 0) clear_prompt ();
2102 }
2103
2104 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2105
2106 if (outfile != NULL)
2107 {
2108 if (out_fp != stdout)
2109 {
2110 fclose (out_fp);
2111 }
2112 }
2113 else
2114 {
2115 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2116 {
2117 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2118 {
2119 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2120 if (quiet == 0) fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 // loopback
2126
2127 if (loopback)
2128 {
2129 char *loopback_file = data.loopback_file;
2130
2131 FILE *fb_fp = NULL;
2132
2133 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2134 {
2135 lock_file (fb_fp);
2136
2137 format_plain (fb_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', fb_fp);
2140
2141 fclose (fb_fp);
2142 }
2143 }
2144
2145 // (rule) debug mode
2146
2147 // the next check implies that:
2148 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2149 // - debug_mode > 0
2150
2151 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2152 {
2153 if (debug_rule_len < 0) debug_rule_len = 0;
2154
2155 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2156
2157 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2158
2159 if ((quiet == 0) && (debug_file == NULL))
2160 {
2161 fprintf (stdout, "%s", PROMPT);
2162 fflush (stdout);
2163 }
2164 }
2165 }
2166
2167 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2168 {
2169 salt_t *salt_buf = &data.salts_buf[salt_pos];
2170
2171 int found = 0;
2172
2173 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2174
2175 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2176
2177 if (found == 1)
2178 {
2179 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2180
2181 log_info_nn ("");
2182
2183 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2184
2185 uint cpt_cracked = 0;
2186
2187 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2188 {
2189 uint idx = salt_buf->digests_offset + digest_pos;
2190
2191 if (data.digests_shown_tmp[idx] == 0) continue;
2192
2193 if (data.digests_shown[idx] == 1) continue;
2194
2195 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2196 {
2197 data.digests_shown[idx] = 1;
2198
2199 data.digests_done++;
2200
2201 cpt_cracked++;
2202
2203 salt_buf->digests_done++;
2204
2205 if (salt_buf->digests_done == salt_buf->digests_cnt)
2206 {
2207 data.salts_shown[salt_pos] = 1;
2208
2209 data.salts_done++;
2210 }
2211 }
2212
2213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2214
2215 check_hash (device_param, salt_pos, digest_pos);
2216 }
2217
2218 if (cpt_cracked > 0)
2219 {
2220 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2221 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2222
2223 data.cpt_pos++;
2224
2225 data.cpt_total += cpt_cracked;
2226
2227 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2228 }
2229
2230 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2231 {
2232 // we need to reset cracked state on the device
2233 // otherwise host thinks again and again the hash was cracked
2234 // and returns invalid password each time
2235
2236 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2237
2238 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2239 }
2240
2241 memset (device_param->result, 0, device_param->size_results);
2242
2243 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2244 }
2245 }
2246
2247 static void save_hash ()
2248 {
2249 char *hashfile = data.hashfile;
2250
2251 char new_hashfile[256] = { 0 };
2252 char old_hashfile[256] = { 0 };
2253
2254 snprintf (new_hashfile, 255, "%s.new", hashfile);
2255 snprintf (old_hashfile, 255, "%s.old", hashfile);
2256
2257 unlink (new_hashfile);
2258
2259 char separator = data.separator;
2260
2261 FILE *fp = fopen (new_hashfile, "wb");
2262
2263 if (fp == NULL)
2264 {
2265 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2266
2267 exit (-1);
2268 }
2269
2270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2271 {
2272 if (data.salts_shown[salt_pos] == 1) continue;
2273
2274 salt_t *salt_buf = &data.salts_buf[salt_pos];
2275
2276 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2277 {
2278 uint idx = salt_buf->digests_offset + digest_pos;
2279
2280 if (data.digests_shown[idx] == 1) continue;
2281
2282 if (data.hash_mode != 2500)
2283 {
2284 char out_buf[HCBUFSIZ] = { 0 };
2285
2286 if (data.username == 1)
2287 {
2288 user_t *user = data.hash_info[idx]->user;
2289
2290 uint i;
2291
2292 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2293
2294 fputc (separator, fp);
2295 }
2296
2297 ascii_digest (out_buf, salt_pos, digest_pos);
2298
2299 fputs (out_buf, fp);
2300
2301 log_out (fp, "");
2302 }
2303 else
2304 {
2305 hccap_t hccap;
2306
2307 to_hccap_t (&hccap, salt_pos, digest_pos);
2308
2309 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2310 }
2311 }
2312 }
2313
2314 fflush (fp);
2315
2316 fclose (fp);
2317
2318 unlink (old_hashfile);
2319
2320 if (rename (hashfile, old_hashfile) != 0)
2321 {
2322 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 unlink (hashfile);
2328
2329 if (rename (new_hashfile, hashfile) != 0)
2330 {
2331 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 unlink (old_hashfile);
2337 }
2338
2339 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2340 {
2341 // function called only in case kernel_power_all > words_left
2342
2343 float kernel_power_div = (float) (total_left) / kernel_power_all;
2344
2345 kernel_power_div += kernel_power_div / 100;
2346
2347 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2348
2349 while (kernel_power_new < total_left)
2350 {
2351 kernel_power_div += kernel_power_div / 100;
2352
2353 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2354 }
2355
2356 if (data.quiet == 0)
2357 {
2358 clear_prompt ();
2359
2360 log_info ("");
2361
2362 log_info ("INFO: approaching final keyspace, workload adjusted");
2363
2364 log_info ("");
2365
2366 fprintf (stdout, "%s", PROMPT);
2367
2368 fflush (stdout);
2369 }
2370
2371 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2372
2373 return kernel_power_div;
2374 }
2375
2376 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2377 {
2378 uint num_elements = num;
2379
2380 device_param->kernel_params_buf32[30] = data.combs_mode;
2381 device_param->kernel_params_buf32[31] = num;
2382
2383 uint kernel_threads = device_param->kernel_threads;
2384
2385 while (num_elements % kernel_threads) num_elements++;
2386
2387 cl_kernel kernel = NULL;
2388
2389 switch (kern_run)
2390 {
2391 case KERN_RUN_1: kernel = device_param->kernel1; break;
2392 case KERN_RUN_12: kernel = device_param->kernel12; break;
2393 case KERN_RUN_2: kernel = device_param->kernel2; break;
2394 case KERN_RUN_23: kernel = device_param->kernel23; break;
2395 case KERN_RUN_3: kernel = device_param->kernel3; break;
2396 }
2397
2398 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2399 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2400 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2401 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2402 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2403 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2404 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2405 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2406 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2407 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2408 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2409
2410 hc_timer_t timer;
2411
2412 hc_timer_set (&timer);
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2420 }
2421 else
2422 {
2423 size_t workgroup_size = 0;
2424
2425 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2426
2427 if (kern_run == KERN_RUN_2)
2428 {
2429 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2430 {
2431 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2432 }
2433 }
2434
2435 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 const size_t global_work_size[3] = { num_elements, 1, 1 };
2440 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2443 }
2444
2445 hc_clFlush (data.ocl, device_param->command_queue);
2446
2447 hc_clFinish (data.ocl, device_param->command_queue);
2448
2449 if (event_update)
2450 {
2451 double exec_time;
2452
2453 hc_timer_get (timer, exec_time);
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468 }
2469
2470 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2471 {
2472 uint num_elements = num;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2477 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2478 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2479 }
2480
2481 // causes problems with special threads like in bcrypt
2482 // const uint kernel_threads = device_param->kernel_threads;
2483
2484 uint kernel_threads = KERNEL_THREADS;
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 cl_kernel kernel = NULL;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2493 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2494 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2495 }
2496
2497 switch (kern_run)
2498 {
2499 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2500 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2501 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2502 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2503 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2504 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2505 break;
2506 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2507 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2508 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2509 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2510 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2511 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2512 break;
2513 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2514 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2515 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2516 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2517 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2518 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2519 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2520 break;
2521 }
2522
2523 size_t workgroup_size = 0;
2524 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2525 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2531
2532 hc_clFlush (data.ocl, device_param->command_queue);
2533
2534 hc_clFinish (data.ocl, device_param->command_queue);
2535 }
2536
2537 static void run_kernel_tm (hc_device_param_t *device_param)
2538 {
2539 const uint num_elements = 1024; // fixed
2540
2541 uint kernel_threads = 32;
2542
2543 cl_kernel kernel = device_param->kernel_tm;
2544
2545 size_t workgroup_size = 0;
2546 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2547 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2553
2554 hc_clFlush (data.ocl, device_param->command_queue);
2555
2556 hc_clFinish (data.ocl, device_param->command_queue);
2557 }
2558
2559 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2560 {
2561 uint num_elements = num;
2562
2563 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2564 device_param->kernel_params_amp_buf32[6] = num_elements;
2565
2566 // causes problems with special threads like in bcrypt
2567 // const uint kernel_threads = device_param->kernel_threads;
2568
2569 uint kernel_threads = KERNEL_THREADS;
2570
2571 while (num_elements % kernel_threads) num_elements++;
2572
2573 cl_kernel kernel = device_param->kernel_amp;
2574
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2577
2578 size_t workgroup_size = 0;
2579 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2580 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2581
2582 const size_t global_work_size[3] = { num_elements, 1, 1 };
2583 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2584
2585 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2586
2587 hc_clFlush (data.ocl, device_param->command_queue);
2588
2589 hc_clFinish (data.ocl, device_param->command_queue);
2590 }
2591
2592 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2593 {
2594 int rc = -1;
2595
2596 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2597 {
2598 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2599
2600 const cl_uchar zero = 0;
2601
2602 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2603 }
2604
2605 if (rc != 0)
2606 {
2607 // NOTE: clEnqueueFillBuffer () always fails with -59
2608 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2609 // How's that possible, OpenCL 1.2 support is advertised??
2610 // We need to workaround...
2611
2612 #define FILLSZ 0x100000
2613
2614 char *tmp = (char *) mymalloc (FILLSZ);
2615
2616 for (uint i = 0; i < size; i += FILLSZ)
2617 {
2618 const int left = size - i;
2619
2620 const int fillsz = MIN (FILLSZ, left);
2621
2622 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2623 }
2624
2625 myfree (tmp);
2626 }
2627 }
2628
2629 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2630 {
2631 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2632 {
2633 if (attack_mode == ATTACK_MODE_BF)
2634 {
2635 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2636 {
2637 const uint size_tm = 32 * sizeof (bs_word_t);
2638
2639 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2640
2641 run_kernel_tm (device_param);
2642
2643 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2644 }
2645 }
2646
2647 if (highest_pw_len < 16)
2648 {
2649 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2650 }
2651 else if (highest_pw_len < 32)
2652 {
2653 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2654 }
2655 else
2656 {
2657 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2658 }
2659 }
2660 else
2661 {
2662 run_kernel_amp (device_param, pws_cnt);
2663
2664 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2665
2666 if (opts_type & OPTS_TYPE_HOOK12)
2667 {
2668 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2669 }
2670
2671 uint iter = salt_buf->salt_iter;
2672
2673 uint loop_step = device_param->kernel_loops;
2674
2675 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2676 {
2677 uint loop_left = iter - loop_pos;
2678
2679 loop_left = MIN (loop_left, loop_step);
2680
2681 device_param->kernel_params_buf32[25] = loop_pos;
2682 device_param->kernel_params_buf32[26] = loop_left;
2683
2684 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2685
2686 if (data.devices_status == STATUS_CRACKED) break;
2687 if (data.devices_status == STATUS_ABORTED) break;
2688 if (data.devices_status == STATUS_QUIT) break;
2689
2690 /**
2691 * speed
2692 */
2693
2694 const float iter_part = (float) (loop_pos + loop_left) / iter;
2695
2696 const u64 perf_sum_all = pws_cnt * iter_part;
2697
2698 double speed_ms;
2699
2700 hc_timer_get (device_param->timer_speed, speed_ms);
2701
2702 const u32 speed_pos = device_param->speed_pos;
2703
2704 device_param->speed_cnt[speed_pos] = perf_sum_all;
2705
2706 device_param->speed_ms[speed_pos] = speed_ms;
2707 }
2708
2709 if (opts_type & OPTS_TYPE_HOOK23)
2710 {
2711 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2712
2713 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2714
2715 // do something with data
2716
2717 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2718 }
2719
2720 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2721 }
2722 }
2723
2724 static int run_rule_engine (const int rule_len, const char *rule_buf)
2725 {
2726 if (rule_len == 0)
2727 {
2728 return 0;
2729 }
2730 else if (rule_len == 1)
2731 {
2732 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2733 }
2734
2735 return 1;
2736 }
2737
2738 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2739 {
2740 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2741 {
2742 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2743 }
2744 else if (data.attack_kern == ATTACK_KERN_COMBI)
2745 {
2746 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2747 {
2748 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2749 {
2750 for (u32 i = 0; i < pws_cnt; i++)
2751 {
2752 const u32 pw_len = device_param->pws_buf[i].pw_len;
2753
2754 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2755
2756 ptr[pw_len] = 0x01;
2757 }
2758 }
2759 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x80;
2768 }
2769 }
2770 }
2771
2772 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2773 }
2774 else if (data.attack_kern == ATTACK_KERN_BF)
2775 {
2776 const u64 off = device_param->words_off;
2777
2778 device_param->kernel_params_mp_l_buf64[3] = off;
2779
2780 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2781 }
2782 }
2783
2784 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2785 {
2786 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2787
2788 device_param->kernel_params_buf32[26] = kernel_loops;
2789 device_param->kernel_params_buf32[27] = kernel_loops;
2790
2791 // init some fake words
2792
2793 for (u32 i = 0; i < kernel_power; i++)
2794 {
2795 device_param->pws_buf[i].i[0] = i;
2796 device_param->pws_buf[i].i[1] = 0x01234567;
2797 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2798 }
2799
2800 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2801
2802 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2803 {
2804 run_kernel_amp (device_param, kernel_power);
2805 }
2806
2807 // caching run
2808
2809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2810 {
2811 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2812 }
2813 else
2814 {
2815 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2816 }
2817
2818 // now user repeats
2819
2820 for (int i = 0; i < repeat; i++)
2821 {
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2829 }
2830 }
2831
2832 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2833
2834 // reset fake words
2835
2836 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2837
2838 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2839 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2840
2841 return exec_ms_prev;
2842 }
2843
2844 static void autotune (hc_device_param_t *device_param)
2845 {
2846 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2847
2848 const u32 kernel_accel_min = device_param->kernel_accel_min;
2849 const u32 kernel_accel_max = device_param->kernel_accel_max;
2850
2851 const u32 kernel_loops_min = device_param->kernel_loops_min;
2852 const u32 kernel_loops_max = device_param->kernel_loops_max;
2853
2854 u32 kernel_accel = kernel_accel_min;
2855 u32 kernel_loops = kernel_loops_min;
2856
2857 // steps
2858
2859 #define STEPS_CNT 10
2860
2861 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2862 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2863
2864 u32 steps_accel[STEPS_ACCEL_CNT];
2865 u32 steps_loops[STEPS_LOOPS_CNT];
2866
2867 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2868 {
2869 steps_accel[i] = 1 << i;
2870 }
2871
2872 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2873 {
2874 steps_loops[i] = 1 << i;
2875 }
2876
2877 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2878 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2879
2880 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2881 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2882
2883 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2884 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2885
2886 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2887
2888 u32 kernel_loops_tmp;
2889
2890 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2891 {
2892 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2893
2894 if (exec_ms < target_ms) break;
2895 }
2896
2897 // kernel-accel
2898
2899 if (kernel_accel_min < kernel_accel_max)
2900 {
2901 double e_best = 0;
2902
2903 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2904 {
2905 const u32 kernel_accel_try = steps_accel[i];
2906
2907 if (kernel_accel_try < kernel_accel_min) continue;
2908 if (kernel_accel_try > kernel_accel_max) break;
2909
2910 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2911
2912 if (exec_ms > target_ms) break;
2913
2914 const double e = kernel_accel_try / exec_ms;
2915
2916 if (e > e_best)
2917 {
2918 kernel_accel = kernel_accel_try;
2919
2920 e_best = e;
2921 }
2922 }
2923 }
2924
2925 // kernel-loops final
2926
2927 if (kernel_loops_min < kernel_loops_max)
2928 {
2929 double e_best = 0;
2930
2931 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2932 {
2933 const u32 kernel_loops_try = steps_loops[i];
2934
2935 if (kernel_loops_try < kernel_loops_min) continue;
2936 if (kernel_loops_try > kernel_loops_max) break;
2937
2938 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2939
2940 if (exec_ms > target_ms) break;
2941
2942 const double e = kernel_loops_try / exec_ms;
2943
2944 if (e > e_best)
2945 {
2946 kernel_loops = kernel_loops_try;
2947
2948 e_best = e;
2949 }
2950 }
2951 }
2952
2953 // final balance
2954
2955 u32 kernel_accel_best = kernel_accel;
2956 u32 kernel_loops_best = kernel_loops;
2957
2958 u32 exec_best = -1;
2959
2960 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2961 {
2962 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2963
2964 exec_best = exec_ms;
2965 }
2966
2967 // reset
2968
2969 if (kernel_accel_min < kernel_accel_max)
2970 {
2971 u32 kernel_accel_try = kernel_accel;
2972 u32 kernel_loops_try = kernel_loops;
2973
2974 for (int i = 0; i < 2; i++)
2975 {
2976 kernel_accel_try >>= 1;
2977 kernel_loops_try <<= 1;
2978
2979 if (kernel_accel_try < kernel_accel_min) break;
2980 if (kernel_loops_try > kernel_loops_max) break;
2981
2982 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2983
2984 if (exec_ms < exec_best)
2985 {
2986 kernel_accel_best = kernel_accel_try;
2987 kernel_loops_best = kernel_loops_try;
2988
2989 exec_best = exec_ms;
2990 }
2991 }
2992 }
2993
2994 // reset
2995
2996 if (kernel_loops_min < kernel_loops_max)
2997 {
2998 u32 kernel_accel_try = kernel_accel;
2999 u32 kernel_loops_try = kernel_loops;
3000
3001 for (int i = 0; i < 2; i++)
3002 {
3003 kernel_accel_try <<= 1;
3004 kernel_loops_try >>= 1;
3005
3006 if (kernel_accel_try > kernel_accel_max) break;
3007 if (kernel_loops_try < kernel_loops_min) break;
3008
3009 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3010
3011 if (exec_ms < exec_best)
3012 {
3013 kernel_accel_best = kernel_accel_try;
3014 kernel_loops_best = kernel_loops_try;
3015
3016 exec_best = exec_ms;
3017 }
3018 }
3019 }
3020
3021 // reset timer
3022
3023 device_param->exec_pos = 0;
3024
3025 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3026
3027 // store
3028
3029 kernel_accel = kernel_accel_best;
3030 kernel_loops = kernel_loops_best;
3031
3032 device_param->kernel_accel = kernel_accel;
3033 device_param->kernel_loops = kernel_loops;
3034
3035 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3036
3037 device_param->kernel_power = kernel_power;
3038
3039 #ifdef DEBUG
3040
3041 if (data.quiet == 0)
3042 {
3043 clear_prompt ();
3044
3045 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3046 "Device #%u: autotuned kernel-loops to %u\n",
3047 device_param->device_id + 1,
3048 kernel_accel,
3049 device_param->device_id + 1,
3050 kernel_loops);
3051
3052 fprintf (stdout, "%s", PROMPT);
3053 fflush (stdout);
3054 }
3055
3056 #endif
3057 }
3058
3059 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3060 {
3061 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3062
3063 // init speed timer
3064
3065 uint speed_pos = device_param->speed_pos;
3066
3067 #ifdef _POSIX
3068 if (device_param->timer_speed.tv_sec == 0)
3069 {
3070 hc_timer_set (&device_param->timer_speed);
3071 }
3072 #endif
3073
3074 #ifdef _WIN
3075 if (device_param->timer_speed.QuadPart == 0)
3076 {
3077 hc_timer_set (&device_param->timer_speed);
3078 }
3079 #endif
3080
3081 // find higest password length, this is for optimization stuff
3082
3083 uint highest_pw_len = 0;
3084
3085 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3086 {
3087 }
3088 else if (data.attack_kern == ATTACK_KERN_COMBI)
3089 {
3090 }
3091 else if (data.attack_kern == ATTACK_KERN_BF)
3092 {
3093 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3094 + device_param->kernel_params_mp_l_buf32[5];
3095 }
3096
3097 // iteration type
3098
3099 uint innerloop_step = 0;
3100 uint innerloop_cnt = 0;
3101
3102 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3103 else innerloop_step = 1;
3104
3105 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3106 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3107 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3108
3109 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3110
3111 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3112 {
3113 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3114
3115 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3116
3117 if (data.devices_status == STATUS_CRACKED) break;
3118 if (data.devices_status == STATUS_ABORTED) break;
3119 if (data.devices_status == STATUS_QUIT) break;
3120 if (data.devices_status == STATUS_BYPASS) break;
3121
3122 salt_t *salt_buf = &data.salts_buf[salt_pos];
3123
3124 device_param->kernel_params_buf32[24] = salt_pos;
3125 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3126 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3127
3128 FILE *combs_fp = device_param->combs_fp;
3129
3130 if (data.attack_mode == ATTACK_MODE_COMBI)
3131 {
3132 rewind (combs_fp);
3133 }
3134
3135 // innerloops
3136
3137 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3138 {
3139 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3140
3141 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3142
3143 if (data.devices_status == STATUS_CRACKED) break;
3144 if (data.devices_status == STATUS_ABORTED) break;
3145 if (data.devices_status == STATUS_QUIT) break;
3146 if (data.devices_status == STATUS_BYPASS) break;
3147
3148 uint innerloop_left = innerloop_cnt - innerloop_pos;
3149
3150 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3151
3152 device_param->innerloop_pos = innerloop_pos;
3153 device_param->innerloop_left = innerloop_left;
3154
3155 device_param->kernel_params_buf32[27] = innerloop_left;
3156
3157 // i think we can get rid of this
3158 if (innerloop_left == 0)
3159 {
3160 puts ("bug, how should this happen????\n");
3161
3162 continue;
3163 }
3164
3165 if (data.salts_shown[salt_pos] == 1)
3166 {
3167 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3168
3169 continue;
3170 }
3171
3172 // initialize amplifiers
3173
3174 if (data.attack_mode == ATTACK_MODE_COMBI)
3175 {
3176 uint i = 0;
3177
3178 while (i < innerloop_left)
3179 {
3180 if (feof (combs_fp)) break;
3181
3182 int line_len = fgetl (combs_fp, line_buf);
3183
3184 if (line_len >= PW_MAX1) continue;
3185
3186 line_len = convert_from_hex (line_buf, line_len);
3187
3188 char *line_buf_new = line_buf;
3189
3190 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3191 {
3192 char rule_buf_out[BLOCK_SIZE] = { 0 };
3193
3194 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3195
3196 if (rule_len_out < 0)
3197 {
3198 data.words_progress_rejected[salt_pos] += pws_cnt;
3199
3200 continue;
3201 }
3202
3203 line_len = rule_len_out;
3204
3205 line_buf_new = rule_buf_out;
3206 }
3207
3208 line_len = MIN (line_len, PW_DICTMAX);
3209
3210 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3211
3212 memcpy (ptr, line_buf_new, line_len);
3213
3214 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3215
3216 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3217 {
3218 uppercase (ptr, line_len);
3219 }
3220
3221 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3222 {
3223 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3224 {
3225 ptr[line_len] = 0x80;
3226 }
3227
3228 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3229 {
3230 ptr[line_len] = 0x01;
3231 }
3232 }
3233
3234 device_param->combs_buf[i].pw_len = line_len;
3235
3236 i++;
3237 }
3238
3239 for (uint j = i; j < innerloop_left; j++)
3240 {
3241 device_param->combs_buf[j].i[0] = 0;
3242 device_param->combs_buf[j].i[1] = 0;
3243 device_param->combs_buf[j].i[2] = 0;
3244 device_param->combs_buf[j].i[3] = 0;
3245 device_param->combs_buf[j].i[4] = 0;
3246 device_param->combs_buf[j].i[5] = 0;
3247 device_param->combs_buf[j].i[6] = 0;
3248 device_param->combs_buf[j].i[7] = 0;
3249
3250 device_param->combs_buf[j].pw_len = 0;
3251 }
3252
3253 innerloop_left = i;
3254 }
3255 else if (data.attack_mode == ATTACK_MODE_BF)
3256 {
3257 u64 off = innerloop_pos;
3258
3259 device_param->kernel_params_mp_r_buf64[3] = off;
3260
3261 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3262 }
3263 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3264 {
3265 u64 off = innerloop_pos;
3266
3267 device_param->kernel_params_mp_buf64[3] = off;
3268
3269 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3270 }
3271 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3272 {
3273 u64 off = innerloop_pos;
3274
3275 device_param->kernel_params_mp_buf64[3] = off;
3276
3277 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3278 }
3279
3280 // copy amplifiers
3281
3282 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3283 {
3284 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);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_COMBI)
3287 {
3288 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);
3289 }
3290 else if (data.attack_mode == ATTACK_MODE_BF)
3291 {
3292 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);
3293 }
3294 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3295 {
3296 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);
3297 }
3298 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3299 {
3300 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);
3301 }
3302
3303 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3304
3305 if (data.benchmark == 1)
3306 {
3307 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3308
3309 // a few caching rounds
3310
3311 for (u32 i = 0; i < 2; i++)
3312 {
3313 hc_timer_set (&device_param->timer_speed);
3314
3315 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3316
3317 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3318
3319 exec_ms_avg_prev = exec_ms_avg;
3320 }
3321
3322 // benchmark_repeats became a maximum possible repeats
3323
3324 for (u32 i = 2; i < data.benchmark_repeats; i++)
3325 {
3326 hc_timer_set (&device_param->timer_speed);
3327
3328 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3329
3330 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3331
3332 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3333
3334 exec_ms_avg_prev = exec_ms_avg;
3335 }
3336 }
3337
3338 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3339
3340 if (data.devices_status == STATUS_CRACKED) break;
3341 if (data.devices_status == STATUS_ABORTED) break;
3342 if (data.devices_status == STATUS_QUIT) break;
3343
3344 /**
3345 * result
3346 */
3347
3348 hc_thread_mutex_lock (mux_display);
3349
3350 check_cracked (device_param, salt_pos);
3351
3352 hc_thread_mutex_unlock (mux_display);
3353
3354 /**
3355 * progress
3356 */
3357
3358 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3359
3360 hc_thread_mutex_lock (mux_counter);
3361
3362 data.words_progress_done[salt_pos] += perf_sum_all;
3363
3364 hc_thread_mutex_unlock (mux_counter);
3365
3366 /**
3367 * speed
3368 */
3369
3370 double speed_ms;
3371
3372 hc_timer_get (device_param->timer_speed, speed_ms);
3373
3374 hc_timer_set (&device_param->timer_speed);
3375
3376 hc_thread_mutex_lock (mux_display);
3377
3378 // current speed
3379
3380 device_param->speed_cnt[speed_pos] = perf_sum_all;
3381
3382 device_param->speed_ms[speed_pos] = speed_ms;
3383
3384 hc_thread_mutex_unlock (mux_display);
3385
3386 speed_pos++;
3387
3388 if (speed_pos == SPEED_CACHE)
3389 {
3390 speed_pos = 0;
3391 }
3392
3393 /**
3394 * benchmark
3395 */
3396
3397 if (data.benchmark == 1) break;
3398 }
3399 }
3400
3401 device_param->speed_pos = speed_pos;
3402
3403 myfree (line_buf);
3404 }
3405
3406 static void load_segment (wl_data_t *wl_data, FILE *fd)
3407 {
3408 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3409
3410 wl_data->pos = 0;
3411
3412 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3413
3414 wl_data->buf[wl_data->cnt] = 0;
3415
3416 if (wl_data->cnt == 0) return;
3417
3418 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3419
3420 while (!feof (fd))
3421 {
3422 if (wl_data->cnt == wl_data->avail)
3423 {
3424 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3425
3426 wl_data->avail += wl_data->incr;
3427 }
3428
3429 const int c = fgetc (fd);
3430
3431 if (c == EOF) break;
3432
3433 wl_data->buf[wl_data->cnt] = (char) c;
3434
3435 wl_data->cnt++;
3436
3437 if (c == '\n') break;
3438 }
3439
3440 // ensure stream ends with a newline
3441
3442 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3443 {
3444 wl_data->cnt++;
3445
3446 wl_data->buf[wl_data->cnt - 1] = '\n';
3447 }
3448
3449 return;
3450 }
3451
3452 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3453 {
3454 char *ptr = buf;
3455
3456 for (u32 i = 0; i < sz; i++, ptr++)
3457 {
3458 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3459
3460 if (i == 7)
3461 {
3462 *off = i;
3463 *len = i;
3464
3465 return;
3466 }
3467
3468 if (*ptr != '\n') continue;
3469
3470 *off = i + 1;
3471
3472 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3473
3474 *len = i;
3475
3476 return;
3477 }
3478
3479 *off = sz;
3480 *len = sz;
3481 }
3482
3483 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3484 {
3485 char *ptr = buf;
3486
3487 for (u32 i = 0; i < sz; i++, ptr++)
3488 {
3489 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3490
3491 if (*ptr != '\n') continue;
3492
3493 *off = i + 1;
3494
3495 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3496
3497 *len = i;
3498
3499 return;
3500 }
3501
3502 *off = sz;
3503 *len = sz;
3504 }
3505
3506 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3507 {
3508 char *ptr = buf;
3509
3510 for (u32 i = 0; i < sz; i++, ptr++)
3511 {
3512 if (*ptr != '\n') continue;
3513
3514 *off = i + 1;
3515
3516 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3517
3518 *len = i;
3519
3520 return;
3521 }
3522
3523 *off = sz;
3524 *len = sz;
3525 }
3526
3527 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3528 {
3529 while (wl_data->pos < wl_data->cnt)
3530 {
3531 uint off;
3532 uint len;
3533
3534 char *ptr = wl_data->buf + wl_data->pos;
3535
3536 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3537
3538 wl_data->pos += off;
3539
3540 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3541 {
3542 char rule_buf_out[BLOCK_SIZE] = { 0 };
3543
3544 int rule_len_out = -1;
3545
3546 if (len < BLOCK_SIZE)
3547 {
3548 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3549 }
3550
3551 if (rule_len_out < 0)
3552 {
3553 continue;
3554 }
3555
3556 if (rule_len_out > PW_MAX)
3557 {
3558 continue;
3559 }
3560 }
3561 else
3562 {
3563 if (len > PW_MAX)
3564 {
3565 continue;
3566 }
3567 }
3568
3569 *out_buf = ptr;
3570 *out_len = len;
3571
3572 return;
3573 }
3574
3575 if (feof (fd))
3576 {
3577 fprintf (stderr, "BUG feof()!!\n");
3578
3579 return;
3580 }
3581
3582 load_segment (wl_data, fd);
3583
3584 get_next_word (wl_data, fd, out_buf, out_len);
3585 }
3586
3587 #ifdef _POSIX
3588 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3589 #endif
3590
3591 #ifdef _WIN
3592 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3593 #endif
3594 {
3595 hc_signal (NULL);
3596
3597 dictstat_t d;
3598
3599 d.cnt = 0;
3600
3601 #ifdef _POSIX
3602 fstat (fileno (fd), &d.stat);
3603 #endif
3604
3605 #ifdef _WIN
3606 _fstat64 (fileno (fd), &d.stat);
3607 #endif
3608
3609 d.stat.st_mode = 0;
3610 d.stat.st_nlink = 0;
3611 d.stat.st_uid = 0;
3612 d.stat.st_gid = 0;
3613 d.stat.st_rdev = 0;
3614 d.stat.st_atime = 0;
3615
3616 #ifdef _POSIX
3617 d.stat.st_blksize = 0;
3618 d.stat.st_blocks = 0;
3619 #endif
3620
3621 if (d.stat.st_size == 0) return 0;
3622
3623 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3624
3625 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3626 {
3627 if (d_cache)
3628 {
3629 u64 cnt = d_cache->cnt;
3630
3631 u64 keyspace = cnt;
3632
3633 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3634 {
3635 keyspace *= data.kernel_rules_cnt;
3636 }
3637 else if (data.attack_kern == ATTACK_KERN_COMBI)
3638 {
3639 keyspace *= data.combs_cnt;
3640 }
3641
3642 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);
3643 if (data.quiet == 0) log_info ("");
3644
3645 hc_signal (sigHandler_default);
3646
3647 return (keyspace);
3648 }
3649 }
3650
3651 time_t now = 0;
3652 time_t prev = 0;
3653
3654 u64 comp = 0;
3655 u64 cnt = 0;
3656 u64 cnt2 = 0;
3657
3658 while (!feof (fd))
3659 {
3660 load_segment (wl_data, fd);
3661
3662 comp += wl_data->cnt;
3663
3664 u32 i = 0;
3665
3666 while (i < wl_data->cnt)
3667 {
3668 u32 len;
3669 u32 off;
3670
3671 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3672
3673 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3674 {
3675 char rule_buf_out[BLOCK_SIZE] = { 0 };
3676
3677 int rule_len_out = -1;
3678
3679 if (len < BLOCK_SIZE)
3680 {
3681 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3682 }
3683
3684 if (rule_len_out < 0)
3685 {
3686 len = PW_MAX1;
3687 }
3688 else
3689 {
3690 len = rule_len_out;
3691 }
3692 }
3693
3694 if (len < PW_MAX1)
3695 {
3696 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3697 {
3698 cnt += data.kernel_rules_cnt;
3699 }
3700 else if (data.attack_kern == ATTACK_KERN_COMBI)
3701 {
3702 cnt += data.combs_cnt;
3703 }
3704
3705 d.cnt++;
3706 }
3707
3708 i += off;
3709
3710 cnt2++;
3711 }
3712
3713 time (&now);
3714
3715 if ((now - prev) == 0) continue;
3716
3717 float percent = (float) comp / (float) d.stat.st_size;
3718
3719 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);
3720
3721 time (&prev);
3722 }
3723
3724 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);
3725 if (data.quiet == 0) log_info ("");
3726
3727 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3728
3729 hc_signal (sigHandler_default);
3730
3731 return (cnt);
3732 }
3733
3734 static void *thread_monitor (void *p)
3735 {
3736 uint runtime_check = 0;
3737 uint remove_check = 0;
3738 uint status_check = 0;
3739 uint restore_check = 0;
3740
3741 uint restore_left = data.restore_timer;
3742 uint remove_left = data.remove_timer;
3743 uint status_left = data.status_timer;
3744
3745 #ifdef HAVE_HWMON
3746 uint hwmon_check = 0;
3747
3748 // these variables are mainly used for fan control (AMD only)
3749
3750 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3751
3752 // temperature controller "loopback" values
3753
3754 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3755 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756
3757 #ifdef HAVE_ADL
3758 int temp_threshold = 1; // degrees celcius
3759
3760 int fan_speed_min = 15; // in percentage
3761 int fan_speed_max = 100;
3762 #endif // HAVE_ADL
3763
3764 time_t last_temp_check_time;
3765 #endif // HAVE_HWMON
3766
3767 uint sleep_time = 1;
3768
3769 if (data.runtime)
3770 {
3771 runtime_check = 1;
3772 }
3773
3774 if (data.restore_timer)
3775 {
3776 restore_check = 1;
3777 }
3778
3779 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3780 {
3781 remove_check = 1;
3782 }
3783
3784 if (data.status == 1)
3785 {
3786 status_check = 1;
3787 }
3788
3789 #ifdef HAVE_HWMON
3790 if (data.gpu_temp_disable == 0)
3791 {
3792 time (&last_temp_check_time);
3793
3794 hwmon_check = 1;
3795 }
3796 #endif
3797
3798 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3799 {
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 0)
3802 #endif
3803 return (p);
3804 }
3805
3806 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3807 {
3808 hc_sleep (sleep_time);
3809
3810 if (data.devices_status != STATUS_RUNNING) continue;
3811
3812 #ifdef HAVE_HWMON
3813 if (hwmon_check == 1)
3814 {
3815 hc_thread_mutex_lock (mux_adl);
3816
3817 time_t temp_check_time;
3818
3819 time (&temp_check_time);
3820
3821 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3822
3823 if (Ta == 0) Ta = 1;
3824
3825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3826 {
3827 hc_device_param_t *device_param = &data.devices_param[device_id];
3828
3829 if (device_param->skipped) continue;
3830
3831 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3832
3833 const int temperature = hm_get_temperature_with_device_id (device_id);
3834
3835 if (temperature > (int) data.gpu_temp_abort)
3836 {
3837 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3838
3839 if (data.devices_status != STATUS_QUIT) myabort ();
3840
3841 break;
3842 }
3843
3844 #ifdef HAVE_ADL
3845 const int gpu_temp_retain = data.gpu_temp_retain;
3846
3847 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3848 {
3849 if (data.hm_device[device_id].fan_supported == 1)
3850 {
3851 int temp_cur = temperature;
3852
3853 int temp_diff_new = gpu_temp_retain - temp_cur;
3854
3855 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3856
3857 // calculate Ta value (time difference in seconds between the last check and this check)
3858
3859 last_temp_check_time = temp_check_time;
3860
3861 float Kp = 1.8;
3862 float Ki = 0.005;
3863 float Kd = 6;
3864
3865 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3866
3867 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);
3868
3869 if (abs (fan_diff_required) >= temp_threshold)
3870 {
3871 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3872
3873 int fan_speed_level = fan_speed_cur;
3874
3875 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3876
3877 int fan_speed_new = fan_speed_level - fan_diff_required;
3878
3879 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3880 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3881
3882 if (fan_speed_new != fan_speed_cur)
3883 {
3884 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3885 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3886
3887 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3888 {
3889 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3890
3891 fan_speed_chgd[device_id] = 1;
3892 }
3893
3894 temp_diff_old[device_id] = temp_diff_new;
3895 }
3896 }
3897 }
3898 }
3899 #endif // HAVE_ADL
3900 }
3901
3902 hc_thread_mutex_unlock (mux_adl);
3903 }
3904 #endif // HAVE_HWMON
3905
3906 if (restore_check == 1)
3907 {
3908 restore_left--;
3909
3910 if (restore_left == 0)
3911 {
3912 if (data.restore_disable == 0) cycle_restore ();
3913
3914 restore_left = data.restore_timer;
3915 }
3916 }
3917
3918 if ((runtime_check == 1) && (data.runtime_start > 0))
3919 {
3920 time_t runtime_cur;
3921
3922 time (&runtime_cur);
3923
3924 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3925
3926 if (runtime_left <= 0)
3927 {
3928 if (data.benchmark == 0)
3929 {
3930 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3931 }
3932
3933 if (data.devices_status != STATUS_QUIT) myabort ();
3934 }
3935 }
3936
3937 if (remove_check == 1)
3938 {
3939 remove_left--;
3940
3941 if (remove_left == 0)
3942 {
3943 if (data.digests_saved != data.digests_done)
3944 {
3945 data.digests_saved = data.digests_done;
3946
3947 save_hash ();
3948 }
3949
3950 remove_left = data.remove_timer;
3951 }
3952 }
3953
3954 if (status_check == 1)
3955 {
3956 status_left--;
3957
3958 if (status_left == 0)
3959 {
3960 hc_thread_mutex_lock (mux_display);
3961
3962 if (data.quiet == 0) clear_prompt ();
3963
3964 if (data.quiet == 0) log_info ("");
3965
3966 status_display ();
3967
3968 if (data.quiet == 0) log_info ("");
3969
3970 hc_thread_mutex_unlock (mux_display);
3971
3972 status_left = data.status_timer;
3973 }
3974 }
3975 }
3976
3977 #ifdef HAVE_HWMON
3978 myfree (fan_speed_chgd);
3979
3980 myfree (temp_diff_old);
3981 myfree (temp_diff_sum);
3982 #endif
3983
3984 p = NULL;
3985
3986 return (p);
3987 }
3988
3989 static void *thread_outfile_remove (void *p)
3990 {
3991 // some hash-dependent constants
3992 char *outfile_dir = data.outfile_check_directory;
3993 uint dgst_size = data.dgst_size;
3994 uint isSalted = data.isSalted;
3995 uint esalt_size = data.esalt_size;
3996 uint hash_mode = data.hash_mode;
3997
3998 uint outfile_check_timer = data.outfile_check_timer;
3999
4000 char separator = data.separator;
4001
4002 // some hash-dependent functions
4003 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4004 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4005
4006 // buffers
4007 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4008
4009 hash_buf.digest = mymalloc (dgst_size);
4010
4011 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4012
4013 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4014
4015 uint digest_buf[64] = { 0 };
4016
4017 outfile_data_t *out_info = NULL;
4018
4019 char **out_files = NULL;
4020
4021 time_t folder_mtime = 0;
4022
4023 int out_cnt = 0;
4024
4025 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4026
4027 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4028 {
4029 hc_sleep (1);
4030
4031 if (data.devices_status != STATUS_RUNNING) continue;
4032
4033 check_left--;
4034
4035 if (check_left == 0)
4036 {
4037 struct stat outfile_check_stat;
4038
4039 if (stat (outfile_dir, &outfile_check_stat) == 0)
4040 {
4041 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4042
4043 if (is_dir == 1)
4044 {
4045 if (outfile_check_stat.st_mtime > folder_mtime)
4046 {
4047 char **out_files_new = scan_directory (outfile_dir);
4048
4049 int out_cnt_new = count_dictionaries (out_files_new);
4050
4051 outfile_data_t *out_info_new = NULL;
4052
4053 if (out_cnt_new > 0)
4054 {
4055 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4056
4057 for (int i = 0; i < out_cnt_new; i++)
4058 {
4059 out_info_new[i].file_name = out_files_new[i];
4060
4061 // check if there are files that we have seen/checked before (and not changed)
4062
4063 for (int j = 0; j < out_cnt; j++)
4064 {
4065 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4066 {
4067 struct stat outfile_stat;
4068
4069 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4070 {
4071 if (outfile_stat.st_ctime == out_info[j].ctime)
4072 {
4073 out_info_new[i].ctime = out_info[j].ctime;
4074 out_info_new[i].seek = out_info[j].seek;
4075 }
4076 }
4077 }
4078 }
4079 }
4080 }
4081
4082 local_free (out_info);
4083 local_free (out_files);
4084
4085 out_files = out_files_new;
4086 out_cnt = out_cnt_new;
4087 out_info = out_info_new;
4088
4089 folder_mtime = outfile_check_stat.st_mtime;
4090 }
4091
4092 for (int j = 0; j < out_cnt; j++)
4093 {
4094 FILE *fp = fopen (out_info[j].file_name, "rb");
4095
4096 if (fp != NULL)
4097 {
4098 //hc_thread_mutex_lock (mux_display);
4099
4100 #ifdef _POSIX
4101 struct stat outfile_stat;
4102
4103 fstat (fileno (fp), &outfile_stat);
4104 #endif
4105
4106 #ifdef _WIN
4107 struct stat64 outfile_stat;
4108
4109 _fstat64 (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 if (outfile_stat.st_ctime > out_info[j].ctime)
4113 {
4114 out_info[j].ctime = outfile_stat.st_ctime;
4115 out_info[j].seek = 0;
4116 }
4117
4118 fseek (fp, out_info[j].seek, SEEK_SET);
4119
4120 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4121
4122 while (!feof (fp))
4123 {
4124 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4125
4126 if (ptr == NULL) break;
4127
4128 int line_len = strlen (line_buf);
4129
4130 if (line_len <= 0) continue;
4131
4132 int iter = MAX_CUT_TRIES;
4133
4134 for (uint i = line_len - 1; i && iter; i--, line_len--)
4135 {
4136 if (line_buf[i] != separator) continue;
4137
4138 int parser_status = PARSER_OK;
4139
4140 if ((hash_mode != 2500) && (hash_mode != 6800))
4141 {
4142 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4143 }
4144
4145 uint found = 0;
4146
4147 if (parser_status == PARSER_OK)
4148 {
4149 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4150 {
4151 if (data.salts_shown[salt_pos] == 1) continue;
4152
4153 salt_t *salt_buf = &data.salts_buf[salt_pos];
4154
4155 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4156 {
4157 uint idx = salt_buf->digests_offset + digest_pos;
4158
4159 if (data.digests_shown[idx] == 1) continue;
4160
4161 uint cracked = 0;
4162
4163 if (hash_mode == 6800)
4164 {
4165 if (i == salt_buf->salt_len)
4166 {
4167 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4168 }
4169 }
4170 else if (hash_mode == 2500)
4171 {
4172 // BSSID : MAC1 : MAC2 (:plain)
4173 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4174 {
4175 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4176
4177 if (!cracked) continue;
4178
4179 // now compare MAC1 and MAC2 too, since we have this additional info
4180 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4181 char *mac2_pos = mac1_pos + 12 + 1;
4182
4183 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4184 wpa_t *wpa = &wpas[salt_pos];
4185
4186 // compare hex string(s) vs binary MAC address(es)
4187
4188 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4189 {
4190 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4191 {
4192 cracked = 0;
4193
4194 break;
4195 }
4196 }
4197
4198 // early skip ;)
4199 if (!cracked) continue;
4200
4201 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4202 {
4203 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4204 {
4205 cracked = 0;
4206
4207 break;
4208 }
4209 }
4210 }
4211 }
4212 else
4213 {
4214 char *digests_buf_ptr = (char *) data.digests_buf;
4215
4216 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4217
4218 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4219 }
4220
4221 if (cracked == 1)
4222 {
4223 found = 1;
4224
4225 data.digests_shown[idx] = 1;
4226
4227 data.digests_done++;
4228
4229 salt_buf->digests_done++;
4230
4231 if (salt_buf->digests_done == salt_buf->digests_cnt)
4232 {
4233 data.salts_shown[salt_pos] = 1;
4234
4235 data.salts_done++;
4236
4237 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4238 }
4239 }
4240 }
4241
4242 if (data.devices_status == STATUS_CRACKED) break;
4243 }
4244 }
4245
4246 if (found) break;
4247
4248 if (data.devices_status == STATUS_CRACKED) break;
4249
4250 iter--;
4251 }
4252
4253 if (data.devices_status == STATUS_CRACKED) break;
4254 }
4255
4256 myfree (line_buf);
4257
4258 out_info[j].seek = ftell (fp);
4259
4260 //hc_thread_mutex_unlock (mux_display);
4261
4262 fclose (fp);
4263 }
4264 }
4265 }
4266 }
4267
4268 check_left = outfile_check_timer;
4269 }
4270 }
4271
4272 if (esalt_size) local_free (hash_buf.esalt);
4273
4274 if (isSalted) local_free (hash_buf.salt);
4275
4276 local_free (hash_buf.digest);
4277
4278 local_free (out_info);
4279
4280 local_free (out_files);
4281
4282 p = NULL;
4283
4284 return (p);
4285 }
4286
4287 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4288 {
4289 if (device_param->pws_cnt < device_param->kernel_power)
4290 {
4291 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4292
4293 u8 *ptr = (u8 *) pw->i;
4294
4295 memcpy (ptr, pw_buf, pw_len);
4296
4297 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4298
4299 pw->pw_len = pw_len;
4300
4301 device_param->pws_cnt++;
4302 }
4303 else
4304 {
4305 fprintf (stderr, "BUG pw_add()!!\n");
4306
4307 return;
4308 }
4309 }
4310
4311 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4312 {
4313 hc_thread_mutex_lock (mux_dispatcher);
4314
4315 const u64 words_cur = data.words_cur;
4316 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4317
4318 device_param->words_off = words_cur;
4319
4320 const u64 words_left = words_base - words_cur;
4321
4322 if (allow_div)
4323 {
4324 if (data.kernel_power_all > words_left)
4325 {
4326 if (data.kernel_power_div == 0)
4327 {
4328 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4329 }
4330 }
4331
4332 if (data.kernel_power_div)
4333 {
4334 if (device_param->kernel_power == device_param->kernel_power_user)
4335 {
4336 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4337
4338 if (kernel_power_new < device_param->kernel_power)
4339 {
4340 device_param->kernel_power = kernel_power_new;
4341 }
4342 }
4343 }
4344 }
4345
4346 const uint kernel_power = device_param->kernel_power;
4347
4348 uint work = MIN (words_left, kernel_power);
4349
4350 work = MIN (work, max);
4351
4352 data.words_cur += work;
4353
4354 hc_thread_mutex_unlock (mux_dispatcher);
4355
4356 return work;
4357 }
4358
4359 static void *thread_calc_stdin (void *p)
4360 {
4361 hc_device_param_t *device_param = (hc_device_param_t *) p;
4362
4363 if (device_param->skipped) return NULL;
4364
4365 autotune (device_param);
4366
4367 char *buf = (char *) mymalloc (HCBUFSIZ);
4368
4369 const uint attack_kern = data.attack_kern;
4370
4371 const uint kernel_power = device_param->kernel_power;
4372
4373 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4374 {
4375 hc_thread_mutex_lock (mux_dispatcher);
4376
4377 if (feof (stdin) != 0)
4378 {
4379 hc_thread_mutex_unlock (mux_dispatcher);
4380
4381 break;
4382 }
4383
4384 uint words_cur = 0;
4385
4386 while (words_cur < kernel_power)
4387 {
4388 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4389
4390 if (line_buf == NULL) break;
4391
4392 uint line_len = in_superchop (line_buf);
4393
4394 line_len = convert_from_hex (line_buf, line_len);
4395
4396 // post-process rule engine
4397
4398 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4399 {
4400 char rule_buf_out[BLOCK_SIZE] = { 0 };
4401
4402 int rule_len_out = -1;
4403
4404 if (line_len < BLOCK_SIZE)
4405 {
4406 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4407 }
4408
4409 if (rule_len_out < 0) continue;
4410
4411 line_buf = rule_buf_out;
4412 line_len = rule_len_out;
4413 }
4414
4415 if (line_len > PW_MAX)
4416 {
4417 continue;
4418 }
4419
4420 if (attack_kern == ATTACK_KERN_STRAIGHT)
4421 {
4422 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436 else if (attack_kern == ATTACK_KERN_COMBI)
4437 {
4438 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4439 // since we still need to combine the plains
4440
4441 if (line_len > data.pw_max)
4442 {
4443 hc_thread_mutex_lock (mux_counter);
4444
4445 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4446 {
4447 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4448 }
4449
4450 hc_thread_mutex_unlock (mux_counter);
4451
4452 continue;
4453 }
4454 }
4455
4456 pw_add (device_param, (u8 *) line_buf, line_len);
4457
4458 words_cur++;
4459
4460 if (data.devices_status == STATUS_CRACKED) break;
4461 if (data.devices_status == STATUS_ABORTED) break;
4462 if (data.devices_status == STATUS_QUIT) break;
4463 if (data.devices_status == STATUS_BYPASS) break;
4464 }
4465
4466 hc_thread_mutex_unlock (mux_dispatcher);
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 // flush
4474
4475 const uint pws_cnt = device_param->pws_cnt;
4476
4477 if (pws_cnt)
4478 {
4479 run_copy (device_param, pws_cnt);
4480
4481 run_cracker (device_param, pws_cnt);
4482
4483 device_param->pws_cnt = 0;
4484
4485 if (attack_kern == ATTACK_KERN_STRAIGHT)
4486 {
4487 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4488 }
4489 else if (attack_kern == ATTACK_KERN_COMBI)
4490 {
4491 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4492 }
4493 }
4494 }
4495
4496 device_param->kernel_accel = 0;
4497 device_param->kernel_loops = 0;
4498
4499 myfree (buf);
4500
4501 return NULL;
4502 }
4503
4504 static void *thread_calc (void *p)
4505 {
4506 hc_device_param_t *device_param = (hc_device_param_t *) p;
4507
4508 if (device_param->skipped) return NULL;
4509
4510 autotune (device_param);
4511
4512 const uint attack_mode = data.attack_mode;
4513 const uint attack_kern = data.attack_kern;
4514
4515 if (attack_mode == ATTACK_MODE_BF)
4516 {
4517 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4518 {
4519 const uint work = get_work (device_param, -1, true);
4520
4521 if (work == 0) break;
4522
4523 const u64 words_off = device_param->words_off;
4524 const u64 words_fin = words_off + work;
4525
4526 const uint pws_cnt = work;
4527
4528 device_param->pws_cnt = pws_cnt;
4529
4530 if (pws_cnt)
4531 {
4532 run_copy (device_param, pws_cnt);
4533
4534 run_cracker (device_param, pws_cnt);
4535
4536 device_param->pws_cnt = 0;
4537
4538 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4539 }
4540
4541 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4542
4543 if (data.devices_status == STATUS_CRACKED) break;
4544 if (data.devices_status == STATUS_ABORTED) break;
4545 if (data.devices_status == STATUS_QUIT) break;
4546 if (data.devices_status == STATUS_BYPASS) break;
4547
4548 if (data.benchmark == 1) break;
4549
4550 device_param->words_done = words_fin;
4551 }
4552 }
4553 else
4554 {
4555 const uint segment_size = data.segment_size;
4556
4557 char *dictfile = data.dictfile;
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4562 {
4563 dictfile = data.dictfile2;
4564 }
4565 }
4566
4567 FILE *fd = fopen (dictfile, "rb");
4568
4569 if (fd == NULL)
4570 {
4571 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4572
4573 return NULL;
4574 }
4575
4576 if (attack_mode == ATTACK_MODE_COMBI)
4577 {
4578 const uint combs_mode = data.combs_mode;
4579
4580 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4581 {
4582 const char *dictfilec = data.dictfile2;
4583
4584 FILE *combs_fp = fopen (dictfilec, "rb");
4585
4586 if (combs_fp == NULL)
4587 {
4588 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4589
4590 fclose (fd);
4591
4592 return NULL;
4593 }
4594
4595 device_param->combs_fp = combs_fp;
4596 }
4597 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4598 {
4599 const char *dictfilec = data.dictfile;
4600
4601 FILE *combs_fp = fopen (dictfilec, "rb");
4602
4603 if (combs_fp == NULL)
4604 {
4605 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4606
4607 fclose (fd);
4608
4609 return NULL;
4610 }
4611
4612 device_param->combs_fp = combs_fp;
4613 }
4614 }
4615
4616 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4617
4618 wl_data->buf = (char *) mymalloc (segment_size);
4619 wl_data->avail = segment_size;
4620 wl_data->incr = segment_size;
4621 wl_data->cnt = 0;
4622 wl_data->pos = 0;
4623
4624 u64 words_cur = 0;
4625
4626 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4627 {
4628 u64 words_off = 0;
4629 u64 words_fin = 0;
4630
4631 bool allow_div = true;
4632
4633 u64 max = -1;
4634
4635 while (max)
4636 {
4637 const uint work = get_work (device_param, max, allow_div);
4638
4639 allow_div = false;
4640
4641 if (work == 0) break;
4642
4643 words_off = device_param->words_off;
4644 words_fin = words_off + work;
4645
4646 char *line_buf;
4647 uint line_len;
4648
4649 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4650
4651 max = 0;
4652
4653 for ( ; words_cur < words_fin; words_cur++)
4654 {
4655 get_next_word (wl_data, fd, &line_buf, &line_len);
4656
4657 line_len = convert_from_hex (line_buf, line_len);
4658
4659 // post-process rule engine
4660
4661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4662 {
4663 char rule_buf_out[BLOCK_SIZE] = { 0 };
4664
4665 int rule_len_out = -1;
4666
4667 if (line_len < BLOCK_SIZE)
4668 {
4669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4670 }
4671
4672 if (rule_len_out < 0) continue;
4673
4674 line_buf = rule_buf_out;
4675 line_len = rule_len_out;
4676 }
4677
4678 if (attack_kern == ATTACK_KERN_STRAIGHT)
4679 {
4680 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4681 {
4682 max++;
4683
4684 hc_thread_mutex_lock (mux_counter);
4685
4686 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4687 {
4688 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4689 }
4690
4691 hc_thread_mutex_unlock (mux_counter);
4692
4693 continue;
4694 }
4695 }
4696 else if (attack_kern == ATTACK_KERN_COMBI)
4697 {
4698 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4699 // since we still need to combine the plains
4700
4701 if (line_len > data.pw_max)
4702 {
4703 max++;
4704
4705 hc_thread_mutex_lock (mux_counter);
4706
4707 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4708 {
4709 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4710 }
4711
4712 hc_thread_mutex_unlock (mux_counter);
4713
4714 continue;
4715 }
4716 }
4717
4718 pw_add (device_param, (u8 *) line_buf, line_len);
4719
4720 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4721
4722 if (data.devices_status == STATUS_CRACKED) break;
4723 if (data.devices_status == STATUS_ABORTED) break;
4724 if (data.devices_status == STATUS_QUIT) break;
4725 if (data.devices_status == STATUS_BYPASS) break;
4726 }
4727
4728 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4729
4730 if (data.devices_status == STATUS_CRACKED) break;
4731 if (data.devices_status == STATUS_ABORTED) break;
4732 if (data.devices_status == STATUS_QUIT) break;
4733 if (data.devices_status == STATUS_BYPASS) break;
4734 }
4735
4736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4737
4738 if (data.devices_status == STATUS_CRACKED) break;
4739 if (data.devices_status == STATUS_ABORTED) break;
4740 if (data.devices_status == STATUS_QUIT) break;
4741 if (data.devices_status == STATUS_BYPASS) break;
4742
4743 //
4744 // flush
4745 //
4746
4747 const uint pws_cnt = device_param->pws_cnt;
4748
4749 if (pws_cnt)
4750 {
4751 run_copy (device_param, pws_cnt);
4752
4753 run_cracker (device_param, pws_cnt);
4754
4755 device_param->pws_cnt = 0;
4756
4757 if (attack_kern == ATTACK_KERN_STRAIGHT)
4758 {
4759 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4760 }
4761 else if (attack_kern == ATTACK_KERN_COMBI)
4762 {
4763 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4764 }
4765 }
4766
4767 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4768
4769 if (data.devices_status == STATUS_CRACKED) break;
4770 if (data.devices_status == STATUS_ABORTED) break;
4771 if (data.devices_status == STATUS_QUIT) break;
4772 if (data.devices_status == STATUS_BYPASS) break;
4773
4774 if (words_fin == 0) break;
4775
4776 device_param->words_done = words_fin;
4777 }
4778
4779 if (attack_mode == ATTACK_MODE_COMBI)
4780 {
4781 fclose (device_param->combs_fp);
4782 }
4783
4784 free (wl_data->buf);
4785 free (wl_data);
4786
4787 fclose (fd);
4788 }
4789
4790 device_param->kernel_accel = 0;
4791 device_param->kernel_loops = 0;
4792
4793 return NULL;
4794 }
4795
4796 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4797 {
4798 if (!device_param)
4799 {
4800 log_error ("ERROR: %s : Invalid argument", __func__);
4801
4802 exit (-1);
4803 }
4804
4805 salt_t *salt_buf = &data.salts_buf[salt_pos];
4806
4807 device_param->kernel_params_buf32[24] = salt_pos;
4808 device_param->kernel_params_buf32[27] = 1;
4809 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4810 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4811 device_param->kernel_params_buf32[30] = 0;
4812 device_param->kernel_params_buf32[31] = 1;
4813
4814 char *dictfile_old = data.dictfile;
4815
4816 const char *weak_hash_check = "weak-hash-check";
4817
4818 data.dictfile = (char *) weak_hash_check;
4819
4820 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4821
4822 data.kernel_rules_buf[0].cmds[0] = 0;
4823
4824 /**
4825 * run the kernel
4826 */
4827
4828 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4829 {
4830 run_kernel (KERN_RUN_1, device_param, 1, false);
4831 }
4832 else
4833 {
4834 run_kernel (KERN_RUN_1, device_param, 1, false);
4835
4836 uint loop_step = 16;
4837
4838 const uint iter = salt_buf->salt_iter;
4839
4840 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4841 {
4842 uint loop_left = iter - loop_pos;
4843
4844 loop_left = MIN (loop_left, loop_step);
4845
4846 device_param->kernel_params_buf32[25] = loop_pos;
4847 device_param->kernel_params_buf32[26] = loop_left;
4848
4849 run_kernel (KERN_RUN_2, device_param, 1, false);
4850 }
4851
4852 run_kernel (KERN_RUN_3, device_param, 1, false);
4853 }
4854
4855 /**
4856 * result
4857 */
4858
4859 check_cracked (device_param, salt_pos);
4860
4861 /**
4862 * cleanup
4863 */
4864
4865 device_param->kernel_params_buf32[24] = 0;
4866 device_param->kernel_params_buf32[25] = 0;
4867 device_param->kernel_params_buf32[26] = 0;
4868 device_param->kernel_params_buf32[27] = 0;
4869 device_param->kernel_params_buf32[28] = 0;
4870 device_param->kernel_params_buf32[29] = 0;
4871 device_param->kernel_params_buf32[30] = 0;
4872 device_param->kernel_params_buf32[31] = 0;
4873
4874 data.dictfile = dictfile_old;
4875
4876 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4877 }
4878
4879 // hlfmt hashcat
4880
4881 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4882 {
4883 if (data.username == 0)
4884 {
4885 *hashbuf_pos = line_buf;
4886 *hashbuf_len = line_len;
4887 }
4888 else
4889 {
4890 char *pos = line_buf;
4891 int len = line_len;
4892
4893 for (int i = 0; i < line_len; i++, pos++, len--)
4894 {
4895 if (line_buf[i] == data.separator)
4896 {
4897 pos++;
4898
4899 len--;
4900
4901 break;
4902 }
4903 }
4904
4905 *hashbuf_pos = pos;
4906 *hashbuf_len = len;
4907 }
4908 }
4909
4910 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4911 {
4912 char *pos = NULL;
4913 int len = 0;
4914
4915 int sep_cnt = 0;
4916
4917 for (int i = 0; i < line_len; i++)
4918 {
4919 if (line_buf[i] == data.separator)
4920 {
4921 sep_cnt++;
4922
4923 continue;
4924 }
4925
4926 if (sep_cnt == 0)
4927 {
4928 if (pos == NULL) pos = line_buf + i;
4929
4930 len++;
4931 }
4932 }
4933
4934 *userbuf_pos = pos;
4935 *userbuf_len = len;
4936 }
4937
4938 // hlfmt pwdump
4939
4940 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4941 {
4942 int sep_cnt = 0;
4943
4944 int sep2_len = 0;
4945 int sep3_len = 0;
4946
4947 for (int i = 0; i < line_len; i++)
4948 {
4949 if (line_buf[i] == ':')
4950 {
4951 sep_cnt++;
4952
4953 continue;
4954 }
4955
4956 if (sep_cnt == 2) sep2_len++;
4957 if (sep_cnt == 3) sep3_len++;
4958 }
4959
4960 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4961
4962 return 0;
4963 }
4964
4965 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4966 {
4967 char *pos = NULL;
4968 int len = 0;
4969
4970 int sep_cnt = 0;
4971
4972 for (int i = 0; i < line_len; i++)
4973 {
4974 if (line_buf[i] == ':')
4975 {
4976 sep_cnt++;
4977
4978 continue;
4979 }
4980
4981 if (data.hash_mode == 1000)
4982 {
4983 if (sep_cnt == 3)
4984 {
4985 if (pos == NULL) pos = line_buf + i;
4986
4987 len++;
4988 }
4989 }
4990 else if (data.hash_mode == 3000)
4991 {
4992 if (sep_cnt == 2)
4993 {
4994 if (pos == NULL) pos = line_buf + i;
4995
4996 len++;
4997 }
4998 }
4999 }
5000
5001 *hashbuf_pos = pos;
5002 *hashbuf_len = len;
5003 }
5004
5005 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5006 {
5007 char *pos = NULL;
5008 int len = 0;
5009
5010 int sep_cnt = 0;
5011
5012 for (int i = 0; i < line_len; i++)
5013 {
5014 if (line_buf[i] == ':')
5015 {
5016 sep_cnt++;
5017
5018 continue;
5019 }
5020
5021 if (sep_cnt == 0)
5022 {
5023 if (pos == NULL) pos = line_buf + i;
5024
5025 len++;
5026 }
5027 }
5028
5029 *userbuf_pos = pos;
5030 *userbuf_len = len;
5031 }
5032
5033 // hlfmt passwd
5034
5035 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5036 {
5037 int sep_cnt = 0;
5038
5039 char sep5_first = 0;
5040 char sep6_first = 0;
5041
5042 for (int i = 0; i < line_len; i++)
5043 {
5044 if (line_buf[i] == ':')
5045 {
5046 sep_cnt++;
5047
5048 continue;
5049 }
5050
5051 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5052 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5053 }
5054
5055 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5056
5057 return 0;
5058 }
5059
5060 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5061 {
5062 char *pos = NULL;
5063 int len = 0;
5064
5065 int sep_cnt = 0;
5066
5067 for (int i = 0; i < line_len; i++)
5068 {
5069 if (line_buf[i] == ':')
5070 {
5071 sep_cnt++;
5072
5073 continue;
5074 }
5075
5076 if (sep_cnt == 1)
5077 {
5078 if (pos == NULL) pos = line_buf + i;
5079
5080 len++;
5081 }
5082 }
5083
5084 *hashbuf_pos = pos;
5085 *hashbuf_len = len;
5086 }
5087
5088 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5089 {
5090 char *pos = NULL;
5091 int len = 0;
5092
5093 int sep_cnt = 0;
5094
5095 for (int i = 0; i < line_len; i++)
5096 {
5097 if (line_buf[i] == ':')
5098 {
5099 sep_cnt++;
5100
5101 continue;
5102 }
5103
5104 if (sep_cnt == 0)
5105 {
5106 if (pos == NULL) pos = line_buf + i;
5107
5108 len++;
5109 }
5110 }
5111
5112 *userbuf_pos = pos;
5113 *userbuf_len = len;
5114 }
5115
5116 // hlfmt shadow
5117
5118 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5119 {
5120 int sep_cnt = 0;
5121
5122 for (int i = 0; i < line_len; i++)
5123 {
5124 if (line_buf[i] == ':') sep_cnt++;
5125 }
5126
5127 if (sep_cnt == 8) return 1;
5128
5129 return 0;
5130 }
5131
5132 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5135 }
5136
5137 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5138 {
5139 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5140 }
5141
5142 // hlfmt main
5143
5144 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5145 {
5146 switch (hashfile_format)
5147 {
5148 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5149 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5150 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5151 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5152 }
5153 }
5154
5155 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5156 {
5157 switch (hashfile_format)
5158 {
5159 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5160 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5161 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5162 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5163 }
5164 }
5165
5166 char *strhlfmt (const uint hashfile_format)
5167 {
5168 switch (hashfile_format)
5169 {
5170 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5171 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5172 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5173 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5174 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5175 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5176 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5177 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5178 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5179 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5180 }
5181
5182 return ((char *) "Unknown");
5183 }
5184
5185 static uint hlfmt_detect (FILE *fp, uint max_check)
5186 {
5187 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5188
5189 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5190 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5191
5192 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5193
5194 uint num_check = 0;
5195
5196 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5197
5198 while (!feof (fp))
5199 {
5200 int line_len = fgetl (fp, line_buf);
5201
5202 if (line_len == 0) continue;
5203
5204 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5205 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5206 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5207
5208 if (num_check == max_check) break;
5209
5210 num_check++;
5211 }
5212
5213 myfree (line_buf);
5214
5215 uint hashlist_format = HLFMT_HASHCAT;
5216
5217 for (int i = 1; i < HLFMTS_CNT; i++)
5218 {
5219 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5220
5221 hashlist_format = i;
5222 }
5223
5224 free (formats_cnt);
5225
5226 return hashlist_format;
5227 }
5228
5229 /**
5230 * some further helper function
5231 */
5232
5233 // wrapper around mymalloc for ADL
5234
5235 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5236 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5237 {
5238 return mymalloc (iSize);
5239 }
5240 #endif
5241
5242 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)
5243 {
5244 u64 collisions = 0;
5245
5246 const uint dgst_pos0 = data.dgst_pos0;
5247 const uint dgst_pos1 = data.dgst_pos1;
5248 const uint dgst_pos2 = data.dgst_pos2;
5249 const uint dgst_pos3 = data.dgst_pos3;
5250
5251 memset (bitmap_a, 0, bitmap_size);
5252 memset (bitmap_b, 0, bitmap_size);
5253 memset (bitmap_c, 0, bitmap_size);
5254 memset (bitmap_d, 0, bitmap_size);
5255
5256 for (uint i = 0; i < digests_cnt; i++)
5257 {
5258 uint *digest_ptr = (uint *) digests_buf_ptr;
5259
5260 digests_buf_ptr += dgst_size;
5261
5262 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5263 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5264 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5265 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5266
5267 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5268 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5269 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5270 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5271
5272 if (bitmap_a[idx0] & val0) collisions++;
5273 if (bitmap_b[idx1] & val1) collisions++;
5274 if (bitmap_c[idx2] & val2) collisions++;
5275 if (bitmap_d[idx3] & val3) collisions++;
5276
5277 bitmap_a[idx0] |= val0;
5278 bitmap_b[idx1] |= val1;
5279 bitmap_c[idx2] |= val2;
5280 bitmap_d[idx3] |= val3;
5281
5282 if (collisions >= collisions_max) return 0x7fffffff;
5283 }
5284
5285 return collisions;
5286 }
5287
5288 /**
5289 * main
5290 */
5291
5292 int main (int argc, char **argv)
5293 {
5294 /**
5295 * To help users a bit
5296 */
5297
5298 char *compute = getenv ("COMPUTE");
5299
5300 if (compute)
5301 {
5302 static char display[100];
5303
5304 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5305
5306 putenv (display);
5307 }
5308 else
5309 {
5310 if (getenv ("DISPLAY") == NULL)
5311 putenv ((char *) "DISPLAY=:0");
5312 }
5313
5314 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5315 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5316
5317 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5318 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5319
5320 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5321 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5322
5323 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5324 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5325
5326 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5327 putenv ((char *) "POCL_KERNEL_CACHE=0");
5328
5329 /**
5330 * Real init
5331 */
5332
5333 memset (&data, 0, sizeof (hc_global_data_t));
5334
5335 time_t proc_start;
5336
5337 time (&proc_start);
5338
5339 data.proc_start = proc_start;
5340
5341 int myargc = argc;
5342 char **myargv = argv;
5343
5344 hc_thread_mutex_init (mux_dispatcher);
5345 hc_thread_mutex_init (mux_counter);
5346 hc_thread_mutex_init (mux_display);
5347 hc_thread_mutex_init (mux_adl);
5348
5349 /**
5350 * commandline parameters
5351 */
5352
5353 uint usage = USAGE;
5354 uint version = VERSION;
5355 uint quiet = QUIET;
5356 uint benchmark = BENCHMARK;
5357 uint benchmark_repeats = BENCHMARK_REPEATS;
5358 uint show = SHOW;
5359 uint left = LEFT;
5360 uint username = USERNAME;
5361 uint remove = REMOVE;
5362 uint remove_timer = REMOVE_TIMER;
5363 u64 skip = SKIP;
5364 u64 limit = LIMIT;
5365 uint keyspace = KEYSPACE;
5366 uint potfile_disable = POTFILE_DISABLE;
5367 char *potfile_path = NULL;
5368 uint debug_mode = DEBUG_MODE;
5369 char *debug_file = NULL;
5370 char *induction_dir = NULL;
5371 char *outfile_check_dir = NULL;
5372 uint force = FORCE;
5373 uint runtime = RUNTIME;
5374 uint hash_mode = HASH_MODE;
5375 uint attack_mode = ATTACK_MODE;
5376 uint markov_disable = MARKOV_DISABLE;
5377 uint markov_classic = MARKOV_CLASSIC;
5378 uint markov_threshold = MARKOV_THRESHOLD;
5379 char *markov_hcstat = NULL;
5380 char *outfile = NULL;
5381 uint outfile_format = OUTFILE_FORMAT;
5382 uint outfile_autohex = OUTFILE_AUTOHEX;
5383 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5384 uint restore = RESTORE;
5385 uint restore_timer = RESTORE_TIMER;
5386 uint restore_disable = RESTORE_DISABLE;
5387 uint status = STATUS;
5388 uint status_timer = STATUS_TIMER;
5389 uint status_automat = STATUS_AUTOMAT;
5390 uint loopback = LOOPBACK;
5391 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5392 char *session = NULL;
5393 uint hex_charset = HEX_CHARSET;
5394 uint hex_salt = HEX_SALT;
5395 uint hex_wordlist = HEX_WORDLIST;
5396 uint rp_gen = RP_GEN;
5397 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5398 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5399 uint rp_gen_seed = RP_GEN_SEED;
5400 char *rule_buf_l = (char *) RULE_BUF_L;
5401 char *rule_buf_r = (char *) RULE_BUF_R;
5402 uint increment = INCREMENT;
5403 uint increment_min = INCREMENT_MIN;
5404 uint increment_max = INCREMENT_MAX;
5405 char *cpu_affinity = NULL;
5406 OCL_PTR *ocl = NULL;
5407 char *opencl_devices = NULL;
5408 char *opencl_platforms = NULL;
5409 char *opencl_device_types = NULL;
5410 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5411 char *truecrypt_keyfiles = NULL;
5412 uint workload_profile = WORKLOAD_PROFILE;
5413 uint kernel_accel = KERNEL_ACCEL;
5414 uint kernel_loops = KERNEL_LOOPS;
5415 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5416 #ifdef HAVE_HWMON
5417 uint gpu_temp_abort = GPU_TEMP_ABORT;
5418 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5419 #ifdef HAVE_ADL
5420 uint powertune_enable = POWERTUNE_ENABLE;
5421 #endif
5422 #endif
5423 uint logfile_disable = LOGFILE_DISABLE;
5424 uint segment_size = SEGMENT_SIZE;
5425 uint scrypt_tmto = SCRYPT_TMTO;
5426 char separator = SEPARATOR;
5427 uint bitmap_min = BITMAP_MIN;
5428 uint bitmap_max = BITMAP_MAX;
5429 char *custom_charset_1 = NULL;
5430 char *custom_charset_2 = NULL;
5431 char *custom_charset_3 = NULL;
5432 char *custom_charset_4 = NULL;
5433
5434 #define IDX_HELP 'h'
5435 #define IDX_VERSION 'V'
5436 #define IDX_VERSION_LOWER 'v'
5437 #define IDX_QUIET 0xff02
5438 #define IDX_SHOW 0xff03
5439 #define IDX_LEFT 0xff04
5440 #define IDX_REMOVE 0xff05
5441 #define IDX_REMOVE_TIMER 0xff37
5442 #define IDX_SKIP 's'
5443 #define IDX_LIMIT 'l'
5444 #define IDX_KEYSPACE 0xff35
5445 #define IDX_POTFILE_DISABLE 0xff06
5446 #define IDX_POTFILE_PATH 0xffe0
5447 #define IDX_DEBUG_MODE 0xff43
5448 #define IDX_DEBUG_FILE 0xff44
5449 #define IDX_INDUCTION_DIR 0xff46
5450 #define IDX_OUTFILE_CHECK_DIR 0xff47
5451 #define IDX_USERNAME 0xff07
5452 #define IDX_FORCE 0xff08
5453 #define IDX_RUNTIME 0xff09
5454 #define IDX_BENCHMARK 'b'
5455 #define IDX_BENCHMARK_REPEATS 0xff78
5456 #define IDX_HASH_MODE 'm'
5457 #define IDX_ATTACK_MODE 'a'
5458 #define IDX_RP_FILE 'r'
5459 #define IDX_RP_GEN 'g'
5460 #define IDX_RP_GEN_FUNC_MIN 0xff10
5461 #define IDX_RP_GEN_FUNC_MAX 0xff11
5462 #define IDX_RP_GEN_SEED 0xff34
5463 #define IDX_RULE_BUF_L 'j'
5464 #define IDX_RULE_BUF_R 'k'
5465 #define IDX_INCREMENT 'i'
5466 #define IDX_INCREMENT_MIN 0xff12
5467 #define IDX_INCREMENT_MAX 0xff13
5468 #define IDX_OUTFILE 'o'
5469 #define IDX_OUTFILE_FORMAT 0xff14
5470 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5471 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5472 #define IDX_RESTORE 0xff15
5473 #define IDX_RESTORE_DISABLE 0xff27
5474 #define IDX_STATUS 0xff17
5475 #define IDX_STATUS_TIMER 0xff18
5476 #define IDX_STATUS_AUTOMAT 0xff50
5477 #define IDX_LOOPBACK 0xff38
5478 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5479 #define IDX_SESSION 0xff19
5480 #define IDX_HEX_CHARSET 0xff20
5481 #define IDX_HEX_SALT 0xff21
5482 #define IDX_HEX_WORDLIST 0xff40
5483 #define IDX_MARKOV_DISABLE 0xff22
5484 #define IDX_MARKOV_CLASSIC 0xff23
5485 #define IDX_MARKOV_THRESHOLD 't'
5486 #define IDX_MARKOV_HCSTAT 0xff24
5487 #define IDX_CPU_AFFINITY 0xff25
5488 #define IDX_OPENCL_DEVICES 'd'
5489 #define IDX_OPENCL_PLATFORMS 0xff72
5490 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5491 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5492 #define IDX_WORKLOAD_PROFILE 'w'
5493 #define IDX_KERNEL_ACCEL 'n'
5494 #define IDX_KERNEL_LOOPS 'u'
5495 #define IDX_GPU_TEMP_DISABLE 0xff29
5496 #define IDX_GPU_TEMP_ABORT 0xff30
5497 #define IDX_GPU_TEMP_RETAIN 0xff31
5498 #define IDX_POWERTUNE_ENABLE 0xff41
5499 #define IDX_LOGFILE_DISABLE 0xff51
5500 #define IDX_TRUECRYPT_KEYFILES 0xff52
5501 #define IDX_SCRYPT_TMTO 0xff61
5502 #define IDX_SEGMENT_SIZE 'c'
5503 #define IDX_SEPARATOR 'p'
5504 #define IDX_BITMAP_MIN 0xff70
5505 #define IDX_BITMAP_MAX 0xff71
5506 #define IDX_CUSTOM_CHARSET_1 '1'
5507 #define IDX_CUSTOM_CHARSET_2 '2'
5508 #define IDX_CUSTOM_CHARSET_3 '3'
5509 #define IDX_CUSTOM_CHARSET_4 '4'
5510
5511 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5512
5513 struct option long_options[] =
5514 {
5515 {"help", no_argument, 0, IDX_HELP},
5516 {"version", no_argument, 0, IDX_VERSION},
5517 {"quiet", no_argument, 0, IDX_QUIET},
5518 {"show", no_argument, 0, IDX_SHOW},
5519 {"left", no_argument, 0, IDX_LEFT},
5520 {"username", no_argument, 0, IDX_USERNAME},
5521 {"remove", no_argument, 0, IDX_REMOVE},
5522 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5523 {"skip", required_argument, 0, IDX_SKIP},
5524 {"limit", required_argument, 0, IDX_LIMIT},
5525 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5526 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5527 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5528 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5529 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5530 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5531 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5532 {"force", no_argument, 0, IDX_FORCE},
5533 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5534 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5535 {"restore", no_argument, 0, IDX_RESTORE},
5536 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5537 {"status", no_argument, 0, IDX_STATUS},
5538 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5539 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5540 {"loopback", no_argument, 0, IDX_LOOPBACK},
5541 {"weak-hash-threshold",
5542 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5543 {"session", required_argument, 0, IDX_SESSION},
5544 {"runtime", required_argument, 0, IDX_RUNTIME},
5545 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5546 {"generate-rules-func-min",
5547 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5548 {"generate-rules-func-max",
5549 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5550 {"generate-rules-seed",
5551 required_argument, 0, IDX_RP_GEN_SEED},
5552 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5553 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5554 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5555 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5556 {"rules-file", required_argument, 0, IDX_RP_FILE},
5557 {"outfile", required_argument, 0, IDX_OUTFILE},
5558 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5559 {"outfile-autohex-disable",
5560 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5561 {"outfile-check-timer",
5562 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5563 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5564 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5565 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5566 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5567 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5568 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5569 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5570 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5571 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5572 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5573 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5574 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5575 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5576 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5577 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5578 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5579 #ifdef HAVE_HWMON
5580 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5581 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5582 #ifdef HAVE_ADL
5583 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5584 #endif
5585 #endif // HAVE_HWMON
5586 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5587 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5588 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5589 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5590 // deprecated
5591 {"seperator", required_argument, 0, IDX_SEPARATOR},
5592 {"separator", required_argument, 0, IDX_SEPARATOR},
5593 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5594 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5595 {"increment", no_argument, 0, IDX_INCREMENT},
5596 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5597 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5598 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5599 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5600 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5601 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5602
5603 {0, 0, 0, 0}
5604 };
5605
5606 uint rp_files_cnt = 0;
5607
5608 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5609
5610 int option_index = 0;
5611 int c = -1;
5612
5613 optind = 1;
5614 optopt = 0;
5615
5616 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5617 {
5618 switch (c)
5619 {
5620 case IDX_HELP: usage = 1; break;
5621 case IDX_VERSION:
5622 case IDX_VERSION_LOWER: version = 1; break;
5623 case IDX_RESTORE: restore = 1; break;
5624 case IDX_SESSION: session = optarg; break;
5625 case IDX_SHOW: show = 1; break;
5626 case IDX_LEFT: left = 1; break;
5627 case '?': return (-1);
5628 }
5629 }
5630
5631 if (optopt != 0)
5632 {
5633 log_error ("ERROR: Invalid argument specified");
5634
5635 return (-1);
5636 }
5637
5638 /**
5639 * exit functions
5640 */
5641
5642 if (version)
5643 {
5644 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5645
5646 return (0);
5647 }
5648
5649 if (usage)
5650 {
5651 usage_big_print (PROGNAME);
5652
5653 return (0);
5654 }
5655
5656 /**
5657 * session needs to be set, always!
5658 */
5659
5660 if (session == NULL) session = (char *) PROGNAME;
5661
5662 /**
5663 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5664 */
5665
5666 char *exec_path = get_exec_path ();
5667
5668 #ifdef LINUX
5669
5670 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5671 char *resolved_exec_path = realpath (exec_path, NULL);
5672
5673 char *install_dir = get_install_dir (resolved_exec_path);
5674 char *profile_dir = NULL;
5675 char *session_dir = NULL;
5676 char *shared_dir = NULL;
5677
5678 if (strcmp (install_dir, resolved_install_folder) == 0)
5679 {
5680 struct passwd *pw = getpwuid (getuid ());
5681
5682 const char *homedir = pw->pw_dir;
5683
5684 profile_dir = get_profile_dir (homedir);
5685 session_dir = get_session_dir (profile_dir);
5686 shared_dir = strdup (SHARED_FOLDER);
5687
5688 mkdir (profile_dir, 0700);
5689 mkdir (session_dir, 0700);
5690 }
5691 else
5692 {
5693 profile_dir = install_dir;
5694 session_dir = install_dir;
5695 shared_dir = install_dir;
5696 }
5697
5698 myfree (resolved_install_folder);
5699 myfree (resolved_exec_path);
5700
5701 #else
5702
5703 char *install_dir = get_install_dir (exec_path);
5704 char *profile_dir = install_dir;
5705 char *session_dir = install_dir;
5706 char *shared_dir = install_dir;
5707
5708 #endif
5709
5710 data.install_dir = install_dir;
5711 data.profile_dir = profile_dir;
5712 data.session_dir = session_dir;
5713 data.shared_dir = shared_dir;
5714
5715 myfree (exec_path);
5716
5717 /**
5718 * kernel cache, we need to make sure folder exist
5719 */
5720
5721 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5722
5723 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5724
5725 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5726
5727 mkdir (kernels_folder, 0700);
5728
5729 myfree (kernels_folder);
5730
5731 /**
5732 * session
5733 */
5734
5735 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5736
5737 data.session = session;
5738
5739 char *eff_restore_file = (char *) mymalloc (session_size);
5740 char *new_restore_file = (char *) mymalloc (session_size);
5741
5742 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5743 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5744
5745 data.eff_restore_file = eff_restore_file;
5746 data.new_restore_file = new_restore_file;
5747
5748 if (((show == 1) || (left == 1)) && (restore == 1))
5749 {
5750 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5751 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5752
5753 return (-1);
5754 }
5755
5756 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5757 if ((show == 1) || (left == 1))
5758 {
5759 restore_disable = 1;
5760
5761 restore = 0;
5762 }
5763
5764 data.restore_disable = restore_disable;
5765
5766 restore_data_t *rd = init_restore (argc, argv);
5767
5768 data.rd = rd;
5769
5770 /**
5771 * restore file
5772 */
5773
5774 if (restore == 1)
5775 {
5776 read_restore (eff_restore_file, rd);
5777
5778 if (rd->version_bin < RESTORE_MIN)
5779 {
5780 log_error ("ERROR: Incompatible restore-file version");
5781
5782 return (-1);
5783 }
5784
5785 myargc = rd->argc;
5786 myargv = rd->argv;
5787
5788 #ifdef _POSIX
5789 rd->pid = getpid ();
5790 #elif _WIN
5791 rd->pid = GetCurrentProcessId ();
5792 #endif
5793 }
5794
5795 uint hash_mode_chgd = 0;
5796 uint runtime_chgd = 0;
5797 uint kernel_loops_chgd = 0;
5798 uint kernel_accel_chgd = 0;
5799 uint attack_mode_chgd = 0;
5800 uint outfile_format_chgd = 0;
5801 uint rp_gen_seed_chgd = 0;
5802 uint remove_timer_chgd = 0;
5803 uint increment_min_chgd = 0;
5804 uint increment_max_chgd = 0;
5805 uint workload_profile_chgd = 0;
5806 uint opencl_vector_width_chgd = 0;
5807
5808 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5809 uint gpu_temp_retain_chgd = 0;
5810 uint gpu_temp_abort_chgd = 0;
5811 #endif
5812
5813 optind = 1;
5814 optopt = 0;
5815 option_index = 0;
5816
5817 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5818 {
5819 switch (c)
5820 {
5821 //case IDX_HELP: usage = 1; break;
5822 //case IDX_VERSION: version = 1; break;
5823 //case IDX_RESTORE: restore = 1; break;
5824 case IDX_QUIET: quiet = 1; break;
5825 //case IDX_SHOW: show = 1; break;
5826 case IDX_SHOW: break;
5827 //case IDX_LEFT: left = 1; break;
5828 case IDX_LEFT: break;
5829 case IDX_USERNAME: username = 1; break;
5830 case IDX_REMOVE: remove = 1; break;
5831 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5832 remove_timer_chgd = 1; break;
5833 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5834 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5835 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5836 case IDX_DEBUG_FILE: debug_file = optarg; break;
5837 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5838 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5839 case IDX_FORCE: force = 1; break;
5840 case IDX_SKIP: skip = atoll (optarg); break;
5841 case IDX_LIMIT: limit = atoll (optarg); break;
5842 case IDX_KEYSPACE: keyspace = 1; break;
5843 case IDX_BENCHMARK: benchmark = 1; break;
5844 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5845 case IDX_RESTORE: break;
5846 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5847 case IDX_STATUS: status = 1; break;
5848 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5849 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5850 case IDX_LOOPBACK: loopback = 1; break;
5851 case IDX_WEAK_HASH_THRESHOLD:
5852 weak_hash_threshold = atoi (optarg); break;
5853 //case IDX_SESSION: session = optarg; break;
5854 case IDX_SESSION: break;
5855 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5856 hash_mode_chgd = 1; break;
5857 case IDX_RUNTIME: runtime = atoi (optarg);
5858 runtime_chgd = 1; break;
5859 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5860 attack_mode_chgd = 1; break;
5861 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5862 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5863 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5864 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5865 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5866 rp_gen_seed_chgd = 1; break;
5867 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5868 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5869 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5870 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5871 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5872 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5873 case IDX_OUTFILE: outfile = optarg; break;
5874 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5875 outfile_format_chgd = 1; break;
5876 case IDX_OUTFILE_AUTOHEX_DISABLE:
5877 outfile_autohex = 0; break;
5878 case IDX_OUTFILE_CHECK_TIMER:
5879 outfile_check_timer = atoi (optarg); break;
5880 case IDX_HEX_CHARSET: hex_charset = 1; break;
5881 case IDX_HEX_SALT: hex_salt = 1; break;
5882 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5883 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5884 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5885 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5886 case IDX_OPENCL_DEVICE_TYPES:
5887 opencl_device_types = optarg; break;
5888 case IDX_OPENCL_VECTOR_WIDTH:
5889 opencl_vector_width = atoi (optarg);
5890 opencl_vector_width_chgd = 1; break;
5891 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5892 workload_profile_chgd = 1; break;
5893 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5894 kernel_accel_chgd = 1; break;
5895 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5896 kernel_loops_chgd = 1; break;
5897 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5898 #ifdef HAVE_HWMON
5899 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5900 #ifdef HAVE_ADL
5901 gpu_temp_abort_chgd = 1;
5902 #endif
5903 break;
5904 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5905 #ifdef HAVE_ADL
5906 gpu_temp_retain_chgd = 1;
5907 #endif
5908 break;
5909 #ifdef HAVE_ADL
5910 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5911 #endif
5912 #endif // HAVE_HWMON
5913 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5914 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5915 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5916 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5917 case IDX_SEPARATOR: separator = optarg[0]; break;
5918 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5919 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5920 case IDX_INCREMENT: increment = 1; break;
5921 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5922 increment_min_chgd = 1; break;
5923 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5924 increment_max_chgd = 1; break;
5925 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5926 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5927 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5928 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5929
5930 default:
5931 log_error ("ERROR: Invalid argument specified");
5932 return (-1);
5933 }
5934 }
5935
5936 if (optopt != 0)
5937 {
5938 log_error ("ERROR: Invalid argument specified");
5939
5940 return (-1);
5941 }
5942
5943 /**
5944 * Inform user things getting started,
5945 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5946 * - we do not need to check algorithm_pos
5947 */
5948
5949 if (quiet == 0)
5950 {
5951 if (benchmark == 1)
5952 {
5953 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5954
5955 log_info ("");
5956 }
5957 else if (restore == 1)
5958 {
5959 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5960
5961 log_info ("");
5962 }
5963 else
5964 {
5965 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5966
5967 log_info ("");
5968 }
5969 }
5970
5971 /**
5972 * sanity check
5973 */
5974
5975 if (attack_mode > 7)
5976 {
5977 log_error ("ERROR: Invalid attack-mode specified");
5978
5979 return (-1);
5980 }
5981
5982 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5983 {
5984 log_error ("ERROR: Invalid runtime specified");
5985
5986 return (-1);
5987 }
5988
5989 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5990 {
5991 log_error ("ERROR: Invalid hash-type specified");
5992
5993 return (-1);
5994 }
5995
5996 // renamed hash modes
5997
5998 if (hash_mode_chgd)
5999 {
6000 int n = -1;
6001
6002 switch (hash_mode)
6003 {
6004 case 123: n = 124;
6005 break;
6006 }
6007
6008 if (n >= 0)
6009 {
6010 log_error ("Old -m specified, use -m %d instead", n);
6011
6012 return (-1);
6013 }
6014 }
6015
6016 if (username == 1)
6017 {
6018 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6019 {
6020 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6021
6022 return (-1);
6023 }
6024 }
6025
6026 if (outfile_format > 16)
6027 {
6028 log_error ("ERROR: Invalid outfile-format specified");
6029
6030 return (-1);
6031 }
6032
6033 if (left == 1)
6034 {
6035 if (outfile_format_chgd == 1)
6036 {
6037 if (outfile_format > 1)
6038 {
6039 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6040
6041 return (-1);
6042 }
6043 }
6044 else
6045 {
6046 outfile_format = OUTFILE_FMT_HASH;
6047 }
6048 }
6049
6050 if (show == 1)
6051 {
6052 if (outfile_format_chgd == 1)
6053 {
6054 if ((outfile_format > 7) && (outfile_format < 16))
6055 {
6056 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6057
6058 return (-1);
6059 }
6060 }
6061 }
6062
6063 if (increment_min < INCREMENT_MIN)
6064 {
6065 log_error ("ERROR: Invalid increment-min specified");
6066
6067 return (-1);
6068 }
6069
6070 if (increment_max > INCREMENT_MAX)
6071 {
6072 log_error ("ERROR: Invalid increment-max specified");
6073
6074 return (-1);
6075 }
6076
6077 if (increment_min > increment_max)
6078 {
6079 log_error ("ERROR: Invalid increment-min specified");
6080
6081 return (-1);
6082 }
6083
6084 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6085 {
6086 log_error ("ERROR: increment is not allowed in attack-mode 0");
6087
6088 return (-1);
6089 }
6090
6091 if ((increment == 0) && (increment_min_chgd == 1))
6092 {
6093 log_error ("ERROR: increment-min is only supported together with increment switch");
6094
6095 return (-1);
6096 }
6097
6098 if ((increment == 0) && (increment_max_chgd == 1))
6099 {
6100 log_error ("ERROR: increment-max is only supported together with increment switch");
6101
6102 return (-1);
6103 }
6104
6105 if (rp_files_cnt && rp_gen)
6106 {
6107 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6108
6109 return (-1);
6110 }
6111
6112 if (rp_files_cnt || rp_gen)
6113 {
6114 if (attack_mode != ATTACK_MODE_STRAIGHT)
6115 {
6116 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6117
6118 return (-1);
6119 }
6120 }
6121
6122 if (rp_gen_func_min > rp_gen_func_max)
6123 {
6124 log_error ("ERROR: Invalid rp-gen-func-min specified");
6125
6126 return (-1);
6127 }
6128
6129 if (kernel_accel_chgd == 1)
6130 {
6131 if (kernel_accel < 1)
6132 {
6133 log_error ("ERROR: Invalid kernel-accel specified");
6134
6135 return (-1);
6136 }
6137
6138 if (kernel_accel > 1024)
6139 {
6140 log_error ("ERROR: Invalid kernel-accel specified");
6141
6142 return (-1);
6143 }
6144 }
6145
6146 if (kernel_loops_chgd == 1)
6147 {
6148 if (kernel_loops < 1)
6149 {
6150 log_error ("ERROR: Invalid kernel-loops specified");
6151
6152 return (-1);
6153 }
6154
6155 if (kernel_loops > 1024)
6156 {
6157 log_error ("ERROR: Invalid kernel-loops specified");
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if ((workload_profile < 1) || (workload_profile > 3))
6164 {
6165 log_error ("ERROR: workload-profile %i not available", workload_profile);
6166
6167 return (-1);
6168 }
6169
6170 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6171 {
6172 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6173
6174 return (-1);
6175 }
6176
6177 if (show == 1 || left == 1)
6178 {
6179 attack_mode = ATTACK_MODE_NONE;
6180
6181 if (remove == 1)
6182 {
6183 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6184
6185 return (-1);
6186 }
6187
6188 if (potfile_disable == 1)
6189 {
6190 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6191
6192 return (-1);
6193 }
6194 }
6195
6196 uint attack_kern = ATTACK_KERN_NONE;
6197
6198 switch (attack_mode)
6199 {
6200 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6201 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6202 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6203 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6204 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6205 }
6206
6207 if (benchmark == 0)
6208 {
6209 if (keyspace == 1)
6210 {
6211 int num_additional_params = 1;
6212
6213 if (attack_kern == ATTACK_KERN_COMBI)
6214 {
6215 num_additional_params = 2;
6216 }
6217
6218 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6219
6220 if (keyspace_wordlist_specified == 0) optind--;
6221 }
6222
6223 if (attack_kern == ATTACK_KERN_NONE)
6224 {
6225 if ((optind + 1) != myargc)
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6233 {
6234 if ((optind + 1) > myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else if (attack_kern == ATTACK_KERN_COMBI)
6242 {
6243 if ((optind + 3) != myargc)
6244 {
6245 usage_mini_print (myargv[0]);
6246
6247 return (-1);
6248 }
6249 }
6250 else if (attack_kern == ATTACK_KERN_BF)
6251 {
6252 if ((optind + 1) > myargc)
6253 {
6254 usage_mini_print (myargv[0]);
6255
6256 return (-1);
6257 }
6258 }
6259 else
6260 {
6261 usage_mini_print (myargv[0]);
6262
6263 return (-1);
6264 }
6265 }
6266 else
6267 {
6268 if (myargv[optind] != 0)
6269 {
6270 log_error ("ERROR: Invalid argument for benchmark mode specified");
6271
6272 return (-1);
6273 }
6274
6275 if (attack_mode_chgd == 1)
6276 {
6277 if (attack_mode != ATTACK_MODE_BF)
6278 {
6279 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6280
6281 return (-1);
6282 }
6283 }
6284 }
6285
6286 if (skip != 0 && limit != 0)
6287 {
6288 limit += skip;
6289 }
6290
6291 if (keyspace == 1)
6292 {
6293 if (show == 1)
6294 {
6295 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6296
6297 return (-1);
6298 }
6299 else if (left == 1)
6300 {
6301 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6302
6303 return (-1);
6304 }
6305
6306 potfile_disable = 1;
6307
6308 restore_disable = 1;
6309
6310 restore = 0;
6311
6312 weak_hash_threshold = 0;
6313
6314 quiet = 1;
6315 }
6316
6317 if (remove_timer_chgd == 1)
6318 {
6319 if (remove == 0)
6320 {
6321 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6322
6323 return (-1);
6324 }
6325
6326 if (remove_timer < 1)
6327 {
6328 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6329
6330 return (-1);
6331 }
6332 }
6333
6334 if (loopback == 1)
6335 {
6336 if (attack_mode == ATTACK_MODE_STRAIGHT)
6337 {
6338 if ((rp_files_cnt == 0) && (rp_gen == 0))
6339 {
6340 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6341
6342 return (-1);
6343 }
6344 }
6345 else
6346 {
6347 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 if (debug_mode > 0)
6354 {
6355 if (attack_mode != ATTACK_MODE_STRAIGHT)
6356 {
6357 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6358
6359 return (-1);
6360 }
6361
6362 if ((rp_files_cnt == 0) && (rp_gen == 0))
6363 {
6364 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6365
6366 return (-1);
6367 }
6368 }
6369
6370 if (debug_mode > 4)
6371 {
6372 log_error ("ERROR: Invalid debug-mode specified");
6373
6374 return (-1);
6375 }
6376
6377 if (debug_file != NULL)
6378 {
6379 if (debug_mode < 1)
6380 {
6381 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6382
6383 return (-1);
6384 }
6385 }
6386
6387 if (induction_dir != NULL)
6388 {
6389 if (attack_mode == ATTACK_MODE_BF)
6390 {
6391 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6392
6393 return (-1);
6394 }
6395 }
6396
6397 if (attack_mode != ATTACK_MODE_STRAIGHT)
6398 {
6399 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6400 {
6401 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6402
6403 return (-1);
6404 }
6405
6406 weak_hash_threshold = 0;
6407 }
6408
6409 /**
6410 * induction directory
6411 */
6412
6413 char *induction_directory = NULL;
6414
6415 if (attack_mode != ATTACK_MODE_BF)
6416 {
6417 if (induction_dir == NULL)
6418 {
6419 induction_directory = (char *) mymalloc (session_size);
6420
6421 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6422
6423 // create induction folder if it does not already exist
6424
6425 if (keyspace == 0)
6426 {
6427 if (rmdir (induction_directory) == -1)
6428 {
6429 if (errno == ENOENT)
6430 {
6431 // good, we can ignore
6432 }
6433 else if (errno == ENOTEMPTY)
6434 {
6435 char *induction_directory_mv = (char *) mymalloc (session_size);
6436
6437 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6438
6439 if (rename (induction_directory, induction_directory_mv) != 0)
6440 {
6441 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6442
6443 return (-1);
6444 }
6445 }
6446 else
6447 {
6448 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6449
6450 return (-1);
6451 }
6452 }
6453
6454 if (mkdir (induction_directory, 0700) == -1)
6455 {
6456 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6457
6458 return (-1);
6459 }
6460 }
6461 }
6462 else
6463 {
6464 induction_directory = induction_dir;
6465 }
6466 }
6467
6468 data.induction_directory = induction_directory;
6469
6470 /**
6471 * loopback
6472 */
6473
6474 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6475
6476 char *loopback_file = (char *) mymalloc (loopback_size);
6477
6478 /**
6479 * tuning db
6480 */
6481
6482 char tuning_db_file[256] = { 0 };
6483
6484 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6485
6486 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6487
6488 /**
6489 * outfile-check directory
6490 */
6491
6492 char *outfile_check_directory = NULL;
6493
6494 if (outfile_check_dir == NULL)
6495 {
6496 outfile_check_directory = (char *) mymalloc (session_size);
6497
6498 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6499 }
6500 else
6501 {
6502 outfile_check_directory = outfile_check_dir;
6503 }
6504
6505 data.outfile_check_directory = outfile_check_directory;
6506
6507 if (keyspace == 0)
6508 {
6509 struct stat outfile_check_stat;
6510
6511 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6512 {
6513 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6514
6515 if (is_dir == 0)
6516 {
6517 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6518
6519 return (-1);
6520 }
6521 }
6522 else if (outfile_check_dir == NULL)
6523 {
6524 if (mkdir (outfile_check_directory, 0700) == -1)
6525 {
6526 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6527
6528 return (-1);
6529 }
6530 }
6531 }
6532
6533 /**
6534 * special other stuff
6535 */
6536
6537 if (hash_mode == 9710)
6538 {
6539 outfile_format = 5;
6540 outfile_format_chgd = 1;
6541 }
6542
6543 if (hash_mode == 9810)
6544 {
6545 outfile_format = 5;
6546 outfile_format_chgd = 1;
6547 }
6548
6549 if (hash_mode == 10410)
6550 {
6551 outfile_format = 5;
6552 outfile_format_chgd = 1;
6553 }
6554
6555 /**
6556 * store stuff
6557 */
6558
6559 data.hash_mode = hash_mode;
6560 data.restore = restore;
6561 data.restore_timer = restore_timer;
6562 data.restore_disable = restore_disable;
6563 data.status = status;
6564 data.status_timer = status_timer;
6565 data.status_automat = status_automat;
6566 data.loopback = loopback;
6567 data.runtime = runtime;
6568 data.remove = remove;
6569 data.remove_timer = remove_timer;
6570 data.debug_mode = debug_mode;
6571 data.debug_file = debug_file;
6572 data.username = username;
6573 data.quiet = quiet;
6574 data.outfile = outfile;
6575 data.outfile_format = outfile_format;
6576 data.outfile_autohex = outfile_autohex;
6577 data.hex_charset = hex_charset;
6578 data.hex_salt = hex_salt;
6579 data.hex_wordlist = hex_wordlist;
6580 data.separator = separator;
6581 data.rp_files = rp_files;
6582 data.rp_files_cnt = rp_files_cnt;
6583 data.rp_gen = rp_gen;
6584 data.rp_gen_seed = rp_gen_seed;
6585 data.force = force;
6586 data.benchmark = benchmark;
6587 data.benchmark_repeats = benchmark_repeats;
6588 data.skip = skip;
6589 data.limit = limit;
6590 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6591 data.powertune_enable = powertune_enable;
6592 #endif
6593 data.logfile_disable = logfile_disable;
6594 data.truecrypt_keyfiles = truecrypt_keyfiles;
6595 data.scrypt_tmto = scrypt_tmto;
6596 data.workload_profile = workload_profile;
6597
6598 /**
6599 * cpu affinity
6600 */
6601
6602 if (cpu_affinity)
6603 {
6604 set_cpu_affinity (cpu_affinity);
6605 }
6606
6607 if (rp_gen_seed_chgd == 0)
6608 {
6609 srand (proc_start);
6610 }
6611 else
6612 {
6613 srand (rp_gen_seed);
6614 }
6615
6616 /**
6617 * logfile init
6618 */
6619
6620 if (logfile_disable == 0)
6621 {
6622 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6623
6624 char *logfile = (char *) mymalloc (logfile_size);
6625
6626 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6627
6628 data.logfile = logfile;
6629
6630 char *topid = logfile_generate_topid ();
6631
6632 data.topid = topid;
6633 }
6634
6635 // logfile_append() checks for logfile_disable internally to make it easier from here
6636
6637 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6638 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6639 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6640 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6641 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6642 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6643 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6644 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6645 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6646 #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));
6647
6648 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6649 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6650 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6651 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6652 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6653 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6654 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6655 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6656
6657 logfile_top_msg ("START");
6658
6659 logfile_top_uint (attack_mode);
6660 logfile_top_uint (attack_kern);
6661 logfile_top_uint (benchmark);
6662 logfile_top_uint (benchmark_repeats);
6663 logfile_top_uint (bitmap_min);
6664 logfile_top_uint (bitmap_max);
6665 logfile_top_uint (debug_mode);
6666 logfile_top_uint (force);
6667 logfile_top_uint (kernel_accel);
6668 logfile_top_uint (kernel_loops);
6669 logfile_top_uint (gpu_temp_disable);
6670 #ifdef HAVE_HWMON
6671 logfile_top_uint (gpu_temp_abort);
6672 logfile_top_uint (gpu_temp_retain);
6673 #endif
6674 logfile_top_uint (hash_mode);
6675 logfile_top_uint (hex_charset);
6676 logfile_top_uint (hex_salt);
6677 logfile_top_uint (hex_wordlist);
6678 logfile_top_uint (increment);
6679 logfile_top_uint (increment_max);
6680 logfile_top_uint (increment_min);
6681 logfile_top_uint (keyspace);
6682 logfile_top_uint (left);
6683 logfile_top_uint (logfile_disable);
6684 logfile_top_uint (loopback);
6685 logfile_top_uint (markov_classic);
6686 logfile_top_uint (markov_disable);
6687 logfile_top_uint (markov_threshold);
6688 logfile_top_uint (outfile_autohex);
6689 logfile_top_uint (outfile_check_timer);
6690 logfile_top_uint (outfile_format);
6691 logfile_top_uint (potfile_disable);
6692 logfile_top_string (potfile_path);
6693 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6694 logfile_top_uint (powertune_enable);
6695 #endif
6696 logfile_top_uint (scrypt_tmto);
6697 logfile_top_uint (quiet);
6698 logfile_top_uint (remove);
6699 logfile_top_uint (remove_timer);
6700 logfile_top_uint (restore);
6701 logfile_top_uint (restore_disable);
6702 logfile_top_uint (restore_timer);
6703 logfile_top_uint (rp_gen);
6704 logfile_top_uint (rp_gen_func_max);
6705 logfile_top_uint (rp_gen_func_min);
6706 logfile_top_uint (rp_gen_seed);
6707 logfile_top_uint (runtime);
6708 logfile_top_uint (segment_size);
6709 logfile_top_uint (show);
6710 logfile_top_uint (status);
6711 logfile_top_uint (status_automat);
6712 logfile_top_uint (status_timer);
6713 logfile_top_uint (usage);
6714 logfile_top_uint (username);
6715 logfile_top_uint (version);
6716 logfile_top_uint (weak_hash_threshold);
6717 logfile_top_uint (workload_profile);
6718 logfile_top_uint64 (limit);
6719 logfile_top_uint64 (skip);
6720 logfile_top_char (separator);
6721 logfile_top_string (cpu_affinity);
6722 logfile_top_string (custom_charset_1);
6723 logfile_top_string (custom_charset_2);
6724 logfile_top_string (custom_charset_3);
6725 logfile_top_string (custom_charset_4);
6726 logfile_top_string (debug_file);
6727 logfile_top_string (opencl_devices);
6728 logfile_top_string (opencl_platforms);
6729 logfile_top_string (opencl_device_types);
6730 logfile_top_uint (opencl_vector_width);
6731 logfile_top_string (induction_dir);
6732 logfile_top_string (markov_hcstat);
6733 logfile_top_string (outfile);
6734 logfile_top_string (outfile_check_dir);
6735 logfile_top_string (rule_buf_l);
6736 logfile_top_string (rule_buf_r);
6737 logfile_top_string (session);
6738 logfile_top_string (truecrypt_keyfiles);
6739
6740 /**
6741 * Init OpenCL library loader
6742 */
6743
6744 if (keyspace == 0)
6745 {
6746 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6747
6748 ocl_init (ocl);
6749
6750 data.ocl = ocl;
6751 }
6752
6753 /**
6754 * OpenCL platform selection
6755 */
6756
6757 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6758
6759 /**
6760 * OpenCL device selection
6761 */
6762
6763 u32 devices_filter = setup_devices_filter (opencl_devices);
6764
6765 /**
6766 * OpenCL device type selection
6767 */
6768
6769 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6770
6771 /**
6772 * benchmark
6773 */
6774
6775 if (benchmark == 1)
6776 {
6777 /**
6778 * disable useless stuff for benchmark
6779 */
6780
6781 status_timer = 0;
6782 restore_timer = 0;
6783 restore_disable = 1;
6784 potfile_disable = 1;
6785 weak_hash_threshold = 0;
6786 gpu_temp_disable = 1;
6787
6788 data.status_timer = status_timer;
6789 data.restore_timer = restore_timer;
6790 data.restore_disable = restore_disable;
6791
6792 /**
6793 * force attack mode to be bruteforce
6794 */
6795
6796 attack_mode = ATTACK_MODE_BF;
6797 attack_kern = ATTACK_KERN_BF;
6798
6799 if (workload_profile_chgd == 0)
6800 {
6801 workload_profile = 3;
6802
6803 data.workload_profile = workload_profile;
6804 }
6805 }
6806
6807 /**
6808 * config
6809 */
6810
6811 uint hash_type = 0;
6812 uint salt_type = 0;
6813 uint attack_exec = 0;
6814 uint opts_type = 0;
6815 uint kern_type = 0;
6816 uint dgst_size = 0;
6817 uint esalt_size = 0;
6818 uint opti_type = 0;
6819 uint dgst_pos0 = -1;
6820 uint dgst_pos1 = -1;
6821 uint dgst_pos2 = -1;
6822 uint dgst_pos3 = -1;
6823
6824 int (*parse_func) (char *, uint, hash_t *);
6825 int (*sort_by_digest) (const void *, const void *);
6826
6827 uint algorithm_pos = 0;
6828 uint algorithm_max = 1;
6829
6830 uint *algorithms = default_benchmark_algorithms;
6831
6832 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6833
6834 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6835 {
6836 /*
6837 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6838 * the following algos are skipped entirely
6839 */
6840
6841 if (algorithm_pos > 0)
6842 {
6843 local_free (rd);
6844
6845 rd = init_restore (argc, argv);
6846
6847 data.rd = rd;
6848 }
6849
6850 /**
6851 * update hash_mode in case of multihash benchmark
6852 */
6853
6854 if (benchmark == 1)
6855 {
6856 if (hash_mode_chgd == 0)
6857 {
6858 hash_mode = algorithms[algorithm_pos];
6859
6860 data.hash_mode = hash_mode;
6861 }
6862
6863 quiet = 1;
6864
6865 data.quiet = quiet;
6866 }
6867
6868 switch (hash_mode)
6869 {
6870 case 0: hash_type = HASH_TYPE_MD5;
6871 salt_type = SALT_TYPE_NONE;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_LE
6874 | OPTS_TYPE_PT_ADD80
6875 | OPTS_TYPE_PT_ADDBITS14;
6876 kern_type = KERN_TYPE_MD5;
6877 dgst_size = DGST_SIZE_4_4;
6878 parse_func = md5_parse_hash;
6879 sort_by_digest = sort_by_digest_4_4;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_MEET_IN_MIDDLE
6884 | OPTI_TYPE_EARLY_SKIP
6885 | OPTI_TYPE_NOT_ITERATED
6886 | OPTI_TYPE_NOT_SALTED
6887 | OPTI_TYPE_RAW_HASH;
6888 dgst_pos0 = 0;
6889 dgst_pos1 = 3;
6890 dgst_pos2 = 2;
6891 dgst_pos3 = 1;
6892 break;
6893
6894 case 10: hash_type = HASH_TYPE_MD5;
6895 salt_type = SALT_TYPE_INTERN;
6896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6897 opts_type = OPTS_TYPE_PT_GENERATE_LE
6898 | OPTS_TYPE_ST_ADD80
6899 | OPTS_TYPE_ST_ADDBITS14;
6900 kern_type = KERN_TYPE_MD5_PWSLT;
6901 dgst_size = DGST_SIZE_4_4;
6902 parse_func = md5s_parse_hash;
6903 sort_by_digest = sort_by_digest_4_4;
6904 opti_type = OPTI_TYPE_ZERO_BYTE
6905 | OPTI_TYPE_PRECOMPUTE_INIT
6906 | OPTI_TYPE_PRECOMPUTE_MERKLE
6907 | OPTI_TYPE_MEET_IN_MIDDLE
6908 | OPTI_TYPE_EARLY_SKIP
6909 | OPTI_TYPE_NOT_ITERATED
6910 | OPTI_TYPE_APPENDED_SALT
6911 | OPTI_TYPE_RAW_HASH;
6912 dgst_pos0 = 0;
6913 dgst_pos1 = 3;
6914 dgst_pos2 = 2;
6915 dgst_pos3 = 1;
6916 break;
6917
6918 case 11: hash_type = HASH_TYPE_MD5;
6919 salt_type = SALT_TYPE_INTERN;
6920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6921 opts_type = OPTS_TYPE_PT_GENERATE_LE
6922 | OPTS_TYPE_ST_ADD80
6923 | OPTS_TYPE_ST_ADDBITS14;
6924 kern_type = KERN_TYPE_MD5_PWSLT;
6925 dgst_size = DGST_SIZE_4_4;
6926 parse_func = joomla_parse_hash;
6927 sort_by_digest = sort_by_digest_4_4;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_PRECOMPUTE_INIT
6930 | OPTI_TYPE_PRECOMPUTE_MERKLE
6931 | OPTI_TYPE_MEET_IN_MIDDLE
6932 | OPTI_TYPE_EARLY_SKIP
6933 | OPTI_TYPE_NOT_ITERATED
6934 | OPTI_TYPE_APPENDED_SALT
6935 | OPTI_TYPE_RAW_HASH;
6936 dgst_pos0 = 0;
6937 dgst_pos1 = 3;
6938 dgst_pos2 = 2;
6939 dgst_pos3 = 1;
6940 break;
6941
6942 case 12: hash_type = HASH_TYPE_MD5;
6943 salt_type = SALT_TYPE_INTERN;
6944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6945 opts_type = OPTS_TYPE_PT_GENERATE_LE
6946 | OPTS_TYPE_ST_ADD80
6947 | OPTS_TYPE_ST_ADDBITS14;
6948 kern_type = KERN_TYPE_MD5_PWSLT;
6949 dgst_size = DGST_SIZE_4_4;
6950 parse_func = postgresql_parse_hash;
6951 sort_by_digest = sort_by_digest_4_4;
6952 opti_type = OPTI_TYPE_ZERO_BYTE
6953 | OPTI_TYPE_PRECOMPUTE_INIT
6954 | OPTI_TYPE_PRECOMPUTE_MERKLE
6955 | OPTI_TYPE_MEET_IN_MIDDLE
6956 | OPTI_TYPE_EARLY_SKIP
6957 | OPTI_TYPE_NOT_ITERATED
6958 | OPTI_TYPE_APPENDED_SALT
6959 | OPTI_TYPE_RAW_HASH;
6960 dgst_pos0 = 0;
6961 dgst_pos1 = 3;
6962 dgst_pos2 = 2;
6963 dgst_pos3 = 1;
6964 break;
6965
6966 case 20: hash_type = HASH_TYPE_MD5;
6967 salt_type = SALT_TYPE_INTERN;
6968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6969 opts_type = OPTS_TYPE_PT_GENERATE_LE
6970 | OPTS_TYPE_PT_ADD80
6971 | OPTS_TYPE_PT_ADDBITS14;
6972 kern_type = KERN_TYPE_MD5_SLTPW;
6973 dgst_size = DGST_SIZE_4_4;
6974 parse_func = md5s_parse_hash;
6975 sort_by_digest = sort_by_digest_4_4;
6976 opti_type = OPTI_TYPE_ZERO_BYTE
6977 | OPTI_TYPE_PRECOMPUTE_INIT
6978 | OPTI_TYPE_PRECOMPUTE_MERKLE
6979 | OPTI_TYPE_EARLY_SKIP
6980 | OPTI_TYPE_NOT_ITERATED
6981 | OPTI_TYPE_PREPENDED_SALT
6982 | OPTI_TYPE_RAW_HASH;
6983 dgst_pos0 = 0;
6984 dgst_pos1 = 3;
6985 dgst_pos2 = 2;
6986 dgst_pos3 = 1;
6987 break;
6988
6989 case 21: hash_type = HASH_TYPE_MD5;
6990 salt_type = SALT_TYPE_INTERN;
6991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6992 opts_type = OPTS_TYPE_PT_GENERATE_LE
6993 | OPTS_TYPE_PT_ADD80
6994 | OPTS_TYPE_PT_ADDBITS14;
6995 kern_type = KERN_TYPE_MD5_SLTPW;
6996 dgst_size = DGST_SIZE_4_4;
6997 parse_func = osc_parse_hash;
6998 sort_by_digest = sort_by_digest_4_4;
6999 opti_type = OPTI_TYPE_ZERO_BYTE
7000 | OPTI_TYPE_PRECOMPUTE_INIT
7001 | OPTI_TYPE_PRECOMPUTE_MERKLE
7002 | OPTI_TYPE_EARLY_SKIP
7003 | OPTI_TYPE_NOT_ITERATED
7004 | OPTI_TYPE_PREPENDED_SALT
7005 | OPTI_TYPE_RAW_HASH;
7006 dgst_pos0 = 0;
7007 dgst_pos1 = 3;
7008 dgst_pos2 = 2;
7009 dgst_pos3 = 1;
7010 break;
7011
7012 case 22: hash_type = HASH_TYPE_MD5;
7013 salt_type = SALT_TYPE_EMBEDDED;
7014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7015 opts_type = OPTS_TYPE_PT_GENERATE_LE
7016 | OPTS_TYPE_PT_ADD80
7017 | OPTS_TYPE_PT_ADDBITS14;
7018 kern_type = KERN_TYPE_MD5_SLTPW;
7019 dgst_size = DGST_SIZE_4_4;
7020 parse_func = netscreen_parse_hash;
7021 sort_by_digest = sort_by_digest_4_4;
7022 opti_type = OPTI_TYPE_ZERO_BYTE
7023 | OPTI_TYPE_PRECOMPUTE_INIT
7024 | OPTI_TYPE_PRECOMPUTE_MERKLE
7025 | OPTI_TYPE_EARLY_SKIP
7026 | OPTI_TYPE_NOT_ITERATED
7027 | OPTI_TYPE_PREPENDED_SALT
7028 | OPTI_TYPE_RAW_HASH;
7029 dgst_pos0 = 0;
7030 dgst_pos1 = 3;
7031 dgst_pos2 = 2;
7032 dgst_pos3 = 1;
7033 break;
7034
7035 case 23: hash_type = HASH_TYPE_MD5;
7036 salt_type = SALT_TYPE_EMBEDDED;
7037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7038 opts_type = OPTS_TYPE_PT_GENERATE_LE
7039 | OPTS_TYPE_PT_ADD80
7040 | OPTS_TYPE_PT_ADDBITS14;
7041 kern_type = KERN_TYPE_MD5_SLTPW;
7042 dgst_size = DGST_SIZE_4_4;
7043 parse_func = skype_parse_hash;
7044 sort_by_digest = sort_by_digest_4_4;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_PREPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 0;
7053 dgst_pos1 = 3;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 30: hash_type = HASH_TYPE_MD5;
7059 salt_type = SALT_TYPE_INTERN;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_LE
7062 | OPTS_TYPE_PT_UNICODE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS14;
7065 kern_type = KERN_TYPE_MD5_PWUSLT;
7066 dgst_size = DGST_SIZE_4_4;
7067 parse_func = md5s_parse_hash;
7068 sort_by_digest = sort_by_digest_4_4;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_MEET_IN_MIDDLE
7073 | OPTI_TYPE_EARLY_SKIP
7074 | OPTI_TYPE_NOT_ITERATED
7075 | OPTI_TYPE_APPENDED_SALT
7076 | OPTI_TYPE_RAW_HASH;
7077 dgst_pos0 = 0;
7078 dgst_pos1 = 3;
7079 dgst_pos2 = 2;
7080 dgst_pos3 = 1;
7081 break;
7082
7083 case 40: hash_type = HASH_TYPE_MD5;
7084 salt_type = SALT_TYPE_INTERN;
7085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7086 opts_type = OPTS_TYPE_PT_GENERATE_LE
7087 | OPTS_TYPE_PT_ADD80
7088 | OPTS_TYPE_PT_ADDBITS14
7089 | OPTS_TYPE_PT_UNICODE;
7090 kern_type = KERN_TYPE_MD5_SLTPWU;
7091 dgst_size = DGST_SIZE_4_4;
7092 parse_func = md5s_parse_hash;
7093 sort_by_digest = sort_by_digest_4_4;
7094 opti_type = OPTI_TYPE_ZERO_BYTE
7095 | OPTI_TYPE_PRECOMPUTE_INIT
7096 | OPTI_TYPE_PRECOMPUTE_MERKLE
7097 | OPTI_TYPE_EARLY_SKIP
7098 | OPTI_TYPE_NOT_ITERATED
7099 | OPTI_TYPE_PREPENDED_SALT
7100 | OPTI_TYPE_RAW_HASH;
7101 dgst_pos0 = 0;
7102 dgst_pos1 = 3;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 50: hash_type = HASH_TYPE_MD5;
7108 salt_type = SALT_TYPE_INTERN;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_LE
7111 | OPTS_TYPE_ST_ADD80
7112 | OPTS_TYPE_ST_ADDBITS14;
7113 kern_type = KERN_TYPE_HMACMD5_PW;
7114 dgst_size = DGST_SIZE_4_4;
7115 parse_func = hmacmd5_parse_hash;
7116 sort_by_digest = sort_by_digest_4_4;
7117 opti_type = OPTI_TYPE_ZERO_BYTE
7118 | OPTI_TYPE_NOT_ITERATED;
7119 dgst_pos0 = 0;
7120 dgst_pos1 = 3;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 60: hash_type = HASH_TYPE_MD5;
7126 salt_type = SALT_TYPE_INTERN;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_LE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS14;
7131 kern_type = KERN_TYPE_HMACMD5_SLT;
7132 dgst_size = DGST_SIZE_4_4;
7133 parse_func = hmacmd5_parse_hash;
7134 sort_by_digest = sort_by_digest_4_4;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_NOT_ITERATED;
7137 dgst_pos0 = 0;
7138 dgst_pos1 = 3;
7139 dgst_pos2 = 2;
7140 dgst_pos3 = 1;
7141 break;
7142
7143 case 100: hash_type = HASH_TYPE_SHA1;
7144 salt_type = SALT_TYPE_NONE;
7145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7146 opts_type = OPTS_TYPE_PT_GENERATE_BE
7147 | OPTS_TYPE_PT_ADD80
7148 | OPTS_TYPE_PT_ADDBITS15;
7149 kern_type = KERN_TYPE_SHA1;
7150 dgst_size = DGST_SIZE_4_5;
7151 parse_func = sha1_parse_hash;
7152 sort_by_digest = sort_by_digest_4_5;
7153 opti_type = OPTI_TYPE_ZERO_BYTE
7154 | OPTI_TYPE_PRECOMPUTE_INIT
7155 | OPTI_TYPE_PRECOMPUTE_MERKLE
7156 | OPTI_TYPE_EARLY_SKIP
7157 | OPTI_TYPE_NOT_ITERATED
7158 | OPTI_TYPE_NOT_SALTED
7159 | OPTI_TYPE_RAW_HASH;
7160 dgst_pos0 = 3;
7161 dgst_pos1 = 4;
7162 dgst_pos2 = 2;
7163 dgst_pos3 = 1;
7164 break;
7165
7166 case 101: hash_type = HASH_TYPE_SHA1;
7167 salt_type = SALT_TYPE_NONE;
7168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7169 opts_type = OPTS_TYPE_PT_GENERATE_BE
7170 | OPTS_TYPE_PT_ADD80
7171 | OPTS_TYPE_PT_ADDBITS15;
7172 kern_type = KERN_TYPE_SHA1;
7173 dgst_size = DGST_SIZE_4_5;
7174 parse_func = sha1b64_parse_hash;
7175 sort_by_digest = sort_by_digest_4_5;
7176 opti_type = OPTI_TYPE_ZERO_BYTE
7177 | OPTI_TYPE_PRECOMPUTE_INIT
7178 | OPTI_TYPE_PRECOMPUTE_MERKLE
7179 | OPTI_TYPE_EARLY_SKIP
7180 | OPTI_TYPE_NOT_ITERATED
7181 | OPTI_TYPE_NOT_SALTED
7182 | OPTI_TYPE_RAW_HASH;
7183 dgst_pos0 = 3;
7184 dgst_pos1 = 4;
7185 dgst_pos2 = 2;
7186 dgst_pos3 = 1;
7187 break;
7188
7189 case 110: hash_type = HASH_TYPE_SHA1;
7190 salt_type = SALT_TYPE_INTERN;
7191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7192 opts_type = OPTS_TYPE_PT_GENERATE_BE
7193 | OPTS_TYPE_ST_ADD80
7194 | OPTS_TYPE_ST_ADDBITS15;
7195 kern_type = KERN_TYPE_SHA1_PWSLT;
7196 dgst_size = DGST_SIZE_4_5;
7197 parse_func = sha1s_parse_hash;
7198 sort_by_digest = sort_by_digest_4_5;
7199 opti_type = OPTI_TYPE_ZERO_BYTE
7200 | OPTI_TYPE_PRECOMPUTE_INIT
7201 | OPTI_TYPE_PRECOMPUTE_MERKLE
7202 | OPTI_TYPE_EARLY_SKIP
7203 | OPTI_TYPE_NOT_ITERATED
7204 | OPTI_TYPE_APPENDED_SALT
7205 | OPTI_TYPE_RAW_HASH;
7206 dgst_pos0 = 3;
7207 dgst_pos1 = 4;
7208 dgst_pos2 = 2;
7209 dgst_pos3 = 1;
7210 break;
7211
7212 case 111: hash_type = HASH_TYPE_SHA1;
7213 salt_type = SALT_TYPE_EMBEDDED;
7214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7215 opts_type = OPTS_TYPE_PT_GENERATE_BE
7216 | OPTS_TYPE_ST_ADD80
7217 | OPTS_TYPE_ST_ADDBITS15;
7218 kern_type = KERN_TYPE_SHA1_PWSLT;
7219 dgst_size = DGST_SIZE_4_5;
7220 parse_func = sha1b64s_parse_hash;
7221 sort_by_digest = sort_by_digest_4_5;
7222 opti_type = OPTI_TYPE_ZERO_BYTE
7223 | OPTI_TYPE_PRECOMPUTE_INIT
7224 | OPTI_TYPE_PRECOMPUTE_MERKLE
7225 | OPTI_TYPE_EARLY_SKIP
7226 | OPTI_TYPE_NOT_ITERATED
7227 | OPTI_TYPE_APPENDED_SALT
7228 | OPTI_TYPE_RAW_HASH;
7229 dgst_pos0 = 3;
7230 dgst_pos1 = 4;
7231 dgst_pos2 = 2;
7232 dgst_pos3 = 1;
7233 break;
7234
7235 case 112: hash_type = HASH_TYPE_SHA1;
7236 salt_type = SALT_TYPE_INTERN;
7237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7238 opts_type = OPTS_TYPE_PT_GENERATE_BE
7239 | OPTS_TYPE_ST_ADD80
7240 | OPTS_TYPE_ST_ADDBITS15
7241 | OPTS_TYPE_ST_HEX;
7242 kern_type = KERN_TYPE_SHA1_PWSLT;
7243 dgst_size = DGST_SIZE_4_5;
7244 parse_func = oracles_parse_hash;
7245 sort_by_digest = sort_by_digest_4_5;
7246 opti_type = OPTI_TYPE_ZERO_BYTE
7247 | OPTI_TYPE_PRECOMPUTE_INIT
7248 | OPTI_TYPE_PRECOMPUTE_MERKLE
7249 | OPTI_TYPE_EARLY_SKIP
7250 | OPTI_TYPE_NOT_ITERATED
7251 | OPTI_TYPE_APPENDED_SALT
7252 | OPTI_TYPE_RAW_HASH;
7253 dgst_pos0 = 3;
7254 dgst_pos1 = 4;
7255 dgst_pos2 = 2;
7256 dgst_pos3 = 1;
7257 break;
7258
7259 case 120: hash_type = HASH_TYPE_SHA1;
7260 salt_type = SALT_TYPE_INTERN;
7261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7262 opts_type = OPTS_TYPE_PT_GENERATE_BE
7263 | OPTS_TYPE_PT_ADD80
7264 | OPTS_TYPE_PT_ADDBITS15;
7265 kern_type = KERN_TYPE_SHA1_SLTPW;
7266 dgst_size = DGST_SIZE_4_5;
7267 parse_func = sha1s_parse_hash;
7268 sort_by_digest = sort_by_digest_4_5;
7269 opti_type = OPTI_TYPE_ZERO_BYTE
7270 | OPTI_TYPE_PRECOMPUTE_INIT
7271 | OPTI_TYPE_PRECOMPUTE_MERKLE
7272 | OPTI_TYPE_EARLY_SKIP
7273 | OPTI_TYPE_NOT_ITERATED
7274 | OPTI_TYPE_PREPENDED_SALT
7275 | OPTI_TYPE_RAW_HASH;
7276 dgst_pos0 = 3;
7277 dgst_pos1 = 4;
7278 dgst_pos2 = 2;
7279 dgst_pos3 = 1;
7280 break;
7281
7282 case 121: hash_type = HASH_TYPE_SHA1;
7283 salt_type = SALT_TYPE_INTERN;
7284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7285 opts_type = OPTS_TYPE_PT_GENERATE_BE
7286 | OPTS_TYPE_PT_ADD80
7287 | OPTS_TYPE_PT_ADDBITS15
7288 | OPTS_TYPE_ST_LOWER;
7289 kern_type = KERN_TYPE_SHA1_SLTPW;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = smf_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_PREPENDED_SALT
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 122: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS15
7312 | OPTS_TYPE_ST_HEX;
7313 kern_type = KERN_TYPE_SHA1_SLTPW;
7314 dgst_size = DGST_SIZE_4_5;
7315 parse_func = osx1_parse_hash;
7316 sort_by_digest = sort_by_digest_4_5;
7317 opti_type = OPTI_TYPE_ZERO_BYTE
7318 | OPTI_TYPE_PRECOMPUTE_INIT
7319 | OPTI_TYPE_PRECOMPUTE_MERKLE
7320 | OPTI_TYPE_EARLY_SKIP
7321 | OPTI_TYPE_NOT_ITERATED
7322 | OPTI_TYPE_PREPENDED_SALT
7323 | OPTI_TYPE_RAW_HASH;
7324 dgst_pos0 = 3;
7325 dgst_pos1 = 4;
7326 dgst_pos2 = 2;
7327 dgst_pos3 = 1;
7328 break;
7329
7330 case 124: hash_type = HASH_TYPE_SHA1;
7331 salt_type = SALT_TYPE_EMBEDDED;
7332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7333 opts_type = OPTS_TYPE_PT_GENERATE_BE
7334 | OPTS_TYPE_PT_ADD80
7335 | OPTS_TYPE_PT_ADDBITS15;
7336 kern_type = KERN_TYPE_SHA1_SLTPW;
7337 dgst_size = DGST_SIZE_4_5;
7338 parse_func = djangosha1_parse_hash;
7339 sort_by_digest = sort_by_digest_4_5;
7340 opti_type = OPTI_TYPE_ZERO_BYTE
7341 | OPTI_TYPE_PRECOMPUTE_INIT
7342 | OPTI_TYPE_PRECOMPUTE_MERKLE
7343 | OPTI_TYPE_EARLY_SKIP
7344 | OPTI_TYPE_NOT_ITERATED
7345 | OPTI_TYPE_PREPENDED_SALT
7346 | OPTI_TYPE_RAW_HASH;
7347 dgst_pos0 = 3;
7348 dgst_pos1 = 4;
7349 dgst_pos2 = 2;
7350 dgst_pos3 = 1;
7351 break;
7352
7353 case 125: hash_type = HASH_TYPE_SHA1;
7354 salt_type = SALT_TYPE_EMBEDDED;
7355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7356 opts_type = OPTS_TYPE_PT_GENERATE_BE
7357 | OPTS_TYPE_PT_ADD80
7358 | OPTS_TYPE_PT_ADDBITS15
7359 | OPTS_TYPE_ST_HEX;
7360 kern_type = KERN_TYPE_SHA1_SLTPW;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = arubaos_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_PREPENDED_SALT
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 130: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_PT_UNICODE
7382 | OPTS_TYPE_ST_ADD80
7383 | OPTS_TYPE_ST_ADDBITS15;
7384 kern_type = KERN_TYPE_SHA1_PWUSLT;
7385 dgst_size = DGST_SIZE_4_5;
7386 parse_func = sha1s_parse_hash;
7387 sort_by_digest = sort_by_digest_4_5;
7388 opti_type = OPTI_TYPE_ZERO_BYTE
7389 | OPTI_TYPE_PRECOMPUTE_INIT
7390 | OPTI_TYPE_PRECOMPUTE_MERKLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 3;
7396 dgst_pos1 = 4;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 131: hash_type = HASH_TYPE_SHA1;
7402 salt_type = SALT_TYPE_EMBEDDED;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_BE
7405 | OPTS_TYPE_PT_UNICODE
7406 | OPTS_TYPE_PT_UPPER
7407 | OPTS_TYPE_ST_ADD80
7408 | OPTS_TYPE_ST_ADDBITS15
7409 | OPTS_TYPE_ST_HEX;
7410 kern_type = KERN_TYPE_SHA1_PWUSLT;
7411 dgst_size = DGST_SIZE_4_5;
7412 parse_func = mssql2000_parse_hash;
7413 sort_by_digest = sort_by_digest_4_5;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_PRECOMPUTE_INIT
7416 | OPTI_TYPE_PRECOMPUTE_MERKLE
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_APPENDED_SALT
7420 | OPTI_TYPE_RAW_HASH;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 4;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 132: hash_type = HASH_TYPE_SHA1;
7428 salt_type = SALT_TYPE_EMBEDDED;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_UNICODE
7432 | OPTS_TYPE_ST_ADD80
7433 | OPTS_TYPE_ST_ADDBITS15
7434 | OPTS_TYPE_ST_HEX;
7435 kern_type = KERN_TYPE_SHA1_PWUSLT;
7436 dgst_size = DGST_SIZE_4_5;
7437 parse_func = mssql2005_parse_hash;
7438 sort_by_digest = sort_by_digest_4_5;
7439 opti_type = OPTI_TYPE_ZERO_BYTE
7440 | OPTI_TYPE_PRECOMPUTE_INIT
7441 | OPTI_TYPE_PRECOMPUTE_MERKLE
7442 | OPTI_TYPE_EARLY_SKIP
7443 | OPTI_TYPE_NOT_ITERATED
7444 | OPTI_TYPE_APPENDED_SALT
7445 | OPTI_TYPE_RAW_HASH;
7446 dgst_pos0 = 3;
7447 dgst_pos1 = 4;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 1;
7450 break;
7451
7452 case 133: hash_type = HASH_TYPE_SHA1;
7453 salt_type = SALT_TYPE_EMBEDDED;
7454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7455 opts_type = OPTS_TYPE_PT_GENERATE_BE
7456 | OPTS_TYPE_PT_UNICODE
7457 | OPTS_TYPE_ST_ADD80
7458 | OPTS_TYPE_ST_ADDBITS15;
7459 kern_type = KERN_TYPE_SHA1_PWUSLT;
7460 dgst_size = DGST_SIZE_4_5;
7461 parse_func = peoplesoft_parse_hash;
7462 sort_by_digest = sort_by_digest_4_5;
7463 opti_type = OPTI_TYPE_ZERO_BYTE
7464 | OPTI_TYPE_PRECOMPUTE_INIT
7465 | OPTI_TYPE_PRECOMPUTE_MERKLE
7466 | OPTI_TYPE_EARLY_SKIP
7467 | OPTI_TYPE_NOT_ITERATED
7468 | OPTI_TYPE_APPENDED_SALT
7469 | OPTI_TYPE_RAW_HASH;
7470 dgst_pos0 = 3;
7471 dgst_pos1 = 4;
7472 dgst_pos2 = 2;
7473 dgst_pos3 = 1;
7474 break;
7475
7476 case 140: hash_type = HASH_TYPE_SHA1;
7477 salt_type = SALT_TYPE_INTERN;
7478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7479 opts_type = OPTS_TYPE_PT_GENERATE_BE
7480 | OPTS_TYPE_PT_ADD80
7481 | OPTS_TYPE_PT_ADDBITS15
7482 | OPTS_TYPE_PT_UNICODE;
7483 kern_type = KERN_TYPE_SHA1_SLTPWU;
7484 dgst_size = DGST_SIZE_4_5;
7485 parse_func = sha1s_parse_hash;
7486 sort_by_digest = sort_by_digest_4_5;
7487 opti_type = OPTI_TYPE_ZERO_BYTE
7488 | OPTI_TYPE_PRECOMPUTE_INIT
7489 | OPTI_TYPE_PRECOMPUTE_MERKLE
7490 | OPTI_TYPE_EARLY_SKIP
7491 | OPTI_TYPE_NOT_ITERATED
7492 | OPTI_TYPE_PREPENDED_SALT
7493 | OPTI_TYPE_RAW_HASH;
7494 dgst_pos0 = 3;
7495 dgst_pos1 = 4;
7496 dgst_pos2 = 2;
7497 dgst_pos3 = 1;
7498 break;
7499
7500 case 141: hash_type = HASH_TYPE_SHA1;
7501 salt_type = SALT_TYPE_EMBEDDED;
7502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7503 opts_type = OPTS_TYPE_PT_GENERATE_BE
7504 | OPTS_TYPE_PT_ADD80
7505 | OPTS_TYPE_PT_ADDBITS15
7506 | OPTS_TYPE_PT_UNICODE
7507 | OPTS_TYPE_ST_BASE64;
7508 kern_type = KERN_TYPE_SHA1_SLTPWU;
7509 dgst_size = DGST_SIZE_4_5;
7510 parse_func = episerver_parse_hash;
7511 sort_by_digest = sort_by_digest_4_5;
7512 opti_type = OPTI_TYPE_ZERO_BYTE
7513 | OPTI_TYPE_PRECOMPUTE_INIT
7514 | OPTI_TYPE_PRECOMPUTE_MERKLE
7515 | OPTI_TYPE_EARLY_SKIP
7516 | OPTI_TYPE_NOT_ITERATED
7517 | OPTI_TYPE_PREPENDED_SALT
7518 | OPTI_TYPE_RAW_HASH;
7519 dgst_pos0 = 3;
7520 dgst_pos1 = 4;
7521 dgst_pos2 = 2;
7522 dgst_pos3 = 1;
7523 break;
7524
7525 case 150: hash_type = HASH_TYPE_SHA1;
7526 salt_type = SALT_TYPE_INTERN;
7527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7528 opts_type = OPTS_TYPE_PT_GENERATE_BE
7529 | OPTS_TYPE_ST_ADD80
7530 | OPTS_TYPE_ST_ADDBITS15;
7531 kern_type = KERN_TYPE_HMACSHA1_PW;
7532 dgst_size = DGST_SIZE_4_5;
7533 parse_func = hmacsha1_parse_hash;
7534 sort_by_digest = sort_by_digest_4_5;
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_NOT_ITERATED;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 160: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_INTERN;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_ADD80
7548 | OPTS_TYPE_PT_ADDBITS15;
7549 kern_type = KERN_TYPE_HMACSHA1_SLT;
7550 dgst_size = DGST_SIZE_4_5;
7551 parse_func = hmacsha1_parse_hash;
7552 sort_by_digest = sort_by_digest_4_5;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_NOT_ITERATED;
7555 dgst_pos0 = 3;
7556 dgst_pos1 = 4;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 1;
7559 break;
7560
7561 case 190: hash_type = HASH_TYPE_SHA1;
7562 salt_type = SALT_TYPE_NONE;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_BE
7565 | OPTS_TYPE_PT_ADD80
7566 | OPTS_TYPE_PT_ADDBITS15;
7567 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7568 dgst_size = DGST_SIZE_4_5;
7569 parse_func = sha1linkedin_parse_hash;
7570 sort_by_digest = sort_by_digest_4_5;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_EARLY_SKIP
7574 | OPTI_TYPE_NOT_ITERATED
7575 | OPTI_TYPE_NOT_SALTED;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 4;
7578 dgst_pos2 = 3;
7579 dgst_pos3 = 2;
7580 break;
7581
7582 case 200: hash_type = HASH_TYPE_MYSQL;
7583 salt_type = SALT_TYPE_NONE;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = 0;
7586 kern_type = KERN_TYPE_MYSQL;
7587 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7588 parse_func = mysql323_parse_hash;
7589 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7590 opti_type = OPTI_TYPE_ZERO_BYTE;
7591 dgst_pos0 = 0;
7592 dgst_pos1 = 1;
7593 dgst_pos2 = 2;
7594 dgst_pos3 = 3;
7595 break;
7596
7597 case 300: hash_type = HASH_TYPE_SHA1;
7598 salt_type = SALT_TYPE_NONE;
7599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7600 opts_type = OPTS_TYPE_PT_GENERATE_BE
7601 | OPTS_TYPE_PT_ADD80
7602 | OPTS_TYPE_PT_ADDBITS15;
7603 kern_type = KERN_TYPE_MYSQL41;
7604 dgst_size = DGST_SIZE_4_5;
7605 parse_func = sha1_parse_hash;
7606 sort_by_digest = sort_by_digest_4_5;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_NOT_SALTED;
7613 dgst_pos0 = 3;
7614 dgst_pos1 = 4;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 1;
7617 break;
7618
7619 case 400: hash_type = HASH_TYPE_MD5;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7623 kern_type = KERN_TYPE_PHPASS;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = phpass_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_SLOW_HASH_SIMD;
7629 dgst_pos0 = 0;
7630 dgst_pos1 = 1;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 3;
7633 break;
7634
7635 case 500: hash_type = HASH_TYPE_MD5;
7636 salt_type = SALT_TYPE_EMBEDDED;
7637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7639 kern_type = KERN_TYPE_MD5CRYPT;
7640 dgst_size = DGST_SIZE_4_4;
7641 parse_func = md5crypt_parse_hash;
7642 sort_by_digest = sort_by_digest_4_4;
7643 opti_type = OPTI_TYPE_ZERO_BYTE;
7644 dgst_pos0 = 0;
7645 dgst_pos1 = 1;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 3;
7648 break;
7649
7650 case 501: hash_type = HASH_TYPE_MD5;
7651 salt_type = SALT_TYPE_EMBEDDED;
7652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_LE
7654 | OPTS_TYPE_HASH_COPY;
7655 kern_type = KERN_TYPE_MD5CRYPT;
7656 dgst_size = DGST_SIZE_4_4;
7657 parse_func = juniper_parse_hash;
7658 sort_by_digest = sort_by_digest_4_4;
7659 opti_type = OPTI_TYPE_ZERO_BYTE;
7660 dgst_pos0 = 0;
7661 dgst_pos1 = 1;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 3;
7664 break;
7665
7666 case 900: hash_type = HASH_TYPE_MD4;
7667 salt_type = SALT_TYPE_NONE;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_LE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS14;
7672 kern_type = KERN_TYPE_MD4;
7673 dgst_size = DGST_SIZE_4_4;
7674 parse_func = md4_parse_hash;
7675 sort_by_digest = sort_by_digest_4_4;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_PRECOMPUTE_MERKLE
7679 | OPTI_TYPE_MEET_IN_MIDDLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_NOT_SALTED
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 0;
7685 dgst_pos1 = 3;
7686 dgst_pos2 = 2;
7687 dgst_pos3 = 1;
7688 break;
7689
7690 case 1000: hash_type = HASH_TYPE_MD4;
7691 salt_type = SALT_TYPE_NONE;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_LE
7694 | OPTS_TYPE_PT_ADD80
7695 | OPTS_TYPE_PT_ADDBITS14
7696 | OPTS_TYPE_PT_UNICODE;
7697 kern_type = KERN_TYPE_MD4_PWU;
7698 dgst_size = DGST_SIZE_4_4;
7699 parse_func = md4_parse_hash;
7700 sort_by_digest = sort_by_digest_4_4;
7701 opti_type = OPTI_TYPE_ZERO_BYTE
7702 | OPTI_TYPE_PRECOMPUTE_INIT
7703 | OPTI_TYPE_PRECOMPUTE_MERKLE
7704 | OPTI_TYPE_MEET_IN_MIDDLE
7705 | OPTI_TYPE_EARLY_SKIP
7706 | OPTI_TYPE_NOT_ITERATED
7707 | OPTI_TYPE_NOT_SALTED
7708 | OPTI_TYPE_RAW_HASH;
7709 dgst_pos0 = 0;
7710 dgst_pos1 = 3;
7711 dgst_pos2 = 2;
7712 dgst_pos3 = 1;
7713 break;
7714
7715 case 1100: hash_type = HASH_TYPE_MD4;
7716 salt_type = SALT_TYPE_INTERN;
7717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7718 opts_type = OPTS_TYPE_PT_GENERATE_LE
7719 | OPTS_TYPE_PT_ADD80
7720 | OPTS_TYPE_PT_ADDBITS14
7721 | OPTS_TYPE_PT_UNICODE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_UNICODE
7724 | OPTS_TYPE_ST_LOWER;
7725 kern_type = KERN_TYPE_MD44_PWUSLT;
7726 dgst_size = DGST_SIZE_4_4;
7727 parse_func = dcc_parse_hash;
7728 sort_by_digest = sort_by_digest_4_4;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED;
7734 dgst_pos0 = 0;
7735 dgst_pos1 = 3;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 1;
7738 break;
7739
7740 case 1400: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_NONE;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA256;
7747 dgst_size = DGST_SIZE_4_8;
7748 parse_func = sha256_parse_hash;
7749 sort_by_digest = sort_by_digest_4_8;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_NOT_SALTED
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 7;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 6;
7761 break;
7762
7763 case 1410: hash_type = HASH_TYPE_SHA256;
7764 salt_type = SALT_TYPE_INTERN;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_ST_ADD80
7768 | OPTS_TYPE_ST_ADDBITS15;
7769 kern_type = KERN_TYPE_SHA256_PWSLT;
7770 dgst_size = DGST_SIZE_4_8;
7771 parse_func = sha256s_parse_hash;
7772 sort_by_digest = sort_by_digest_4_8;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_APPENDED_SALT
7779 | OPTI_TYPE_RAW_HASH;
7780 dgst_pos0 = 3;
7781 dgst_pos1 = 7;
7782 dgst_pos2 = 2;
7783 dgst_pos3 = 6;
7784 break;
7785
7786 case 1420: hash_type = HASH_TYPE_SHA256;
7787 salt_type = SALT_TYPE_INTERN;
7788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7789 opts_type = OPTS_TYPE_PT_GENERATE_BE
7790 | OPTS_TYPE_PT_ADD80
7791 | OPTS_TYPE_PT_ADDBITS15;
7792 kern_type = KERN_TYPE_SHA256_SLTPW;
7793 dgst_size = DGST_SIZE_4_8;
7794 parse_func = sha256s_parse_hash;
7795 sort_by_digest = sort_by_digest_4_8;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP
7800 | OPTI_TYPE_NOT_ITERATED
7801 | OPTI_TYPE_PREPENDED_SALT
7802 | OPTI_TYPE_RAW_HASH;
7803 dgst_pos0 = 3;
7804 dgst_pos1 = 7;
7805 dgst_pos2 = 2;
7806 dgst_pos3 = 6;
7807 break;
7808
7809 case 1421: hash_type = HASH_TYPE_SHA256;
7810 salt_type = SALT_TYPE_EMBEDDED;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_BE
7813 | OPTS_TYPE_PT_ADD80
7814 | OPTS_TYPE_PT_ADDBITS15;
7815 kern_type = KERN_TYPE_SHA256_SLTPW;
7816 dgst_size = DGST_SIZE_4_8;
7817 parse_func = hmailserver_parse_hash;
7818 sort_by_digest = sort_by_digest_4_8;
7819 opti_type = OPTI_TYPE_ZERO_BYTE
7820 | OPTI_TYPE_PRECOMPUTE_INIT
7821 | OPTI_TYPE_PRECOMPUTE_MERKLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED
7824 | OPTI_TYPE_PREPENDED_SALT
7825 | OPTI_TYPE_RAW_HASH;
7826 dgst_pos0 = 3;
7827 dgst_pos1 = 7;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 6;
7830 break;
7831
7832 case 1430: hash_type = HASH_TYPE_SHA256;
7833 salt_type = SALT_TYPE_INTERN;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_BE
7836 | OPTS_TYPE_PT_UNICODE
7837 | OPTS_TYPE_ST_ADD80
7838 | OPTS_TYPE_ST_ADDBITS15;
7839 kern_type = KERN_TYPE_SHA256_PWUSLT;
7840 dgst_size = DGST_SIZE_4_8;
7841 parse_func = sha256s_parse_hash;
7842 sort_by_digest = sort_by_digest_4_8;
7843 opti_type = OPTI_TYPE_ZERO_BYTE
7844 | OPTI_TYPE_PRECOMPUTE_INIT
7845 | OPTI_TYPE_PRECOMPUTE_MERKLE
7846 | OPTI_TYPE_EARLY_SKIP
7847 | OPTI_TYPE_NOT_ITERATED
7848 | OPTI_TYPE_APPENDED_SALT
7849 | OPTI_TYPE_RAW_HASH;
7850 dgst_pos0 = 3;
7851 dgst_pos1 = 7;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 6;
7854 break;
7855
7856 case 1440: hash_type = HASH_TYPE_SHA256;
7857 salt_type = SALT_TYPE_INTERN;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_BE
7860 | OPTS_TYPE_PT_ADD80
7861 | OPTS_TYPE_PT_ADDBITS15
7862 | OPTS_TYPE_PT_UNICODE;
7863 kern_type = KERN_TYPE_SHA256_SLTPWU;
7864 dgst_size = DGST_SIZE_4_8;
7865 parse_func = sha256s_parse_hash;
7866 sort_by_digest = sort_by_digest_4_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_PREPENDED_SALT
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 3;
7875 dgst_pos1 = 7;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 6;
7878 break;
7879
7880 case 1441: hash_type = HASH_TYPE_SHA256;
7881 salt_type = SALT_TYPE_EMBEDDED;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_PT_ADD80
7885 | OPTS_TYPE_PT_ADDBITS15
7886 | OPTS_TYPE_PT_UNICODE
7887 | OPTS_TYPE_ST_BASE64;
7888 kern_type = KERN_TYPE_SHA256_SLTPWU;
7889 dgst_size = DGST_SIZE_4_8;
7890 parse_func = episerver4_parse_hash;
7891 sort_by_digest = sort_by_digest_4_8;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_PREPENDED_SALT
7898 | OPTI_TYPE_RAW_HASH;
7899 dgst_pos0 = 3;
7900 dgst_pos1 = 7;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 6;
7903 break;
7904
7905 case 1450: hash_type = HASH_TYPE_SHA256;
7906 salt_type = SALT_TYPE_INTERN;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_ST_ADD80;
7910 kern_type = KERN_TYPE_HMACSHA256_PW;
7911 dgst_size = DGST_SIZE_4_8;
7912 parse_func = hmacsha256_parse_hash;
7913 sort_by_digest = sort_by_digest_4_8;
7914 opti_type = OPTI_TYPE_ZERO_BYTE
7915 | OPTI_TYPE_NOT_ITERATED;
7916 dgst_pos0 = 3;
7917 dgst_pos1 = 7;
7918 dgst_pos2 = 2;
7919 dgst_pos3 = 6;
7920 break;
7921
7922 case 1460: hash_type = HASH_TYPE_SHA256;
7923 salt_type = SALT_TYPE_INTERN;
7924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925 opts_type = OPTS_TYPE_PT_GENERATE_BE
7926 | OPTS_TYPE_PT_ADD80
7927 | OPTS_TYPE_PT_ADDBITS15;
7928 kern_type = KERN_TYPE_HMACSHA256_SLT;
7929 dgst_size = DGST_SIZE_4_8;
7930 parse_func = hmacsha256_parse_hash;
7931 sort_by_digest = sort_by_digest_4_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_NOT_ITERATED;
7934 dgst_pos0 = 3;
7935 dgst_pos1 = 7;
7936 dgst_pos2 = 2;
7937 dgst_pos3 = 6;
7938 break;
7939
7940 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7941 salt_type = SALT_TYPE_EMBEDDED;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_LE
7944 | OPTS_TYPE_PT_BITSLICE;
7945 kern_type = KERN_TYPE_DESCRYPT;
7946 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7947 parse_func = descrypt_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7951 dgst_pos0 = 0;
7952 dgst_pos1 = 1;
7953 dgst_pos2 = 2;
7954 dgst_pos3 = 3;
7955 break;
7956
7957 case 1600: hash_type = HASH_TYPE_MD5;
7958 salt_type = SALT_TYPE_EMBEDDED;
7959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7961 kern_type = KERN_TYPE_APR1CRYPT;
7962 dgst_size = DGST_SIZE_4_4;
7963 parse_func = md5apr1_parse_hash;
7964 sort_by_digest = sort_by_digest_4_4;
7965 opti_type = OPTI_TYPE_ZERO_BYTE;
7966 dgst_pos0 = 0;
7967 dgst_pos1 = 1;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 3;
7970 break;
7971
7972 case 1700: hash_type = HASH_TYPE_SHA512;
7973 salt_type = SALT_TYPE_NONE;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_ADD80
7977 | OPTS_TYPE_PT_ADDBITS15;
7978 kern_type = KERN_TYPE_SHA512;
7979 dgst_size = DGST_SIZE_8_8;
7980 parse_func = sha512_parse_hash;
7981 sort_by_digest = sort_by_digest_8_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_NOT_SALTED
7988 | OPTI_TYPE_USES_BITS_64
7989 | OPTI_TYPE_RAW_HASH;
7990 dgst_pos0 = 14;
7991 dgst_pos1 = 15;
7992 dgst_pos2 = 6;
7993 dgst_pos3 = 7;
7994 break;
7995
7996 case 1710: hash_type = HASH_TYPE_SHA512;
7997 salt_type = SALT_TYPE_INTERN;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_BE
8000 | OPTS_TYPE_ST_ADD80
8001 | OPTS_TYPE_ST_ADDBITS15;
8002 kern_type = KERN_TYPE_SHA512_PWSLT;
8003 dgst_size = DGST_SIZE_8_8;
8004 parse_func = sha512s_parse_hash;
8005 sort_by_digest = sort_by_digest_8_8;
8006 opti_type = OPTI_TYPE_ZERO_BYTE
8007 | OPTI_TYPE_PRECOMPUTE_INIT
8008 | OPTI_TYPE_PRECOMPUTE_MERKLE
8009 | OPTI_TYPE_EARLY_SKIP
8010 | OPTI_TYPE_NOT_ITERATED
8011 | OPTI_TYPE_APPENDED_SALT
8012 | OPTI_TYPE_USES_BITS_64
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 14;
8015 dgst_pos1 = 15;
8016 dgst_pos2 = 6;
8017 dgst_pos3 = 7;
8018 break;
8019
8020 case 1711: hash_type = HASH_TYPE_SHA512;
8021 salt_type = SALT_TYPE_EMBEDDED;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_ST_ADD80
8025 | OPTS_TYPE_ST_ADDBITS15;
8026 kern_type = KERN_TYPE_SHA512_PWSLT;
8027 dgst_size = DGST_SIZE_8_8;
8028 parse_func = sha512b64s_parse_hash;
8029 sort_by_digest = sort_by_digest_8_8;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP
8034 | OPTI_TYPE_NOT_ITERATED
8035 | OPTI_TYPE_APPENDED_SALT
8036 | OPTI_TYPE_USES_BITS_64
8037 | OPTI_TYPE_RAW_HASH;
8038 dgst_pos0 = 14;
8039 dgst_pos1 = 15;
8040 dgst_pos2 = 6;
8041 dgst_pos3 = 7;
8042 break;
8043
8044 case 1720: hash_type = HASH_TYPE_SHA512;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_BE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS15;
8050 kern_type = KERN_TYPE_SHA512_SLTPW;
8051 dgst_size = DGST_SIZE_8_8;
8052 parse_func = sha512s_parse_hash;
8053 sort_by_digest = sort_by_digest_8_8;
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_INIT
8056 | OPTI_TYPE_PRECOMPUTE_MERKLE
8057 | OPTI_TYPE_EARLY_SKIP
8058 | OPTI_TYPE_NOT_ITERATED
8059 | OPTI_TYPE_PREPENDED_SALT
8060 | OPTI_TYPE_USES_BITS_64
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 14;
8063 dgst_pos1 = 15;
8064 dgst_pos2 = 6;
8065 dgst_pos3 = 7;
8066 break;
8067
8068 case 1722: hash_type = HASH_TYPE_SHA512;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_ADD80
8073 | OPTS_TYPE_PT_ADDBITS15
8074 | OPTS_TYPE_ST_HEX;
8075 kern_type = KERN_TYPE_SHA512_SLTPW;
8076 dgst_size = DGST_SIZE_8_8;
8077 parse_func = osx512_parse_hash;
8078 sort_by_digest = sort_by_digest_8_8;
8079 opti_type = OPTI_TYPE_ZERO_BYTE
8080 | OPTI_TYPE_PRECOMPUTE_INIT
8081 | OPTI_TYPE_PRECOMPUTE_MERKLE
8082 | OPTI_TYPE_EARLY_SKIP
8083 | OPTI_TYPE_NOT_ITERATED
8084 | OPTI_TYPE_PREPENDED_SALT
8085 | OPTI_TYPE_USES_BITS_64
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 14;
8088 dgst_pos1 = 15;
8089 dgst_pos2 = 6;
8090 dgst_pos3 = 7;
8091 break;
8092
8093 case 1730: hash_type = HASH_TYPE_SHA512;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_PT_UNICODE
8098 | OPTS_TYPE_ST_ADD80
8099 | OPTS_TYPE_ST_ADDBITS15;
8100 kern_type = KERN_TYPE_SHA512_PWSLTU;
8101 dgst_size = DGST_SIZE_8_8;
8102 parse_func = sha512s_parse_hash;
8103 sort_by_digest = sort_by_digest_8_8;
8104 opti_type = OPTI_TYPE_ZERO_BYTE
8105 | OPTI_TYPE_PRECOMPUTE_INIT
8106 | OPTI_TYPE_PRECOMPUTE_MERKLE
8107 | OPTI_TYPE_EARLY_SKIP
8108 | OPTI_TYPE_NOT_ITERATED
8109 | OPTI_TYPE_APPENDED_SALT
8110 | OPTI_TYPE_USES_BITS_64
8111 | OPTI_TYPE_RAW_HASH;
8112 dgst_pos0 = 14;
8113 dgst_pos1 = 15;
8114 dgst_pos2 = 6;
8115 dgst_pos3 = 7;
8116 break;
8117
8118 case 1731: hash_type = HASH_TYPE_SHA512;
8119 salt_type = SALT_TYPE_EMBEDDED;
8120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8121 opts_type = OPTS_TYPE_PT_GENERATE_BE
8122 | OPTS_TYPE_PT_UNICODE
8123 | OPTS_TYPE_ST_ADD80
8124 | OPTS_TYPE_ST_ADDBITS15
8125 | OPTS_TYPE_ST_HEX;
8126 kern_type = KERN_TYPE_SHA512_PWSLTU;
8127 dgst_size = DGST_SIZE_8_8;
8128 parse_func = mssql2012_parse_hash;
8129 sort_by_digest = sort_by_digest_8_8;
8130 opti_type = OPTI_TYPE_ZERO_BYTE
8131 | OPTI_TYPE_PRECOMPUTE_INIT
8132 | OPTI_TYPE_PRECOMPUTE_MERKLE
8133 | OPTI_TYPE_EARLY_SKIP
8134 | OPTI_TYPE_NOT_ITERATED
8135 | OPTI_TYPE_APPENDED_SALT
8136 | OPTI_TYPE_USES_BITS_64
8137 | OPTI_TYPE_RAW_HASH;
8138 dgst_pos0 = 14;
8139 dgst_pos1 = 15;
8140 dgst_pos2 = 6;
8141 dgst_pos3 = 7;
8142 break;
8143
8144 case 1740: hash_type = HASH_TYPE_SHA512;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_BE
8148 | OPTS_TYPE_PT_ADD80
8149 | OPTS_TYPE_PT_ADDBITS15
8150 | OPTS_TYPE_PT_UNICODE;
8151 kern_type = KERN_TYPE_SHA512_SLTPWU;
8152 dgst_size = DGST_SIZE_8_8;
8153 parse_func = sha512s_parse_hash;
8154 sort_by_digest = sort_by_digest_8_8;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_PRECOMPUTE_INIT
8157 | OPTI_TYPE_PRECOMPUTE_MERKLE
8158 | OPTI_TYPE_EARLY_SKIP
8159 | OPTI_TYPE_NOT_ITERATED
8160 | OPTI_TYPE_PREPENDED_SALT
8161 | OPTI_TYPE_USES_BITS_64
8162 | OPTI_TYPE_RAW_HASH;
8163 dgst_pos0 = 14;
8164 dgst_pos1 = 15;
8165 dgst_pos2 = 6;
8166 dgst_pos3 = 7;
8167 break;
8168
8169 case 1750: hash_type = HASH_TYPE_SHA512;
8170 salt_type = SALT_TYPE_INTERN;
8171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8172 opts_type = OPTS_TYPE_PT_GENERATE_BE
8173 | OPTS_TYPE_ST_ADD80;
8174 kern_type = KERN_TYPE_HMACSHA512_PW;
8175 dgst_size = DGST_SIZE_8_8;
8176 parse_func = hmacsha512_parse_hash;
8177 sort_by_digest = sort_by_digest_8_8;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_USES_BITS_64
8180 | OPTI_TYPE_NOT_ITERATED;
8181 dgst_pos0 = 14;
8182 dgst_pos1 = 15;
8183 dgst_pos2 = 6;
8184 dgst_pos3 = 7;
8185 break;
8186
8187 case 1760: hash_type = HASH_TYPE_SHA512;
8188 salt_type = SALT_TYPE_INTERN;
8189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8190 opts_type = OPTS_TYPE_PT_GENERATE_BE
8191 | OPTS_TYPE_PT_ADD80
8192 | OPTS_TYPE_PT_ADDBITS15;
8193 kern_type = KERN_TYPE_HMACSHA512_SLT;
8194 dgst_size = DGST_SIZE_8_8;
8195 parse_func = hmacsha512_parse_hash;
8196 sort_by_digest = sort_by_digest_8_8;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_USES_BITS_64
8199 | OPTI_TYPE_NOT_ITERATED;
8200 dgst_pos0 = 14;
8201 dgst_pos1 = 15;
8202 dgst_pos2 = 6;
8203 dgst_pos3 = 7;
8204 break;
8205
8206 case 1800: hash_type = HASH_TYPE_SHA512;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8210 kern_type = KERN_TYPE_SHA512CRYPT;
8211 dgst_size = DGST_SIZE_8_8;
8212 parse_func = sha512crypt_parse_hash;
8213 sort_by_digest = sort_by_digest_8_8;
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_USES_BITS_64;
8216 dgst_pos0 = 0;
8217 dgst_pos1 = 1;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 3;
8220 break;
8221
8222 case 2100: hash_type = HASH_TYPE_DCC2;
8223 salt_type = SALT_TYPE_EMBEDDED;
8224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8226 | OPTS_TYPE_ST_LOWER
8227 | OPTS_TYPE_ST_UNICODE;
8228 kern_type = KERN_TYPE_DCC2;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = dcc2_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 1;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 3;
8237 break;
8238
8239 case 2400: hash_type = HASH_TYPE_MD5;
8240 salt_type = SALT_TYPE_NONE;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8243 kern_type = KERN_TYPE_MD5PIX;
8244 dgst_size = DGST_SIZE_4_4;
8245 parse_func = md5pix_parse_hash;
8246 sort_by_digest = sort_by_digest_4_4;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_NOT_SALTED;
8253 dgst_pos0 = 0;
8254 dgst_pos1 = 3;
8255 dgst_pos2 = 2;
8256 dgst_pos3 = 1;
8257 break;
8258
8259 case 2410: hash_type = HASH_TYPE_MD5;
8260 salt_type = SALT_TYPE_INTERN;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8263 kern_type = KERN_TYPE_MD5ASA;
8264 dgst_size = DGST_SIZE_4_4;
8265 parse_func = md5asa_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 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 2500: hash_type = HASH_TYPE_WPA;
8279 salt_type = SALT_TYPE_EMBEDDED;
8280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8282 kern_type = KERN_TYPE_WPA;
8283 dgst_size = DGST_SIZE_4_4;
8284 parse_func = wpa_parse_hash;
8285 sort_by_digest = sort_by_digest_4_4;
8286 opti_type = OPTI_TYPE_ZERO_BYTE;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 1;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 3;
8291 break;
8292
8293 case 2600: hash_type = HASH_TYPE_MD5;
8294 salt_type = SALT_TYPE_VIRTUAL;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_LE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS14
8299 | OPTS_TYPE_ST_ADD80;
8300 kern_type = KERN_TYPE_MD55_PWSLT1;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = md5md5_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 3;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 1;
8312 break;
8313
8314 case 2611: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_ST_ADD80;
8321 kern_type = KERN_TYPE_MD55_PWSLT1;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = vb3_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_PRECOMPUTE_MERKLE
8328 | OPTI_TYPE_EARLY_SKIP;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 3;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 1;
8333 break;
8334
8335 case 2612: hash_type = HASH_TYPE_MD5;
8336 salt_type = SALT_TYPE_EMBEDDED;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS14
8341 | OPTS_TYPE_ST_ADD80
8342 | OPTS_TYPE_ST_HEX;
8343 kern_type = KERN_TYPE_MD55_PWSLT1;
8344 dgst_size = DGST_SIZE_4_4;
8345 parse_func = phps_parse_hash;
8346 sort_by_digest = sort_by_digest_4_4;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_PRECOMPUTE_INIT
8349 | OPTI_TYPE_PRECOMPUTE_MERKLE
8350 | OPTI_TYPE_EARLY_SKIP;
8351 dgst_pos0 = 0;
8352 dgst_pos1 = 3;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 1;
8355 break;
8356
8357 case 2711: hash_type = HASH_TYPE_MD5;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_LE
8361 | OPTS_TYPE_PT_ADD80
8362 | OPTS_TYPE_PT_ADDBITS14
8363 | OPTS_TYPE_ST_ADD80;
8364 kern_type = KERN_TYPE_MD55_PWSLT2;
8365 dgst_size = DGST_SIZE_4_4;
8366 parse_func = vb30_parse_hash;
8367 sort_by_digest = sort_by_digest_4_4;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_PRECOMPUTE_INIT
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 2811: 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 kern_type = KERN_TYPE_MD55_SLTPW;
8384 dgst_size = DGST_SIZE_4_4;
8385 parse_func = ipb2_parse_hash;
8386 sort_by_digest = sort_by_digest_4_4;
8387 opti_type = OPTI_TYPE_ZERO_BYTE
8388 | OPTI_TYPE_PRECOMPUTE_INIT
8389 | OPTI_TYPE_EARLY_SKIP;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 3000: hash_type = HASH_TYPE_LM;
8397 salt_type = SALT_TYPE_NONE;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE
8400 | OPTS_TYPE_PT_UPPER
8401 | OPTS_TYPE_PT_BITSLICE;
8402 kern_type = KERN_TYPE_LM;
8403 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8404 parse_func = lm_parse_hash;
8405 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8406 opti_type = OPTI_TYPE_ZERO_BYTE
8407 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 1;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 3;
8412 break;
8413
8414 case 3100: hash_type = HASH_TYPE_ORACLEH;
8415 salt_type = SALT_TYPE_INTERN;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_PT_UPPER
8419 | OPTS_TYPE_ST_UPPER;
8420 kern_type = KERN_TYPE_ORACLEH;
8421 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8422 parse_func = oracleh_parse_hash;
8423 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 3200: hash_type = HASH_TYPE_BCRYPT;
8432 salt_type = SALT_TYPE_EMBEDDED;
8433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_ST_GENERATE_LE;
8436 kern_type = KERN_TYPE_BCRYPT;
8437 dgst_size = DGST_SIZE_4_6;
8438 parse_func = bcrypt_parse_hash;
8439 sort_by_digest = sort_by_digest_4_6;
8440 opti_type = OPTI_TYPE_ZERO_BYTE;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 1;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 3;
8445 break;
8446
8447 case 3710: hash_type = HASH_TYPE_MD5;
8448 salt_type = SALT_TYPE_INTERN;
8449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE
8451 | OPTS_TYPE_PT_ADD80
8452 | OPTS_TYPE_PT_ADDBITS14;
8453 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8454 dgst_size = DGST_SIZE_4_4;
8455 parse_func = md5s_parse_hash;
8456 sort_by_digest = sort_by_digest_4_4;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_PRECOMPUTE_INIT
8459 | OPTI_TYPE_PRECOMPUTE_MERKLE
8460 | OPTI_TYPE_EARLY_SKIP;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 3711: hash_type = HASH_TYPE_MD5;
8468 salt_type = SALT_TYPE_EMBEDDED;
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 = mediawiki_b_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 3800: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE
8491 | OPTS_TYPE_ST_ADDBITS14;
8492 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5s_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP
8500 | OPTI_TYPE_NOT_ITERATED
8501 | OPTI_TYPE_RAW_HASH;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 4300: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_VIRTUAL;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS14
8514 | OPTS_TYPE_ST_ADD80;
8515 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8516 dgst_size = DGST_SIZE_4_4;
8517 parse_func = md5md5_parse_hash;
8518 sort_by_digest = sort_by_digest_4_4;
8519 opti_type = OPTI_TYPE_ZERO_BYTE
8520 | OPTI_TYPE_PRECOMPUTE_INIT
8521 | OPTI_TYPE_PRECOMPUTE_MERKLE
8522 | OPTI_TYPE_EARLY_SKIP;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 3;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 1;
8527 break;
8528
8529
8530 case 4400: hash_type = HASH_TYPE_MD5;
8531 salt_type = SALT_TYPE_NONE;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_BE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS15;
8536 kern_type = KERN_TYPE_MD5_SHA1;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = md5_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_ITERATED
8545 | OPTI_TYPE_NOT_SALTED
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 3;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 1;
8551 break;
8552
8553 case 4500: hash_type = HASH_TYPE_SHA1;
8554 salt_type = SALT_TYPE_NONE;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_PT_ADD80
8558 | OPTS_TYPE_PT_ADDBITS15;
8559 kern_type = KERN_TYPE_SHA11;
8560 dgst_size = DGST_SIZE_4_5;
8561 parse_func = sha1_parse_hash;
8562 sort_by_digest = sort_by_digest_4_5;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_EARLY_SKIP
8567 | OPTI_TYPE_NOT_SALTED;
8568 dgst_pos0 = 3;
8569 dgst_pos1 = 4;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 4700: hash_type = HASH_TYPE_SHA1;
8575 salt_type = SALT_TYPE_NONE;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADD80
8579 | OPTS_TYPE_PT_ADDBITS14;
8580 kern_type = KERN_TYPE_SHA1_MD5;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = sha1_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP
8588 | OPTI_TYPE_NOT_ITERATED
8589 | OPTI_TYPE_NOT_SALTED
8590 | OPTI_TYPE_RAW_HASH;
8591 dgst_pos0 = 3;
8592 dgst_pos1 = 4;
8593 dgst_pos2 = 2;
8594 dgst_pos3 = 1;
8595 break;
8596
8597 case 4800: hash_type = HASH_TYPE_MD5;
8598 salt_type = SALT_TYPE_EMBEDDED;
8599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8600 opts_type = OPTS_TYPE_PT_GENERATE_LE
8601 | OPTS_TYPE_PT_ADDBITS14;
8602 kern_type = KERN_TYPE_MD5_CHAP;
8603 dgst_size = DGST_SIZE_4_4;
8604 parse_func = chap_parse_hash;
8605 sort_by_digest = sort_by_digest_4_4;
8606 opti_type = OPTI_TYPE_ZERO_BYTE
8607 | OPTI_TYPE_PRECOMPUTE_INIT
8608 | OPTI_TYPE_PRECOMPUTE_MERKLE
8609 | OPTI_TYPE_MEET_IN_MIDDLE
8610 | OPTI_TYPE_EARLY_SKIP
8611 | OPTI_TYPE_NOT_ITERATED
8612 | OPTI_TYPE_RAW_HASH;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 3;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 1;
8617 break;
8618
8619 case 4900: hash_type = HASH_TYPE_SHA1;
8620 salt_type = SALT_TYPE_INTERN;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8623 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8624 dgst_size = DGST_SIZE_4_5;
8625 parse_func = sha1s_parse_hash;
8626 sort_by_digest = sort_by_digest_4_5;
8627 opti_type = OPTI_TYPE_ZERO_BYTE
8628 | OPTI_TYPE_PRECOMPUTE_INIT
8629 | OPTI_TYPE_PRECOMPUTE_MERKLE
8630 | OPTI_TYPE_EARLY_SKIP;
8631 dgst_pos0 = 3;
8632 dgst_pos1 = 4;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 1;
8635 break;
8636
8637 case 5000: hash_type = HASH_TYPE_KECCAK;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD01;
8642 kern_type = KERN_TYPE_KECCAK;
8643 dgst_size = DGST_SIZE_8_25;
8644 parse_func = keccak_parse_hash;
8645 sort_by_digest = sort_by_digest_8_25;
8646 opti_type = OPTI_TYPE_ZERO_BYTE
8647 | OPTI_TYPE_USES_BITS_64
8648 | OPTI_TYPE_RAW_HASH;
8649 dgst_pos0 = 2;
8650 dgst_pos1 = 3;
8651 dgst_pos2 = 4;
8652 dgst_pos3 = 5;
8653 break;
8654
8655 case 5100: hash_type = HASH_TYPE_MD5H;
8656 salt_type = SALT_TYPE_NONE;
8657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE
8659 | OPTS_TYPE_PT_ADD80
8660 | OPTS_TYPE_PT_ADDBITS14;
8661 kern_type = KERN_TYPE_MD5H;
8662 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8663 parse_func = md5half_parse_hash;
8664 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8665 opti_type = OPTI_TYPE_ZERO_BYTE
8666 | OPTI_TYPE_RAW_HASH;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 1;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 3;
8671 break;
8672
8673 case 5200: hash_type = HASH_TYPE_SHA256;
8674 salt_type = SALT_TYPE_EMBEDDED;
8675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8677 kern_type = KERN_TYPE_PSAFE3;
8678 dgst_size = DGST_SIZE_4_8;
8679 parse_func = psafe3_parse_hash;
8680 sort_by_digest = sort_by_digest_4_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 5300: hash_type = HASH_TYPE_MD5;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE
8692 | OPTS_TYPE_ST_ADD80;
8693 kern_type = KERN_TYPE_IKEPSK_MD5;
8694 dgst_size = DGST_SIZE_4_4;
8695 parse_func = ikepsk_md5_parse_hash;
8696 sort_by_digest = sort_by_digest_4_4;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 3;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5400: hash_type = HASH_TYPE_SHA1;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_BE
8708 | OPTS_TYPE_ST_ADD80;
8709 kern_type = KERN_TYPE_IKEPSK_SHA1;
8710 dgst_size = DGST_SIZE_4_5;
8711 parse_func = ikepsk_sha1_parse_hash;
8712 sort_by_digest = sort_by_digest_4_5;
8713 opti_type = OPTI_TYPE_ZERO_BYTE;
8714 dgst_pos0 = 3;
8715 dgst_pos1 = 4;
8716 dgst_pos2 = 2;
8717 dgst_pos3 = 1;
8718 break;
8719
8720 case 5500: hash_type = HASH_TYPE_NETNTLM;
8721 salt_type = SALT_TYPE_EMBEDDED;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_LE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS14
8726 | OPTS_TYPE_PT_UNICODE
8727 | OPTS_TYPE_ST_HEX;
8728 kern_type = KERN_TYPE_NETNTLMv1;
8729 dgst_size = DGST_SIZE_4_4;
8730 parse_func = netntlmv1_parse_hash;
8731 sort_by_digest = sort_by_digest_4_4;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 5600: hash_type = HASH_TYPE_MD5;
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 kern_type = KERN_TYPE_NETNTLMv2;
8748 dgst_size = DGST_SIZE_4_4;
8749 parse_func = netntlmv2_parse_hash;
8750 sort_by_digest = sort_by_digest_4_4;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 3;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 1;
8756 break;
8757
8758 case 5700: hash_type = HASH_TYPE_SHA256;
8759 salt_type = SALT_TYPE_NONE;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_BE
8762 | OPTS_TYPE_PT_ADD80
8763 | OPTS_TYPE_PT_ADDBITS15;
8764 kern_type = KERN_TYPE_SHA256;
8765 dgst_size = DGST_SIZE_4_8;
8766 parse_func = cisco4_parse_hash;
8767 sort_by_digest = sort_by_digest_4_8;
8768 opti_type = OPTI_TYPE_ZERO_BYTE
8769 | OPTI_TYPE_PRECOMPUTE_INIT
8770 | OPTI_TYPE_PRECOMPUTE_MERKLE
8771 | OPTI_TYPE_EARLY_SKIP
8772 | OPTI_TYPE_NOT_ITERATED
8773 | OPTI_TYPE_NOT_SALTED
8774 | OPTI_TYPE_RAW_HASH;
8775 dgst_pos0 = 3;
8776 dgst_pos1 = 7;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 6;
8779 break;
8780
8781 case 5800: hash_type = HASH_TYPE_SHA1;
8782 salt_type = SALT_TYPE_INTERN;
8783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8785 | OPTS_TYPE_ST_ADD80;
8786 kern_type = KERN_TYPE_ANDROIDPIN;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = androidpin_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8798 salt_type = SALT_TYPE_NONE;
8799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE
8801 | OPTS_TYPE_PT_ADD80;
8802 kern_type = KERN_TYPE_RIPEMD160;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = ripemd160_parse_hash;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8814 salt_type = SALT_TYPE_NONE;
8815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_BE
8817 | OPTS_TYPE_PT_ADD80;
8818 kern_type = KERN_TYPE_WHIRLPOOL;
8819 dgst_size = DGST_SIZE_4_16;
8820 parse_func = whirlpool_parse_hash;
8821 sort_by_digest = sort_by_digest_4_16;
8822 opti_type = OPTI_TYPE_ZERO_BYTE;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8833 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8834 dgst_size = DGST_SIZE_4_5;
8835 parse_func = truecrypt_parse_hash_2k;
8836 sort_by_digest = sort_by_digest_4_5;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8849 dgst_size = DGST_SIZE_4_5;
8850 parse_func = truecrypt_parse_hash_2k;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8863 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8864 dgst_size = DGST_SIZE_4_5;
8865 parse_func = truecrypt_parse_hash_2k;
8866 sort_by_digest = sort_by_digest_4_5;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6221: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_TCSHA512_XTS512;
8879 dgst_size = DGST_SIZE_8_8;
8880 parse_func = truecrypt_parse_hash_1k;
8881 sort_by_digest = sort_by_digest_8_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6222: hash_type = HASH_TYPE_SHA512;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8895 dgst_size = DGST_SIZE_8_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_8_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE
8899 | OPTI_TYPE_USES_BITS_64;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6223: hash_type = HASH_TYPE_SHA512;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8910 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8911 dgst_size = DGST_SIZE_8_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_8_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE
8915 | OPTI_TYPE_USES_BITS_64;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8926 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8927 dgst_size = DGST_SIZE_4_8;
8928 parse_func = truecrypt_parse_hash_1k;
8929 sort_by_digest = sort_by_digest_4_8;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8957 dgst_size = DGST_SIZE_4_8;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_8;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8972 dgst_size = DGST_SIZE_4_5;
8973 parse_func = truecrypt_parse_hash_1k;
8974 sort_by_digest = sort_by_digest_4_5;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8987 dgst_size = DGST_SIZE_4_5;
8988 parse_func = truecrypt_parse_hash_1k;
8989 sort_by_digest = sort_by_digest_4_5;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_1k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6300: hash_type = HASH_TYPE_MD5;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_MD5AIX;
9017 dgst_size = DGST_SIZE_4_4;
9018 parse_func = md5aix_parse_hash;
9019 sort_by_digest = sort_by_digest_4_4;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6400: hash_type = HASH_TYPE_SHA256;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_SHA256AIX;
9032 dgst_size = DGST_SIZE_4_8;
9033 parse_func = sha256aix_parse_hash;
9034 sort_by_digest = sort_by_digest_4_8;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6500: hash_type = HASH_TYPE_SHA512;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_SHA512AIX;
9047 dgst_size = DGST_SIZE_8_8;
9048 parse_func = sha512aix_parse_hash;
9049 sort_by_digest = sort_by_digest_8_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE
9051 | OPTI_TYPE_USES_BITS_64;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6600: hash_type = HASH_TYPE_AES;
9059 salt_type = SALT_TYPE_EMBEDDED;
9060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9062 kern_type = KERN_TYPE_AGILEKEY;
9063 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9064 parse_func = agilekey_parse_hash;
9065 sort_by_digest = sort_by_digest_4_5;
9066 opti_type = OPTI_TYPE_ZERO_BYTE;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6700: hash_type = HASH_TYPE_SHA1;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9077 kern_type = KERN_TYPE_SHA1AIX;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = sha1aix_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 6800: hash_type = HASH_TYPE_AES;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9092 kern_type = KERN_TYPE_LASTPASS;
9093 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9094 parse_func = lastpass_parse_hash;
9095 sort_by_digest = sort_by_digest_4_8;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 6900: hash_type = HASH_TYPE_GOST;
9104 salt_type = SALT_TYPE_NONE;
9105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_GOST;
9108 dgst_size = DGST_SIZE_4_8;
9109 parse_func = gost_parse_hash;
9110 sort_by_digest = sort_by_digest_4_8;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7100: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA512;
9123 dgst_size = DGST_SIZE_8_16;
9124 parse_func = sha512osx_parse_hash;
9125 sort_by_digest = sort_by_digest_8_16;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 7200: hash_type = HASH_TYPE_SHA512;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9138 kern_type = KERN_TYPE_PBKDF2_SHA512;
9139 dgst_size = DGST_SIZE_8_16;
9140 parse_func = sha512grub_parse_hash;
9141 sort_by_digest = sort_by_digest_8_16;
9142 opti_type = OPTI_TYPE_ZERO_BYTE
9143 | OPTI_TYPE_USES_BITS_64;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 7300: hash_type = HASH_TYPE_SHA1;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_BE
9154 | OPTS_TYPE_ST_ADD80
9155 | OPTS_TYPE_ST_ADDBITS15;
9156 kern_type = KERN_TYPE_RAKP;
9157 dgst_size = DGST_SIZE_4_5;
9158 parse_func = rakp_parse_hash;
9159 sort_by_digest = sort_by_digest_4_5;
9160 opti_type = OPTI_TYPE_ZERO_BYTE
9161 | OPTI_TYPE_NOT_ITERATED;
9162 dgst_pos0 = 3;
9163 dgst_pos1 = 4;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 1;
9166 break;
9167
9168 case 7400: hash_type = HASH_TYPE_SHA256;
9169 salt_type = SALT_TYPE_EMBEDDED;
9170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9172 kern_type = KERN_TYPE_SHA256CRYPT;
9173 dgst_size = DGST_SIZE_4_8;
9174 parse_func = sha256crypt_parse_hash;
9175 sort_by_digest = sort_by_digest_4_8;
9176 opti_type = OPTI_TYPE_ZERO_BYTE;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 7500: hash_type = HASH_TYPE_KRB5PA;
9184 salt_type = SALT_TYPE_EMBEDDED;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9187 kern_type = KERN_TYPE_KRB5PA;
9188 dgst_size = DGST_SIZE_4_4;
9189 parse_func = krb5pa_parse_hash;
9190 sort_by_digest = sort_by_digest_4_4;
9191 opti_type = OPTI_TYPE_ZERO_BYTE
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 7600: hash_type = HASH_TYPE_SHA1;
9200 salt_type = SALT_TYPE_INTERN;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_BE
9203 | OPTS_TYPE_PT_ADD80
9204 | OPTS_TYPE_PT_ADDBITS15;
9205 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9206 dgst_size = DGST_SIZE_4_5;
9207 parse_func = redmine_parse_hash;
9208 sort_by_digest = sort_by_digest_4_5;
9209 opti_type = OPTI_TYPE_ZERO_BYTE
9210 | OPTI_TYPE_PRECOMPUTE_INIT
9211 | OPTI_TYPE_EARLY_SKIP
9212 | OPTI_TYPE_NOT_ITERATED
9213 | OPTI_TYPE_PREPENDED_SALT;
9214 dgst_pos0 = 3;
9215 dgst_pos1 = 4;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 1;
9218 break;
9219
9220 case 7700: hash_type = HASH_TYPE_SAPB;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_LE
9224 | OPTS_TYPE_PT_UPPER
9225 | OPTS_TYPE_ST_UPPER;
9226 kern_type = KERN_TYPE_SAPB;
9227 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9228 parse_func = sapb_parse_hash;
9229 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9230 opti_type = OPTI_TYPE_ZERO_BYTE
9231 | OPTI_TYPE_PRECOMPUTE_INIT
9232 | OPTI_TYPE_NOT_ITERATED;
9233 dgst_pos0 = 0;
9234 dgst_pos1 = 1;
9235 dgst_pos2 = 2;
9236 dgst_pos3 = 3;
9237 break;
9238
9239 case 7800: hash_type = HASH_TYPE_SAPG;
9240 salt_type = SALT_TYPE_EMBEDDED;
9241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9242 opts_type = OPTS_TYPE_PT_GENERATE_BE
9243 | OPTS_TYPE_ST_ADD80
9244 | OPTS_TYPE_ST_UPPER;
9245 kern_type = KERN_TYPE_SAPG;
9246 dgst_size = DGST_SIZE_4_5;
9247 parse_func = sapg_parse_hash;
9248 sort_by_digest = sort_by_digest_4_5;
9249 opti_type = OPTI_TYPE_ZERO_BYTE
9250 | OPTI_TYPE_PRECOMPUTE_INIT
9251 | OPTI_TYPE_NOT_ITERATED;
9252 dgst_pos0 = 3;
9253 dgst_pos1 = 4;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 1;
9256 break;
9257
9258 case 7900: hash_type = HASH_TYPE_SHA512;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9262 kern_type = KERN_TYPE_DRUPAL7;
9263 dgst_size = DGST_SIZE_8_8;
9264 parse_func = drupal7_parse_hash;
9265 sort_by_digest = sort_by_digest_8_8;
9266 opti_type = OPTI_TYPE_ZERO_BYTE
9267 | OPTI_TYPE_USES_BITS_64;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 8000: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_BE
9278 | OPTS_TYPE_PT_UNICODE
9279 | OPTS_TYPE_ST_ADD80
9280 | OPTS_TYPE_ST_HEX;
9281 kern_type = KERN_TYPE_SYBASEASE;
9282 dgst_size = DGST_SIZE_4_8;
9283 parse_func = sybasease_parse_hash;
9284 sort_by_digest = sort_by_digest_4_8;
9285 opti_type = OPTI_TYPE_ZERO_BYTE
9286 | OPTI_TYPE_PRECOMPUTE_INIT
9287 | OPTI_TYPE_EARLY_SKIP
9288 | OPTI_TYPE_NOT_ITERATED
9289 | OPTI_TYPE_RAW_HASH;
9290 dgst_pos0 = 3;
9291 dgst_pos1 = 7;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 6;
9294 break;
9295
9296 case 8100: hash_type = HASH_TYPE_SHA1;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9300 kern_type = KERN_TYPE_NETSCALER;
9301 dgst_size = DGST_SIZE_4_5;
9302 parse_func = netscaler_parse_hash;
9303 sort_by_digest = sort_by_digest_4_5;
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_PRECOMPUTE_INIT
9306 | OPTI_TYPE_PRECOMPUTE_MERKLE
9307 | OPTI_TYPE_EARLY_SKIP
9308 | OPTI_TYPE_NOT_ITERATED
9309 | OPTI_TYPE_PREPENDED_SALT
9310 | OPTI_TYPE_RAW_HASH;
9311 dgst_pos0 = 3;
9312 dgst_pos1 = 4;
9313 dgst_pos2 = 2;
9314 dgst_pos3 = 1;
9315 break;
9316
9317 case 8200: hash_type = HASH_TYPE_SHA256;
9318 salt_type = SALT_TYPE_EMBEDDED;
9319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9320 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9321 kern_type = KERN_TYPE_CLOUDKEY;
9322 dgst_size = DGST_SIZE_4_8;
9323 parse_func = cloudkey_parse_hash;
9324 sort_by_digest = sort_by_digest_4_8;
9325 opti_type = OPTI_TYPE_ZERO_BYTE;
9326 dgst_pos0 = 0;
9327 dgst_pos1 = 1;
9328 dgst_pos2 = 2;
9329 dgst_pos3 = 3;
9330 break;
9331
9332 case 8300: hash_type = HASH_TYPE_SHA1;
9333 salt_type = SALT_TYPE_EMBEDDED;
9334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9335 opts_type = OPTS_TYPE_PT_GENERATE_BE
9336 | OPTS_TYPE_ST_HEX
9337 | OPTS_TYPE_ST_ADD80;
9338 kern_type = KERN_TYPE_NSEC3;
9339 dgst_size = DGST_SIZE_4_5;
9340 parse_func = nsec3_parse_hash;
9341 sort_by_digest = sort_by_digest_4_5;
9342 opti_type = OPTI_TYPE_ZERO_BYTE;
9343 dgst_pos0 = 3;
9344 dgst_pos1 = 4;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 1;
9347 break;
9348
9349 case 8400: hash_type = HASH_TYPE_SHA1;
9350 salt_type = SALT_TYPE_INTERN;
9351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_BE
9353 | OPTS_TYPE_PT_ADD80
9354 | OPTS_TYPE_PT_ADDBITS15;
9355 kern_type = KERN_TYPE_WBB3;
9356 dgst_size = DGST_SIZE_4_5;
9357 parse_func = wbb3_parse_hash;
9358 sort_by_digest = sort_by_digest_4_5;
9359 opti_type = OPTI_TYPE_ZERO_BYTE
9360 | OPTI_TYPE_PRECOMPUTE_INIT
9361 | OPTI_TYPE_NOT_ITERATED;
9362 dgst_pos0 = 3;
9363 dgst_pos1 = 4;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 1;
9366 break;
9367
9368 case 8500: hash_type = HASH_TYPE_DESRACF;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE
9372 | OPTS_TYPE_ST_UPPER;
9373 kern_type = KERN_TYPE_RACF;
9374 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9375 parse_func = racf_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9377 opti_type = OPTI_TYPE_ZERO_BYTE
9378 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9379 dgst_pos0 = 0;
9380 dgst_pos1 = 1;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 3;
9383 break;
9384
9385 case 8600: hash_type = HASH_TYPE_LOTUS5;
9386 salt_type = SALT_TYPE_NONE;
9387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9389 kern_type = KERN_TYPE_LOTUS5;
9390 dgst_size = DGST_SIZE_4_4;
9391 parse_func = lotus5_parse_hash;
9392 sort_by_digest = sort_by_digest_4_4;
9393 opti_type = OPTI_TYPE_EARLY_SKIP
9394 | OPTI_TYPE_NOT_ITERATED
9395 | OPTI_TYPE_NOT_SALTED
9396 | OPTI_TYPE_RAW_HASH;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 8700: hash_type = HASH_TYPE_LOTUS6;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9407 kern_type = KERN_TYPE_LOTUS6;
9408 dgst_size = DGST_SIZE_4_4;
9409 parse_func = lotus6_parse_hash;
9410 sort_by_digest = sort_by_digest_4_4;
9411 opti_type = OPTI_TYPE_EARLY_SKIP
9412 | OPTI_TYPE_NOT_ITERATED
9413 | OPTI_TYPE_RAW_HASH;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_ANDROIDFDE;
9425 dgst_size = DGST_SIZE_4_4;
9426 parse_func = androidfde_parse_hash;
9427 sort_by_digest = sort_by_digest_4_4;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 8900: hash_type = HASH_TYPE_SCRYPT;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9439 kern_type = KERN_TYPE_SCRYPT;
9440 dgst_size = DGST_SIZE_4_8;
9441 parse_func = scrypt_parse_hash;
9442 sort_by_digest = sort_by_digest_4_8;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9000: hash_type = HASH_TYPE_SHA1;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE
9454 | OPTS_TYPE_ST_GENERATE_LE;
9455 kern_type = KERN_TYPE_PSAFE2;
9456 dgst_size = DGST_SIZE_4_5;
9457 parse_func = psafe2_parse_hash;
9458 sort_by_digest = sort_by_digest_4_5;
9459 opti_type = OPTI_TYPE_ZERO_BYTE;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 9100: hash_type = HASH_TYPE_LOTUS8;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9470 kern_type = KERN_TYPE_LOTUS8;
9471 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9472 parse_func = lotus8_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9474 opti_type = OPTI_TYPE_ZERO_BYTE;
9475 dgst_pos0 = 0;
9476 dgst_pos1 = 1;
9477 dgst_pos2 = 2;
9478 dgst_pos3 = 3;
9479 break;
9480
9481 case 9200: hash_type = HASH_TYPE_SHA256;
9482 salt_type = SALT_TYPE_EMBEDDED;
9483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9484 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9485 kern_type = KERN_TYPE_PBKDF2_SHA256;
9486 dgst_size = DGST_SIZE_4_32;
9487 parse_func = cisco8_parse_hash;
9488 sort_by_digest = sort_by_digest_4_32;
9489 opti_type = OPTI_TYPE_ZERO_BYTE;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 9300: hash_type = HASH_TYPE_SCRYPT;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9500 kern_type = KERN_TYPE_SCRYPT;
9501 dgst_size = DGST_SIZE_4_8;
9502 parse_func = cisco9_parse_hash;
9503 sort_by_digest = sort_by_digest_4_8;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_OFFICE2007;
9516 dgst_size = DGST_SIZE_4_4;
9517 parse_func = office2007_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4;
9519 opti_type = OPTI_TYPE_ZERO_BYTE;
9520 dgst_pos0 = 0;
9521 dgst_pos1 = 1;
9522 dgst_pos2 = 2;
9523 dgst_pos3 = 3;
9524 break;
9525
9526 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9527 salt_type = SALT_TYPE_EMBEDDED;
9528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9530 kern_type = KERN_TYPE_OFFICE2010;
9531 dgst_size = DGST_SIZE_4_4;
9532 parse_func = office2010_parse_hash;
9533 sort_by_digest = sort_by_digest_4_4;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_OFFICE2013;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = office2013_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE
9560 | OPTS_TYPE_PT_ADD80
9561 | OPTS_TYPE_PT_UNICODE;
9562 kern_type = KERN_TYPE_OLDOFFICE01;
9563 dgst_size = DGST_SIZE_4_4;
9564 parse_func = oldoffice01_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_PRECOMPUTE_INIT
9568 | OPTI_TYPE_NOT_ITERATED;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE
9579 | OPTS_TYPE_PT_ADD80;
9580 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = oldoffice01cm1_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE
9585 | OPTI_TYPE_PRECOMPUTE_INIT
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_PT_ADD80
9598 | OPTS_TYPE_PT_UNICODE
9599 | OPTS_TYPE_PT_NEVERCRACK;
9600 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = oldoffice01cm2_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 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_BE
9617 | OPTS_TYPE_PT_ADD80
9618 | OPTS_TYPE_PT_UNICODE;
9619 kern_type = KERN_TYPE_OLDOFFICE34;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = oldoffice34_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE
9624 | OPTI_TYPE_PRECOMPUTE_INIT
9625 | OPTI_TYPE_NOT_ITERATED;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9637 dgst_size = DGST_SIZE_4_4;
9638 parse_func = oldoffice34cm1_parse_hash;
9639 sort_by_digest = sort_by_digest_4_4;
9640 opti_type = OPTI_TYPE_ZERO_BYTE
9641 | OPTI_TYPE_PRECOMPUTE_INIT
9642 | OPTI_TYPE_NOT_ITERATED;
9643 dgst_pos0 = 0;
9644 dgst_pos1 = 1;
9645 dgst_pos2 = 2;
9646 dgst_pos3 = 3;
9647 break;
9648
9649 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9650 salt_type = SALT_TYPE_EMBEDDED;
9651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9652 opts_type = OPTS_TYPE_PT_GENERATE_BE
9653 | OPTS_TYPE_PT_ADD80
9654 | OPTS_TYPE_PT_UNICODE
9655 | OPTS_TYPE_PT_NEVERCRACK;
9656 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9657 dgst_size = DGST_SIZE_4_4;
9658 parse_func = oldoffice34cm2_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 9900: hash_type = HASH_TYPE_MD5;
9670 salt_type = SALT_TYPE_NONE;
9671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_RADMIN2;
9674 dgst_size = DGST_SIZE_4_4;
9675 parse_func = radmin2_parse_hash;
9676 sort_by_digest = sort_by_digest_4_4;
9677 opti_type = OPTI_TYPE_ZERO_BYTE
9678 | OPTI_TYPE_PRECOMPUTE_INIT
9679 | OPTI_TYPE_EARLY_SKIP
9680 | OPTI_TYPE_NOT_ITERATED
9681 | OPTI_TYPE_NOT_SALTED;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 3;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 1;
9686 break;
9687
9688 case 10000: hash_type = HASH_TYPE_SHA256;
9689 salt_type = SALT_TYPE_EMBEDDED;
9690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9692 kern_type = KERN_TYPE_PBKDF2_SHA256;
9693 dgst_size = DGST_SIZE_4_32;
9694 parse_func = djangopbkdf2_parse_hash;
9695 sort_by_digest = sort_by_digest_4_32;
9696 opti_type = OPTI_TYPE_ZERO_BYTE;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 10100: hash_type = HASH_TYPE_SIPHASH;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9707 kern_type = KERN_TYPE_SIPHASH;
9708 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9709 parse_func = siphash_parse_hash;
9710 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_NOT_ITERATED
9713 | OPTI_TYPE_RAW_HASH;
9714 dgst_pos0 = 0;
9715 dgst_pos1 = 1;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 3;
9718 break;
9719
9720 case 10200: hash_type = HASH_TYPE_MD5;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE
9724 | OPTS_TYPE_ST_ADD80
9725 | OPTS_TYPE_ST_ADDBITS14;
9726 kern_type = KERN_TYPE_HMACMD5_PW;
9727 dgst_size = DGST_SIZE_4_4;
9728 parse_func = crammd5_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4;
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 3;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 1;
9736 break;
9737
9738 case 10300: hash_type = HASH_TYPE_SHA1;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9742 kern_type = KERN_TYPE_SAPH_SHA1;
9743 dgst_size = DGST_SIZE_4_5;
9744 parse_func = saph_sha1_parse_hash;
9745 sort_by_digest = sort_by_digest_4_5;
9746 opti_type = OPTI_TYPE_ZERO_BYTE;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 10400: hash_type = HASH_TYPE_PDFU16;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9757 kern_type = KERN_TYPE_PDF11;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = pdf11_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 10410: hash_type = HASH_TYPE_PDFU16;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9773 kern_type = KERN_TYPE_PDF11CM1;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = pdf11cm1_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 10420: hash_type = HASH_TYPE_PDFU16;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9789 kern_type = KERN_TYPE_PDF11CM2;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = pdf11cm2_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 10500: hash_type = HASH_TYPE_PDFU16;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9805 kern_type = KERN_TYPE_PDF14;
9806 dgst_size = DGST_SIZE_4_4;
9807 parse_func = pdf14_parse_hash;
9808 sort_by_digest = sort_by_digest_4_4;
9809 opti_type = OPTI_TYPE_ZERO_BYTE
9810 | OPTI_TYPE_NOT_ITERATED;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 10600: hash_type = HASH_TYPE_SHA256;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_BE
9821 | OPTS_TYPE_ST_ADD80
9822 | OPTS_TYPE_ST_ADDBITS15
9823 | OPTS_TYPE_HASH_COPY;
9824 kern_type = KERN_TYPE_SHA256_PWSLT;
9825 dgst_size = DGST_SIZE_4_8;
9826 parse_func = pdf17l3_parse_hash;
9827 sort_by_digest = sort_by_digest_4_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_PRECOMPUTE_INIT
9830 | OPTI_TYPE_PRECOMPUTE_MERKLE
9831 | OPTI_TYPE_EARLY_SKIP
9832 | OPTI_TYPE_NOT_ITERATED
9833 | OPTI_TYPE_APPENDED_SALT
9834 | OPTI_TYPE_RAW_HASH;
9835 dgst_pos0 = 3;
9836 dgst_pos1 = 7;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 6;
9839 break;
9840
9841 case 10700: hash_type = HASH_TYPE_PDFU32;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE
9845 | OPTS_TYPE_HASH_COPY;
9846 kern_type = KERN_TYPE_PDF17L8;
9847 dgst_size = DGST_SIZE_4_8;
9848 parse_func = pdf17l8_parse_hash;
9849 sort_by_digest = sort_by_digest_4_8;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_NOT_ITERATED;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 10800: hash_type = HASH_TYPE_SHA384;
9859 salt_type = SALT_TYPE_NONE;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_BE
9862 | OPTS_TYPE_PT_ADD80
9863 | OPTS_TYPE_PT_ADDBITS15;
9864 kern_type = KERN_TYPE_SHA384;
9865 dgst_size = DGST_SIZE_8_8;
9866 parse_func = sha384_parse_hash;
9867 sort_by_digest = sort_by_digest_8_8;
9868 opti_type = OPTI_TYPE_ZERO_BYTE
9869 | OPTI_TYPE_PRECOMPUTE_INIT
9870 | OPTI_TYPE_PRECOMPUTE_MERKLE
9871 | OPTI_TYPE_EARLY_SKIP
9872 | OPTI_TYPE_NOT_ITERATED
9873 | OPTI_TYPE_NOT_SALTED
9874 | OPTI_TYPE_USES_BITS_64
9875 | OPTI_TYPE_RAW_HASH;
9876 dgst_pos0 = 6;
9877 dgst_pos1 = 7;
9878 dgst_pos2 = 4;
9879 dgst_pos3 = 5;
9880 break;
9881
9882 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_ST_BASE64
9887 | OPTS_TYPE_HASH_COPY;
9888 kern_type = KERN_TYPE_PBKDF2_SHA256;
9889 dgst_size = DGST_SIZE_4_32;
9890 parse_func = pbkdf2_sha256_parse_hash;
9891 sort_by_digest = sort_by_digest_4_32;
9892 opti_type = OPTI_TYPE_ZERO_BYTE;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 1;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 3;
9897 break;
9898
9899 case 11000: hash_type = HASH_TYPE_MD5;
9900 salt_type = SALT_TYPE_INTERN;
9901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_LE
9903 | OPTS_TYPE_PT_ADD80;
9904 kern_type = KERN_TYPE_PRESTASHOP;
9905 dgst_size = DGST_SIZE_4_4;
9906 parse_func = prestashop_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4;
9908 opti_type = OPTI_TYPE_ZERO_BYTE
9909 | OPTI_TYPE_PRECOMPUTE_INIT
9910 | OPTI_TYPE_NOT_ITERATED
9911 | OPTI_TYPE_PREPENDED_SALT;
9912 dgst_pos0 = 0;
9913 dgst_pos1 = 3;
9914 dgst_pos2 = 2;
9915 dgst_pos3 = 1;
9916 break;
9917
9918 case 11100: hash_type = HASH_TYPE_MD5;
9919 salt_type = SALT_TYPE_EMBEDDED;
9920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9921 opts_type = OPTS_TYPE_PT_GENERATE_LE
9922 | OPTS_TYPE_ST_ADD80;
9923 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9924 dgst_size = DGST_SIZE_4_4;
9925 parse_func = postgresql_auth_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4;
9927 opti_type = OPTI_TYPE_ZERO_BYTE
9928 | OPTI_TYPE_PRECOMPUTE_INIT
9929 | OPTI_TYPE_PRECOMPUTE_MERKLE
9930 | OPTI_TYPE_EARLY_SKIP;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 3;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 1;
9935 break;
9936
9937 case 11200: hash_type = HASH_TYPE_SHA1;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_BE
9941 | OPTS_TYPE_PT_ADD80
9942 | OPTS_TYPE_ST_HEX;
9943 kern_type = KERN_TYPE_MYSQL_AUTH;
9944 dgst_size = DGST_SIZE_4_5;
9945 parse_func = mysql_auth_parse_hash;
9946 sort_by_digest = sort_by_digest_4_5;
9947 opti_type = OPTI_TYPE_ZERO_BYTE
9948 | OPTI_TYPE_EARLY_SKIP;
9949 dgst_pos0 = 3;
9950 dgst_pos1 = 4;
9951 dgst_pos2 = 2;
9952 dgst_pos3 = 1;
9953 break;
9954
9955 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9956 salt_type = SALT_TYPE_EMBEDDED;
9957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9958 opts_type = OPTS_TYPE_PT_GENERATE_LE
9959 | OPTS_TYPE_ST_HEX
9960 | OPTS_TYPE_ST_ADD80;
9961 kern_type = KERN_TYPE_BITCOIN_WALLET;
9962 dgst_size = DGST_SIZE_4_4;
9963 parse_func = bitcoin_wallet_parse_hash;
9964 sort_by_digest = sort_by_digest_4_4;
9965 opti_type = OPTI_TYPE_ZERO_BYTE;
9966 dgst_pos0 = 0;
9967 dgst_pos1 = 1;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 3;
9970 break;
9971
9972 case 11400: hash_type = HASH_TYPE_MD5;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_PT_ADD80
9977 | OPTS_TYPE_HASH_COPY;
9978 kern_type = KERN_TYPE_SIP_AUTH;
9979 dgst_size = DGST_SIZE_4_4;
9980 parse_func = sip_auth_parse_hash;
9981 sort_by_digest = sort_by_digest_4_4;
9982 opti_type = OPTI_TYPE_ZERO_BYTE;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 3;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 1;
9987 break;
9988
9989 case 11500: hash_type = HASH_TYPE_CRC32;
9990 salt_type = SALT_TYPE_INTERN;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_LE
9993 | OPTS_TYPE_ST_GENERATE_LE
9994 | OPTS_TYPE_ST_HEX;
9995 kern_type = KERN_TYPE_CRC32;
9996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9997 parse_func = crc32_parse_hash;
9998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9999 opti_type = OPTI_TYPE_ZERO_BYTE;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 11600: hash_type = HASH_TYPE_AES;
10007 salt_type = SALT_TYPE_EMBEDDED;
10008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_LE
10010 | OPTS_TYPE_PT_NEVERCRACK;
10011 kern_type = KERN_TYPE_SEVEN_ZIP;
10012 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10013 parse_func = seven_zip_parse_hash;
10014 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10023 salt_type = SALT_TYPE_NONE;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_PT_ADD01;
10027 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10028 dgst_size = DGST_SIZE_4_8;
10029 parse_func = gost2012sbog_256_parse_hash;
10030 sort_by_digest = sort_by_digest_4_8;
10031 opti_type = OPTI_TYPE_ZERO_BYTE;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10039 salt_type = SALT_TYPE_NONE;
10040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_PT_ADD01;
10043 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10044 dgst_size = DGST_SIZE_4_16;
10045 parse_func = gost2012sbog_512_parse_hash;
10046 sort_by_digest = sort_by_digest_4_16;
10047 opti_type = OPTI_TYPE_ZERO_BYTE;
10048 dgst_pos0 = 0;
10049 dgst_pos1 = 1;
10050 dgst_pos2 = 2;
10051 dgst_pos3 = 3;
10052 break;
10053
10054 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10055 salt_type = SALT_TYPE_EMBEDDED;
10056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_LE
10058 | OPTS_TYPE_ST_BASE64
10059 | OPTS_TYPE_HASH_COPY;
10060 kern_type = KERN_TYPE_PBKDF2_MD5;
10061 dgst_size = DGST_SIZE_4_32;
10062 parse_func = pbkdf2_md5_parse_hash;
10063 sort_by_digest = sort_by_digest_4_32;
10064 opti_type = OPTI_TYPE_ZERO_BYTE;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10072 salt_type = SALT_TYPE_EMBEDDED;
10073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE
10075 | OPTS_TYPE_ST_BASE64
10076 | OPTS_TYPE_HASH_COPY;
10077 kern_type = KERN_TYPE_PBKDF2_SHA1;
10078 dgst_size = DGST_SIZE_4_32;
10079 parse_func = pbkdf2_sha1_parse_hash;
10080 sort_by_digest = sort_by_digest_4_32;
10081 opti_type = OPTI_TYPE_ZERO_BYTE;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 1;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 3;
10086 break;
10087
10088 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE
10092 | OPTS_TYPE_ST_BASE64
10093 | OPTS_TYPE_HASH_COPY;
10094 kern_type = KERN_TYPE_PBKDF2_SHA512;
10095 dgst_size = DGST_SIZE_8_16;
10096 parse_func = pbkdf2_sha512_parse_hash;
10097 sort_by_digest = sort_by_digest_8_16;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_USES_BITS_64;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 1;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 3;
10104 break;
10105
10106 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10110 kern_type = KERN_TYPE_ECRYPTFS;
10111 dgst_size = DGST_SIZE_8_8;
10112 parse_func = ecryptfs_parse_hash;
10113 sort_by_digest = sort_by_digest_8_8;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_USES_BITS_64;
10116 dgst_pos0 = 0;
10117 dgst_pos1 = 1;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 3;
10120 break;
10121
10122 case 12300: hash_type = HASH_TYPE_ORACLET;
10123 salt_type = SALT_TYPE_EMBEDDED;
10124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10126 kern_type = KERN_TYPE_ORACLET;
10127 dgst_size = DGST_SIZE_8_16;
10128 parse_func = oraclet_parse_hash;
10129 sort_by_digest = sort_by_digest_8_16;
10130 opti_type = OPTI_TYPE_ZERO_BYTE
10131 | OPTI_TYPE_USES_BITS_64;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_BSDICRYPT;
10143 dgst_size = DGST_SIZE_4_4;
10144 parse_func = bsdicrypt_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4;
10146 opti_type = OPTI_TYPE_ZERO_BYTE
10147 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10148 dgst_pos0 = 0;
10149 dgst_pos1 = 1;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 3;
10152 break;
10153
10154 case 12500: hash_type = HASH_TYPE_RAR3HP;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10158 kern_type = KERN_TYPE_RAR3;
10159 dgst_size = DGST_SIZE_4_4;
10160 parse_func = rar3hp_parse_hash;
10161 sort_by_digest = sort_by_digest_4_4;
10162 opti_type = OPTI_TYPE_ZERO_BYTE;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 12600: hash_type = HASH_TYPE_SHA256;
10170 salt_type = SALT_TYPE_INTERN;
10171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_BE
10173 | OPTS_TYPE_PT_ADD80;
10174 kern_type = KERN_TYPE_CF10;
10175 dgst_size = DGST_SIZE_4_8;
10176 parse_func = cf10_parse_hash;
10177 sort_by_digest = sort_by_digest_4_8;
10178 opti_type = OPTI_TYPE_ZERO_BYTE
10179 | OPTI_TYPE_PRECOMPUTE_INIT
10180 | OPTI_TYPE_EARLY_SKIP
10181 | OPTI_TYPE_NOT_ITERATED;
10182 dgst_pos0 = 3;
10183 dgst_pos1 = 7;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 6;
10186 break;
10187
10188 case 12700: hash_type = HASH_TYPE_AES;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE
10192 | OPTS_TYPE_HASH_COPY;
10193 kern_type = KERN_TYPE_MYWALLET;
10194 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10195 parse_func = mywallet_parse_hash;
10196 sort_by_digest = sort_by_digest_4_5;
10197 opti_type = OPTI_TYPE_ZERO_BYTE;
10198 dgst_pos0 = 0;
10199 dgst_pos1 = 1;
10200 dgst_pos2 = 2;
10201 dgst_pos3 = 3;
10202 break;
10203
10204 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10205 salt_type = SALT_TYPE_EMBEDDED;
10206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10208 kern_type = KERN_TYPE_MS_DRSR;
10209 dgst_size = DGST_SIZE_4_8;
10210 parse_func = ms_drsr_parse_hash;
10211 sort_by_digest = sort_by_digest_4_8;
10212 opti_type = OPTI_TYPE_ZERO_BYTE;
10213 dgst_pos0 = 0;
10214 dgst_pos1 = 1;
10215 dgst_pos2 = 2;
10216 dgst_pos3 = 3;
10217 break;
10218
10219 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10220 salt_type = SALT_TYPE_EMBEDDED;
10221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10222 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10223 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10224 dgst_size = DGST_SIZE_4_8;
10225 parse_func = androidfde_samsung_parse_hash;
10226 sort_by_digest = sort_by_digest_4_8;
10227 opti_type = OPTI_TYPE_ZERO_BYTE;
10228 dgst_pos0 = 0;
10229 dgst_pos1 = 1;
10230 dgst_pos2 = 2;
10231 dgst_pos3 = 3;
10232 break;
10233
10234 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10235 salt_type = SALT_TYPE_EMBEDDED;
10236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10238 kern_type = KERN_TYPE_RAR5;
10239 dgst_size = DGST_SIZE_4_4;
10240 parse_func = rar5_parse_hash;
10241 sort_by_digest = sort_by_digest_4_4;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_KRB5TGS;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = krb5tgs_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_NOT_ITERATED;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 13200: hash_type = HASH_TYPE_AES;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10269 kern_type = KERN_TYPE_AXCRYPT;
10270 dgst_size = DGST_SIZE_4_4;
10271 parse_func = axcrypt_parse_hash;
10272 sort_by_digest = sort_by_digest_4_4;
10273 opti_type = OPTI_TYPE_ZERO_BYTE;
10274 dgst_pos0 = 0;
10275 dgst_pos1 = 1;
10276 dgst_pos2 = 2;
10277 dgst_pos3 = 3;
10278 break;
10279
10280 case 13300: hash_type = HASH_TYPE_SHA1;
10281 salt_type = SALT_TYPE_NONE;
10282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10283 opts_type = OPTS_TYPE_PT_GENERATE_BE
10284 | OPTS_TYPE_PT_ADD80
10285 | OPTS_TYPE_PT_ADDBITS15;
10286 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10287 dgst_size = DGST_SIZE_4_5;
10288 parse_func = sha1axcrypt_parse_hash;
10289 sort_by_digest = sort_by_digest_4_5;
10290 opti_type = OPTI_TYPE_ZERO_BYTE
10291 | OPTI_TYPE_PRECOMPUTE_INIT
10292 | OPTI_TYPE_EARLY_SKIP
10293 | OPTI_TYPE_NOT_ITERATED
10294 | OPTI_TYPE_NOT_SALTED;
10295 dgst_pos0 = 0;
10296 dgst_pos1 = 4;
10297 dgst_pos2 = 3;
10298 dgst_pos3 = 2;
10299 break;
10300
10301 case 13400: hash_type = HASH_TYPE_AES;
10302 salt_type = SALT_TYPE_EMBEDDED;
10303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10304 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10305 kern_type = KERN_TYPE_KEEPASS;
10306 dgst_size = DGST_SIZE_4_4;
10307 parse_func = keepass_parse_hash;
10308 sort_by_digest = sort_by_digest_4_4;
10309 opti_type = OPTI_TYPE_ZERO_BYTE;
10310 dgst_pos0 = 0;
10311 dgst_pos1 = 1;
10312 dgst_pos2 = 2;
10313 dgst_pos3 = 3;
10314 break;
10315
10316 case 13500: hash_type = HASH_TYPE_SHA1;
10317 salt_type = SALT_TYPE_EMBEDDED;
10318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10319 opts_type = OPTS_TYPE_PT_GENERATE_BE
10320 | OPTS_TYPE_PT_UNICODE
10321 | OPTS_TYPE_PT_ADD80;
10322 kern_type = KERN_TYPE_PSTOKEN;
10323 dgst_size = DGST_SIZE_4_5;
10324 parse_func = pstoken_parse_hash;
10325 sort_by_digest = sort_by_digest_4_5;
10326 opti_type = OPTI_TYPE_ZERO_BYTE
10327 | OPTI_TYPE_PRECOMPUTE_INIT
10328 | OPTI_TYPE_EARLY_SKIP
10329 | OPTI_TYPE_NOT_ITERATED
10330 | OPTI_TYPE_PREPENDED_SALT
10331 | OPTI_TYPE_RAW_HASH;
10332 dgst_pos0 = 3;
10333 dgst_pos1 = 4;
10334 dgst_pos2 = 2;
10335 dgst_pos3 = 1;
10336 break;
10337
10338 default: usage_mini_print (PROGNAME); return (-1);
10339 }
10340
10341 /**
10342 * parser
10343 */
10344
10345 data.parse_func = parse_func;
10346
10347 /**
10348 * misc stuff
10349 */
10350
10351 if (hex_salt)
10352 {
10353 if (salt_type == SALT_TYPE_INTERN)
10354 {
10355 opts_type |= OPTS_TYPE_ST_HEX;
10356 }
10357 else
10358 {
10359 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10360
10361 return (-1);
10362 }
10363 }
10364
10365 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10366 | (salt_type == SALT_TYPE_EXTERN)
10367 | (salt_type == SALT_TYPE_EMBEDDED)
10368 | (salt_type == SALT_TYPE_VIRTUAL));
10369
10370 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10371
10372 data.hash_type = hash_type;
10373 data.attack_mode = attack_mode;
10374 data.attack_kern = attack_kern;
10375 data.attack_exec = attack_exec;
10376 data.kern_type = kern_type;
10377 data.opts_type = opts_type;
10378 data.dgst_size = dgst_size;
10379 data.salt_type = salt_type;
10380 data.isSalted = isSalted;
10381 data.sort_by_digest = sort_by_digest;
10382 data.dgst_pos0 = dgst_pos0;
10383 data.dgst_pos1 = dgst_pos1;
10384 data.dgst_pos2 = dgst_pos2;
10385 data.dgst_pos3 = dgst_pos3;
10386
10387 esalt_size = 0;
10388
10389 switch (hash_mode)
10390 {
10391 case 2500: esalt_size = sizeof (wpa_t); break;
10392 case 5300: esalt_size = sizeof (ikepsk_t); break;
10393 case 5400: esalt_size = sizeof (ikepsk_t); break;
10394 case 5500: esalt_size = sizeof (netntlm_t); break;
10395 case 5600: esalt_size = sizeof (netntlm_t); break;
10396 case 6211: esalt_size = sizeof (tc_t); break;
10397 case 6212: esalt_size = sizeof (tc_t); break;
10398 case 6213: esalt_size = sizeof (tc_t); break;
10399 case 6221: esalt_size = sizeof (tc_t); break;
10400 case 6222: esalt_size = sizeof (tc_t); break;
10401 case 6223: esalt_size = sizeof (tc_t); break;
10402 case 6231: esalt_size = sizeof (tc_t); break;
10403 case 6232: esalt_size = sizeof (tc_t); break;
10404 case 6233: esalt_size = sizeof (tc_t); break;
10405 case 6241: esalt_size = sizeof (tc_t); break;
10406 case 6242: esalt_size = sizeof (tc_t); break;
10407 case 6243: esalt_size = sizeof (tc_t); break;
10408 case 6600: esalt_size = sizeof (agilekey_t); break;
10409 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10410 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10411 case 7300: esalt_size = sizeof (rakp_t); break;
10412 case 7500: esalt_size = sizeof (krb5pa_t); break;
10413 case 8200: esalt_size = sizeof (cloudkey_t); break;
10414 case 8800: esalt_size = sizeof (androidfde_t); break;
10415 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10416 case 9400: esalt_size = sizeof (office2007_t); break;
10417 case 9500: esalt_size = sizeof (office2010_t); break;
10418 case 9600: esalt_size = sizeof (office2013_t); break;
10419 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10420 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10421 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10422 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10423 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10424 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10425 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10426 case 10200: esalt_size = sizeof (cram_md5_t); break;
10427 case 10400: esalt_size = sizeof (pdf_t); break;
10428 case 10410: esalt_size = sizeof (pdf_t); break;
10429 case 10420: esalt_size = sizeof (pdf_t); break;
10430 case 10500: esalt_size = sizeof (pdf_t); break;
10431 case 10600: esalt_size = sizeof (pdf_t); break;
10432 case 10700: esalt_size = sizeof (pdf_t); break;
10433 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10434 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10435 case 11400: esalt_size = sizeof (sip_t); break;
10436 case 11600: esalt_size = sizeof (seven_zip_t); break;
10437 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10438 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10439 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10440 case 13000: esalt_size = sizeof (rar5_t); break;
10441 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10442 case 13400: esalt_size = sizeof (keepass_t); break;
10443 case 13500: esalt_size = sizeof (pstoken_t); break;
10444 }
10445
10446 data.esalt_size = esalt_size;
10447
10448 /**
10449 * choose dictionary parser
10450 */
10451
10452 if (hash_type == HASH_TYPE_LM)
10453 {
10454 get_next_word_func = get_next_word_lm;
10455 }
10456 else if (opts_type & OPTS_TYPE_PT_UPPER)
10457 {
10458 get_next_word_func = get_next_word_uc;
10459 }
10460 else
10461 {
10462 get_next_word_func = get_next_word_std;
10463 }
10464
10465 /**
10466 * dictstat
10467 */
10468
10469 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10470
10471 #ifdef _POSIX
10472 size_t dictstat_nmemb = 0;
10473 #endif
10474
10475 #ifdef _WIN
10476 uint dictstat_nmemb = 0;
10477 #endif
10478
10479 char dictstat[256] = { 0 };
10480
10481 FILE *dictstat_fp = NULL;
10482
10483 if (keyspace == 0)
10484 {
10485 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10486
10487 dictstat_fp = fopen (dictstat, "rb");
10488
10489 if (dictstat_fp)
10490 {
10491 #ifdef _POSIX
10492 struct stat tmpstat;
10493
10494 fstat (fileno (dictstat_fp), &tmpstat);
10495 #endif
10496
10497 #ifdef _WIN
10498 struct stat64 tmpstat;
10499
10500 _fstat64 (fileno (dictstat_fp), &tmpstat);
10501 #endif
10502
10503 if (tmpstat.st_mtime < COMPTIME)
10504 {
10505 /* with v0.15 the format changed so we have to ensure user is using a good version
10506 since there is no version-header in the dictstat file */
10507
10508 fclose (dictstat_fp);
10509
10510 unlink (dictstat);
10511 }
10512 else
10513 {
10514 while (!feof (dictstat_fp))
10515 {
10516 dictstat_t d;
10517
10518 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10519
10520 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10521
10522 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10523 {
10524 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10525
10526 return -1;
10527 }
10528 }
10529
10530 fclose (dictstat_fp);
10531 }
10532 }
10533 }
10534
10535 /**
10536 * potfile
10537 */
10538
10539 char potfile[256] = { 0 };
10540
10541 if (potfile_path == NULL)
10542 {
10543 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10544 }
10545 else
10546 {
10547 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10548 }
10549
10550 data.pot_fp = NULL;
10551
10552 FILE *out_fp = NULL;
10553 FILE *pot_fp = NULL;
10554
10555 if (show == 1 || left == 1)
10556 {
10557 pot_fp = fopen (potfile, "rb");
10558
10559 if (pot_fp == NULL)
10560 {
10561 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10562
10563 return (-1);
10564 }
10565
10566 if (outfile != NULL)
10567 {
10568 if ((out_fp = fopen (outfile, "ab")) == NULL)
10569 {
10570 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10571
10572 fclose (pot_fp);
10573
10574 return (-1);
10575 }
10576 }
10577 else
10578 {
10579 out_fp = stdout;
10580 }
10581 }
10582 else
10583 {
10584 if (potfile_disable == 0)
10585 {
10586 pot_fp = fopen (potfile, "ab");
10587
10588 if (pot_fp == NULL)
10589 {
10590 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10591
10592 return (-1);
10593 }
10594
10595 data.pot_fp = pot_fp;
10596 }
10597 }
10598
10599 pot_t *pot = NULL;
10600
10601 uint pot_cnt = 0;
10602 uint pot_avail = 0;
10603
10604 if (show == 1 || left == 1)
10605 {
10606 SUPPRESS_OUTPUT = 1;
10607
10608 pot_avail = count_lines (pot_fp);
10609
10610 rewind (pot_fp);
10611
10612 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10613
10614 uint pot_hashes_avail = 0;
10615
10616 uint line_num = 0;
10617
10618 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10619
10620 while (!feof (pot_fp))
10621 {
10622 line_num++;
10623
10624 int line_len = fgetl (pot_fp, line_buf);
10625
10626 if (line_len == 0) continue;
10627
10628 char *plain_buf = line_buf + line_len;
10629
10630 pot_t *pot_ptr = &pot[pot_cnt];
10631
10632 hash_t *hashes_buf = &pot_ptr->hash;
10633
10634 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10635 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10636
10637 if (pot_cnt == pot_hashes_avail)
10638 {
10639 uint pos = 0;
10640
10641 for (pos = 0; pos < INCR_POT; pos++)
10642 {
10643 if ((pot_cnt + pos) >= pot_avail) break;
10644
10645 pot_t *tmp_pot = &pot[pot_cnt + pos];
10646
10647 hash_t *tmp_hash = &tmp_pot->hash;
10648
10649 tmp_hash->digest = mymalloc (dgst_size);
10650
10651 if (isSalted)
10652 {
10653 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10654 }
10655
10656 if (esalt_size)
10657 {
10658 tmp_hash->esalt = mymalloc (esalt_size);
10659 }
10660
10661 pot_hashes_avail++;
10662 }
10663 }
10664
10665 int plain_len = 0;
10666
10667 int parser_status;
10668
10669 int iter = MAX_CUT_TRIES;
10670
10671 do
10672 {
10673 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10674 {
10675 if (line_buf[i] == ':')
10676 {
10677 line_len--;
10678
10679 break;
10680 }
10681 }
10682
10683 if (data.hash_mode != 2500)
10684 {
10685 parser_status = parse_func (line_buf, line_len, hashes_buf);
10686 }
10687 else
10688 {
10689 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10690
10691 if (line_len > max_salt_size)
10692 {
10693 parser_status = PARSER_GLOBAL_LENGTH;
10694 }
10695 else
10696 {
10697 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10698
10699 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10700
10701 hashes_buf->salt->salt_len = line_len;
10702
10703 parser_status = PARSER_OK;
10704 }
10705 }
10706
10707 // if NOT parsed without error, we add the ":" to the plain
10708
10709 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10710 {
10711 plain_len++;
10712 plain_buf--;
10713 }
10714
10715 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10716
10717 if (parser_status < PARSER_GLOBAL_ZERO)
10718 {
10719 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10720
10721 continue;
10722 }
10723
10724 if (plain_len >= 255) continue;
10725
10726 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10727
10728 pot_ptr->plain_len = plain_len;
10729
10730 pot_cnt++;
10731 }
10732
10733 myfree (line_buf);
10734
10735 fclose (pot_fp);
10736
10737 SUPPRESS_OUTPUT = 0;
10738
10739 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10740 }
10741
10742 /**
10743 * word len
10744 */
10745
10746 uint pw_min = PW_MIN;
10747 uint pw_max = PW_MAX;
10748
10749 switch (hash_mode)
10750 {
10751 case 125: if (pw_max > 32) pw_max = 32;
10752 break;
10753 case 400: if (pw_max > 40) pw_max = 40;
10754 break;
10755 case 500: if (pw_max > 16) pw_max = 16;
10756 break;
10757 case 1500: if (pw_max > 8) pw_max = 8;
10758 break;
10759 case 1600: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 1800: if (pw_max > 16) pw_max = 16;
10762 break;
10763 case 2100: if (pw_max > 16) pw_max = 16;
10764 break;
10765 case 2500: if (pw_min < 8) pw_min = 8;
10766 break;
10767 case 3000: if (pw_max > 7) pw_max = 7;
10768 break;
10769 case 5200: if (pw_max > 24) pw_max = 24;
10770 break;
10771 case 5800: if (pw_max > 16) pw_max = 16;
10772 break;
10773 case 6300: if (pw_max > 16) pw_max = 16;
10774 break;
10775 case 7400: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 7900: if (pw_max > 48) pw_max = 48;
10778 break;
10779 case 8500: if (pw_max > 8) pw_max = 8;
10780 break;
10781 case 8600: if (pw_max > 16) pw_max = 16;
10782 break;
10783 case 9710: pw_min = 5;
10784 pw_max = 5;
10785 break;
10786 case 9810: pw_min = 5;
10787 pw_max = 5;
10788 break;
10789 case 10410: pw_min = 5;
10790 pw_max = 5;
10791 break;
10792 case 10300: if (pw_max < 3) pw_min = 3;
10793 if (pw_max > 40) pw_max = 40;
10794 break;
10795 case 10500: if (pw_max < 3) pw_min = 3;
10796 if (pw_max > 40) pw_max = 40;
10797 break;
10798 case 10700: if (pw_max > 16) pw_max = 16;
10799 break;
10800 case 11300: if (pw_max > 40) pw_max = 40;
10801 break;
10802 case 12500: if (pw_max > 20) pw_max = 20;
10803 break;
10804 case 12800: if (pw_max > 24) pw_max = 24;
10805 break;
10806 }
10807
10808 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10809 {
10810 switch (attack_kern)
10811 {
10812 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10813 break;
10814 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10815 break;
10816 }
10817 }
10818
10819 /**
10820 * charsets : keep them together for more easy maintainnce
10821 */
10822
10823 cs_t mp_sys[6] = { { { 0 }, 0 } };
10824 cs_t mp_usr[4] = { { { 0 }, 0 } };
10825
10826 mp_setup_sys (mp_sys);
10827
10828 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10829 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10830 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10831 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10832
10833 /**
10834 * load hashes, part I: find input mode, count hashes
10835 */
10836
10837 uint hashlist_mode = 0;
10838 uint hashlist_format = HLFMT_HASHCAT;
10839
10840 uint hashes_avail = 0;
10841
10842 if (benchmark == 0)
10843 {
10844 struct stat f;
10845
10846 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10847
10848 if ((hash_mode == 2500) ||
10849 (hash_mode == 5200) ||
10850 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10851 (hash_mode == 9000))
10852 {
10853 hashlist_mode = HL_MODE_ARG;
10854
10855 char *hashfile = myargv[optind];
10856
10857 data.hashfile = hashfile;
10858
10859 logfile_top_var_string ("target", hashfile);
10860 }
10861
10862 if (hashlist_mode == HL_MODE_ARG)
10863 {
10864 if (hash_mode == 2500)
10865 {
10866 struct stat st;
10867
10868 if (stat (data.hashfile, &st) == -1)
10869 {
10870 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10871
10872 return (-1);
10873 }
10874
10875 hashes_avail = st.st_size / sizeof (hccap_t);
10876 }
10877 else
10878 {
10879 hashes_avail = 1;
10880 }
10881 }
10882 else if (hashlist_mode == HL_MODE_FILE)
10883 {
10884 char *hashfile = myargv[optind];
10885
10886 data.hashfile = hashfile;
10887
10888 logfile_top_var_string ("target", hashfile);
10889
10890 FILE *fp = NULL;
10891
10892 if ((fp = fopen (hashfile, "rb")) == NULL)
10893 {
10894 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10895
10896 return (-1);
10897 }
10898
10899 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10900
10901 hashes_avail = count_lines (fp);
10902
10903 rewind (fp);
10904
10905 if (hashes_avail == 0)
10906 {
10907 log_error ("ERROR: hashfile is empty or corrupt");
10908
10909 fclose (fp);
10910
10911 return (-1);
10912 }
10913
10914 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10915
10916 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10917 {
10918 log_error ("ERROR: remove not supported in native hashfile-format mode");
10919
10920 fclose (fp);
10921
10922 return (-1);
10923 }
10924
10925 fclose (fp);
10926 }
10927 }
10928 else
10929 {
10930 hashlist_mode = HL_MODE_ARG;
10931
10932 hashes_avail = 1;
10933 }
10934
10935 if (hash_mode == 3000) hashes_avail *= 2;
10936
10937 data.hashlist_mode = hashlist_mode;
10938 data.hashlist_format = hashlist_format;
10939
10940 logfile_top_uint (hashlist_mode);
10941 logfile_top_uint (hashlist_format);
10942
10943 /**
10944 * load hashes, part II: allocate required memory, set pointers
10945 */
10946
10947 hash_t *hashes_buf = NULL;
10948 void *digests_buf = NULL;
10949 salt_t *salts_buf = NULL;
10950 void *esalts_buf = NULL;
10951
10952 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10953
10954 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10955
10956 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10957 {
10958 u32 hash_pos;
10959
10960 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10961 {
10962 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10963
10964 hashes_buf[hash_pos].hash_info = hash_info;
10965
10966 if (username && (remove || show || left))
10967 {
10968 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10969 }
10970
10971 if (benchmark)
10972 {
10973 hash_info->orighash = (char *) mymalloc (256);
10974 }
10975 }
10976 }
10977
10978 if (isSalted)
10979 {
10980 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10981
10982 if (esalt_size)
10983 {
10984 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10985 }
10986 }
10987 else
10988 {
10989 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10990 }
10991
10992 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10993 {
10994 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10995
10996 if (isSalted)
10997 {
10998 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10999
11000 if (esalt_size)
11001 {
11002 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11003 }
11004 }
11005 else
11006 {
11007 hashes_buf[hash_pos].salt = &salts_buf[0];
11008 }
11009 }
11010
11011 /**
11012 * load hashes, part III: parse hashes or generate them if benchmark
11013 */
11014
11015 uint hashes_cnt = 0;
11016
11017 if (benchmark == 0)
11018 {
11019 if (keyspace == 1)
11020 {
11021 // useless to read hash file for keyspace, cheat a little bit w/ optind
11022 }
11023 else if (hashes_avail == 0)
11024 {
11025 }
11026 else if (hashlist_mode == HL_MODE_ARG)
11027 {
11028 char *input_buf = myargv[optind];
11029
11030 uint input_len = strlen (input_buf);
11031
11032 logfile_top_var_string ("target", input_buf);
11033
11034 char *hash_buf = NULL;
11035 int hash_len = 0;
11036
11037 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11038
11039 bool hash_fmt_error = 0;
11040
11041 if (hash_len < 1) hash_fmt_error = 1;
11042 if (hash_buf == NULL) hash_fmt_error = 1;
11043
11044 if (hash_fmt_error)
11045 {
11046 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11047 }
11048 else
11049 {
11050 if (opts_type & OPTS_TYPE_HASH_COPY)
11051 {
11052 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11053
11054 hash_info_tmp->orighash = mystrdup (hash_buf);
11055 }
11056
11057 if (isSalted)
11058 {
11059 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11060 }
11061
11062 int parser_status = PARSER_OK;
11063
11064 if (hash_mode == 2500)
11065 {
11066 if (hash_len == 0)
11067 {
11068 log_error ("ERROR: hccap file not specified");
11069
11070 return (-1);
11071 }
11072
11073 hashlist_mode = HL_MODE_FILE;
11074
11075 data.hashlist_mode = hashlist_mode;
11076
11077 FILE *fp = fopen (hash_buf, "rb");
11078
11079 if (fp == NULL)
11080 {
11081 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11082
11083 return (-1);
11084 }
11085
11086 if (hashes_avail < 1)
11087 {
11088 log_error ("ERROR: hccap file is empty or corrupt");
11089
11090 fclose (fp);
11091
11092 return (-1);
11093 }
11094
11095 uint hccap_size = sizeof (hccap_t);
11096
11097 char *in = (char *) mymalloc (hccap_size);
11098
11099 while (!feof (fp))
11100 {
11101 int n = fread (in, hccap_size, 1, fp);
11102
11103 if (n != 1)
11104 {
11105 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11106
11107 break;
11108 }
11109
11110 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11111
11112 if (parser_status != PARSER_OK)
11113 {
11114 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11115
11116 continue;
11117 }
11118
11119 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11120
11121 if ((show == 1) || (left == 1))
11122 {
11123 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11124
11125 char *salt_ptr = (char *) tmp_salt->salt_buf;
11126
11127 int cur_pos = tmp_salt->salt_len;
11128 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11129
11130 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11131
11132 // do the appending task
11133
11134 snprintf (salt_ptr + cur_pos,
11135 rem_len,
11136 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11137 wpa->orig_mac1[0],
11138 wpa->orig_mac1[1],
11139 wpa->orig_mac1[2],
11140 wpa->orig_mac1[3],
11141 wpa->orig_mac1[4],
11142 wpa->orig_mac1[5],
11143 wpa->orig_mac2[0],
11144 wpa->orig_mac2[1],
11145 wpa->orig_mac2[2],
11146 wpa->orig_mac2[3],
11147 wpa->orig_mac2[4],
11148 wpa->orig_mac2[5]);
11149
11150 // memset () the remaining part of the salt
11151
11152 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11153 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11154
11155 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11156
11157 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11158 }
11159
11160 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);
11161 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);
11162
11163 hashes_cnt++;
11164 }
11165
11166 fclose (fp);
11167
11168 myfree (in);
11169 }
11170 else if (hash_mode == 3000)
11171 {
11172 if (hash_len == 32)
11173 {
11174 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11175
11176 hash_t *lm_hash_left = NULL;
11177
11178 if (parser_status == PARSER_OK)
11179 {
11180 lm_hash_left = &hashes_buf[hashes_cnt];
11181
11182 hashes_cnt++;
11183 }
11184 else
11185 {
11186 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11187 }
11188
11189 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11190
11191 hash_t *lm_hash_right = NULL;
11192
11193 if (parser_status == PARSER_OK)
11194 {
11195 lm_hash_right = &hashes_buf[hashes_cnt];
11196
11197 hashes_cnt++;
11198 }
11199 else
11200 {
11201 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11202 }
11203
11204 // show / left
11205
11206 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11207 {
11208 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);
11209 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);
11210 }
11211 }
11212 else
11213 {
11214 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11215
11216 if (parser_status == PARSER_OK)
11217 {
11218 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11219 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11220 }
11221
11222 if (parser_status == PARSER_OK)
11223 {
11224 hashes_cnt++;
11225 }
11226 else
11227 {
11228 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11229 }
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 }
11253 else if (hashlist_mode == HL_MODE_FILE)
11254 {
11255 char *hashfile = data.hashfile;
11256
11257 FILE *fp;
11258
11259 if ((fp = fopen (hashfile, "rb")) == NULL)
11260 {
11261 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11262
11263 return (-1);
11264 }
11265
11266 uint line_num = 0;
11267
11268 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11269
11270 while (!feof (fp))
11271 {
11272 line_num++;
11273
11274 int line_len = fgetl (fp, line_buf);
11275
11276 if (line_len == 0) continue;
11277
11278 char *hash_buf = NULL;
11279 int hash_len = 0;
11280
11281 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11282
11283 bool hash_fmt_error = 0;
11284
11285 if (hash_len < 1) hash_fmt_error = 1;
11286 if (hash_buf == NULL) hash_fmt_error = 1;
11287
11288 if (hash_fmt_error)
11289 {
11290 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11291
11292 continue;
11293 }
11294
11295 if (username)
11296 {
11297 char *user_buf = NULL;
11298 int user_len = 0;
11299
11300 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11301
11302 if (remove || show)
11303 {
11304 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11305
11306 *user = (user_t *) mymalloc (sizeof (user_t));
11307
11308 user_t *user_ptr = *user;
11309
11310 if (user_buf != NULL)
11311 {
11312 user_ptr->user_name = mystrdup (user_buf);
11313 }
11314 else
11315 {
11316 user_ptr->user_name = mystrdup ("");
11317 }
11318
11319 user_ptr->user_len = user_len;
11320 }
11321 }
11322
11323 if (opts_type & OPTS_TYPE_HASH_COPY)
11324 {
11325 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11326
11327 hash_info_tmp->orighash = mystrdup (hash_buf);
11328 }
11329
11330 if (isSalted)
11331 {
11332 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11333 }
11334
11335 if (hash_mode == 3000)
11336 {
11337 if (hash_len == 32)
11338 {
11339 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11340
11341 if (parser_status < PARSER_GLOBAL_ZERO)
11342 {
11343 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11344
11345 continue;
11346 }
11347
11348 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11349
11350 hashes_cnt++;
11351
11352 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11353
11354 if (parser_status < PARSER_GLOBAL_ZERO)
11355 {
11356 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11357
11358 continue;
11359 }
11360
11361 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11362
11363 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);
11364
11365 hashes_cnt++;
11366
11367 // show / left
11368
11369 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);
11370 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);
11371 }
11372 else
11373 {
11374 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11375
11376 if (parser_status < PARSER_GLOBAL_ZERO)
11377 {
11378 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11379
11380 continue;
11381 }
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 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11386 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11387
11388 hashes_cnt++;
11389 }
11390 }
11391 else
11392 {
11393 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11394
11395 if (parser_status < PARSER_GLOBAL_ZERO)
11396 {
11397 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11398
11399 continue;
11400 }
11401
11402 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);
11403
11404 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11405 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11406
11407 hashes_cnt++;
11408 }
11409 }
11410
11411 myfree (line_buf);
11412
11413 fclose (fp);
11414
11415 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11416
11417 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11418 }
11419 }
11420 else
11421 {
11422 if (isSalted)
11423 {
11424 hashes_buf[0].salt->salt_len = 8;
11425
11426 // special salt handling
11427
11428 switch (hash_mode)
11429 {
11430 case 1500: hashes_buf[0].salt->salt_len = 2;
11431 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11432 break;
11433 case 1731: hashes_buf[0].salt->salt_len = 4;
11434 break;
11435 case 2410: hashes_buf[0].salt->salt_len = 4;
11436 break;
11437 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11438 break;
11439 case 3100: hashes_buf[0].salt->salt_len = 1;
11440 break;
11441 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11442 break;
11443 case 5800: hashes_buf[0].salt->salt_len = 16;
11444 break;
11445 case 6800: hashes_buf[0].salt->salt_len = 32;
11446 break;
11447 case 8400: hashes_buf[0].salt->salt_len = 40;
11448 break;
11449 case 8800: hashes_buf[0].salt->salt_len = 16;
11450 break;
11451 case 8900: hashes_buf[0].salt->salt_len = 16;
11452 hashes_buf[0].salt->scrypt_N = 1024;
11453 hashes_buf[0].salt->scrypt_r = 1;
11454 hashes_buf[0].salt->scrypt_p = 1;
11455 break;
11456 case 9100: hashes_buf[0].salt->salt_len = 16;
11457 break;
11458 case 9300: hashes_buf[0].salt->salt_len = 14;
11459 hashes_buf[0].salt->scrypt_N = 16384;
11460 hashes_buf[0].salt->scrypt_r = 1;
11461 hashes_buf[0].salt->scrypt_p = 1;
11462 break;
11463 case 9400: hashes_buf[0].salt->salt_len = 16;
11464 break;
11465 case 9500: hashes_buf[0].salt->salt_len = 16;
11466 break;
11467 case 9600: hashes_buf[0].salt->salt_len = 16;
11468 break;
11469 case 9700: hashes_buf[0].salt->salt_len = 16;
11470 break;
11471 case 9710: hashes_buf[0].salt->salt_len = 16;
11472 break;
11473 case 9720: hashes_buf[0].salt->salt_len = 16;
11474 break;
11475 case 9800: hashes_buf[0].salt->salt_len = 16;
11476 break;
11477 case 9810: hashes_buf[0].salt->salt_len = 16;
11478 break;
11479 case 9820: hashes_buf[0].salt->salt_len = 16;
11480 break;
11481 case 10300: hashes_buf[0].salt->salt_len = 12;
11482 break;
11483 case 11500: hashes_buf[0].salt->salt_len = 4;
11484 break;
11485 case 11600: hashes_buf[0].salt->salt_len = 4;
11486 break;
11487 case 12400: hashes_buf[0].salt->salt_len = 4;
11488 break;
11489 case 12500: hashes_buf[0].salt->salt_len = 8;
11490 break;
11491 case 12600: hashes_buf[0].salt->salt_len = 64;
11492 break;
11493 }
11494
11495 // special esalt handling
11496
11497 switch (hash_mode)
11498 {
11499 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11500 break;
11501 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11502 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11503 break;
11504 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11505 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11506 break;
11507 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11508 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11509 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11510 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11511 break;
11512 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11513 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11514 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11515 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11516 break;
11517 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11518 break;
11519 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11520 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11521 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11522 break;
11523 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11524 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11525 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11526 break;
11527 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11528 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11529 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11530 break;
11531 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11532 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11533 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11534 break;
11535 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11536 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11537 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11538 break;
11539 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11540 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11541 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11542 break;
11543 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11544 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11545 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11546 break;
11547 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11548 break;
11549 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11550 break;
11551 }
11552 }
11553
11554 // set hashfile
11555
11556 switch (hash_mode)
11557 {
11558 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11559 break;
11560 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11561 break;
11562 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11563 break;
11564 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11565 break;
11566 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11567 break;
11568 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11569 break;
11570 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11571 break;
11572 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11573 break;
11574 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11575 break;
11576 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11577 break;
11578 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11579 break;
11580 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11581 break;
11582 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11583 break;
11584 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11585 break;
11586 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11587 break;
11588 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11589 break;
11590 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11591 break;
11592 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11593 break;
11594 }
11595
11596 // set default iterations
11597
11598 switch (hash_mode)
11599 {
11600 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11601 break;
11602 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11603 break;
11604 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11605 break;
11606 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11607 break;
11608 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11609 break;
11610 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11611 break;
11612 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11613 break;
11614 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11615 break;
11616 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11617 break;
11618 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11619 break;
11620 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11621 break;
11622 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11623 break;
11624 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11625 break;
11626 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11627 break;
11628 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11629 break;
11630 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11631 break;
11632 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11633 break;
11634 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11635 break;
11636 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11637 break;
11638 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11639 break;
11640 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11641 break;
11642 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11643 break;
11644 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11645 break;
11646 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11647 break;
11648 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11649 break;
11650 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11651 break;
11652 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11653 break;
11654 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11655 break;
11656 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11657 break;
11658 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11659 break;
11660 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11661 break;
11662 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11663 break;
11664 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11665 break;
11666 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11667 break;
11668 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11669 break;
11670 case 8900: hashes_buf[0].salt->salt_iter = 1;
11671 break;
11672 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11673 break;
11674 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11675 break;
11676 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11677 break;
11678 case 9300: hashes_buf[0].salt->salt_iter = 1;
11679 break;
11680 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11681 break;
11682 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11683 break;
11684 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11685 break;
11686 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11687 break;
11688 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11689 break;
11690 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11691 break;
11692 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11693 break;
11694 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11695 break;
11696 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11697 break;
11698 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11699 break;
11700 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11701 break;
11702 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11703 break;
11704 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11705 break;
11706 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11707 break;
11708 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11709 break;
11710 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11711 break;
11712 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11713 break;
11714 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11715 break;
11716 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11717 break;
11718 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11719 break;
11720 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11721 break;
11722 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11723 break;
11724 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11725 break;
11726 }
11727
11728 hashes_cnt = 1;
11729 }
11730
11731 if (show == 1 || left == 1)
11732 {
11733 for (uint i = 0; i < pot_cnt; i++)
11734 {
11735 pot_t *pot_ptr = &pot[i];
11736
11737 hash_t *hashes_buf = &pot_ptr->hash;
11738
11739 local_free (hashes_buf->digest);
11740
11741 if (isSalted)
11742 {
11743 local_free (hashes_buf->salt);
11744 }
11745 }
11746
11747 local_free (pot);
11748
11749 if (data.quiet == 0) log_info_nn ("");
11750
11751 return (0);
11752 }
11753
11754 if (keyspace == 0)
11755 {
11756 if (hashes_cnt == 0)
11757 {
11758 log_error ("ERROR: No hashes loaded");
11759
11760 return (-1);
11761 }
11762 }
11763
11764 /**
11765 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11766 */
11767
11768 if (data.outfile != NULL)
11769 {
11770 if (data.hashfile != NULL)
11771 {
11772 #ifdef _POSIX
11773 struct stat tmpstat_outfile;
11774 struct stat tmpstat_hashfile;
11775 #endif
11776
11777 #ifdef _WIN
11778 struct stat64 tmpstat_outfile;
11779 struct stat64 tmpstat_hashfile;
11780 #endif
11781
11782 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11783
11784 if (tmp_outfile_fp)
11785 {
11786 #ifdef _POSIX
11787 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11788 #endif
11789
11790 #ifdef _WIN
11791 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11792 #endif
11793
11794 fclose (tmp_outfile_fp);
11795 }
11796
11797 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11798
11799 if (tmp_hashfile_fp)
11800 {
11801 #ifdef _POSIX
11802 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11803 #endif
11804
11805 #ifdef _WIN
11806 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11807 #endif
11808
11809 fclose (tmp_hashfile_fp);
11810 }
11811
11812 if (tmp_outfile_fp && tmp_outfile_fp)
11813 {
11814 tmpstat_outfile.st_mode = 0;
11815 tmpstat_outfile.st_nlink = 0;
11816 tmpstat_outfile.st_uid = 0;
11817 tmpstat_outfile.st_gid = 0;
11818 tmpstat_outfile.st_rdev = 0;
11819 tmpstat_outfile.st_atime = 0;
11820
11821 tmpstat_hashfile.st_mode = 0;
11822 tmpstat_hashfile.st_nlink = 0;
11823 tmpstat_hashfile.st_uid = 0;
11824 tmpstat_hashfile.st_gid = 0;
11825 tmpstat_hashfile.st_rdev = 0;
11826 tmpstat_hashfile.st_atime = 0;
11827
11828 #ifdef _POSIX
11829 tmpstat_outfile.st_blksize = 0;
11830 tmpstat_outfile.st_blocks = 0;
11831
11832 tmpstat_hashfile.st_blksize = 0;
11833 tmpstat_hashfile.st_blocks = 0;
11834 #endif
11835
11836 #ifdef _POSIX
11837 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11838 {
11839 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11840
11841 return (-1);
11842 }
11843 #endif
11844
11845 #ifdef _WIN
11846 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11847 {
11848 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11849
11850 return (-1);
11851 }
11852 #endif
11853 }
11854 }
11855 }
11856
11857 /**
11858 * Remove duplicates
11859 */
11860
11861 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11862
11863 if (isSalted)
11864 {
11865 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11866 }
11867 else
11868 {
11869 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11870 }
11871
11872 uint hashes_cnt_orig = hashes_cnt;
11873
11874 hashes_cnt = 1;
11875
11876 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11877 {
11878 if (isSalted)
11879 {
11880 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11881 {
11882 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11883 }
11884 }
11885 else
11886 {
11887 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11888 }
11889
11890 if (hashes_pos > hashes_cnt)
11891 {
11892 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11893 }
11894
11895 hashes_cnt++;
11896 }
11897
11898 /**
11899 * Potfile removes
11900 */
11901
11902 uint potfile_remove_cracks = 0;
11903
11904 if (potfile_disable == 0)
11905 {
11906 hash_t hash_buf;
11907
11908 hash_buf.digest = mymalloc (dgst_size);
11909 hash_buf.salt = NULL;
11910 hash_buf.esalt = NULL;
11911 hash_buf.hash_info = NULL;
11912 hash_buf.cracked = 0;
11913
11914 if (isSalted)
11915 {
11916 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11917 }
11918
11919 if (esalt_size)
11920 {
11921 hash_buf.esalt = mymalloc (esalt_size);
11922 }
11923
11924 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11925
11926 // no solution for these special hash types (for instane because they use hashfile in output etc)
11927 if ((hash_mode != 5200) &&
11928 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11929 (hash_mode != 9000))
11930 {
11931 FILE *fp = fopen (potfile, "rb");
11932
11933 if (fp != NULL)
11934 {
11935 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11936
11937 // to be safe work with a copy (because of line_len loop, i etc)
11938 // moved up here because it's easier to handle continue case
11939 // it's just 64kb
11940
11941 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11942
11943 while (!feof (fp))
11944 {
11945 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11946
11947 if (ptr == NULL) break;
11948
11949 int line_len = strlen (line_buf);
11950
11951 if (line_len == 0) continue;
11952
11953 int iter = MAX_CUT_TRIES;
11954
11955 for (int i = line_len - 1; i && iter; i--, line_len--)
11956 {
11957 if (line_buf[i] != ':') continue;
11958
11959 if (isSalted)
11960 {
11961 memset (hash_buf.salt, 0, sizeof (salt_t));
11962 }
11963
11964 hash_t *found = NULL;
11965
11966 if (hash_mode == 6800)
11967 {
11968 if (i < 64) // 64 = 16 * uint in salt_buf[]
11969 {
11970 // manipulate salt_buf
11971 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11972
11973 hash_buf.salt->salt_len = i;
11974
11975 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11976 }
11977 }
11978 else if (hash_mode == 2500)
11979 {
11980 if (i < 64) // 64 = 16 * uint in salt_buf[]
11981 {
11982 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11983 // manipulate salt_buf
11984
11985 memcpy (line_buf_cpy, line_buf, i);
11986
11987 char *mac2_pos = strrchr (line_buf_cpy, ':');
11988
11989 if (mac2_pos == NULL) continue;
11990
11991 mac2_pos[0] = 0;
11992 mac2_pos++;
11993
11994 if (strlen (mac2_pos) != 12) continue;
11995
11996 char *mac1_pos = strrchr (line_buf_cpy, ':');
11997
11998 if (mac1_pos == NULL) continue;
11999
12000 mac1_pos[0] = 0;
12001 mac1_pos++;
12002
12003 if (strlen (mac1_pos) != 12) continue;
12004
12005 uint essid_length = mac1_pos - line_buf_cpy - 1;
12006
12007 // here we need the ESSID
12008 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12009
12010 hash_buf.salt->salt_len = essid_length;
12011
12012 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12013
12014 if (found)
12015 {
12016 wpa_t *wpa = (wpa_t *) found->esalt;
12017
12018 // compare hex string(s) vs binary MAC address(es)
12019
12020 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12021 {
12022 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12023 {
12024 found = NULL;
12025
12026 break;
12027 }
12028 }
12029
12030 // early skip ;)
12031 if (!found) continue;
12032
12033 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12034 {
12035 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12036 {
12037 found = NULL;
12038
12039 break;
12040 }
12041 }
12042 }
12043 }
12044 }
12045 else
12046 {
12047 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12048
12049 if (parser_status == PARSER_OK)
12050 {
12051 if (isSalted)
12052 {
12053 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12054 }
12055 else
12056 {
12057 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12058 }
12059 }
12060 }
12061
12062 if (found == NULL) continue;
12063
12064 if (!found->cracked) potfile_remove_cracks++;
12065
12066 found->cracked = 1;
12067
12068 if (found) break;
12069
12070 iter--;
12071 }
12072 }
12073
12074 myfree (line_buf_cpy);
12075
12076 myfree (line_buf);
12077
12078 fclose (fp);
12079 }
12080 }
12081
12082 if (esalt_size)
12083 {
12084 local_free (hash_buf.esalt);
12085 }
12086
12087 if (isSalted)
12088 {
12089 local_free (hash_buf.salt);
12090 }
12091
12092 local_free (hash_buf.digest);
12093 }
12094
12095 /**
12096 * Now generate all the buffers required for later
12097 */
12098
12099 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12100
12101 salt_t *salts_buf_new = NULL;
12102 void *esalts_buf_new = NULL;
12103
12104 if (isSalted)
12105 {
12106 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12107
12108 if (esalt_size)
12109 {
12110 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12111 }
12112 }
12113 else
12114 {
12115 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12116 }
12117
12118 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12119
12120 uint digests_cnt = hashes_cnt;
12121 uint digests_done = 0;
12122
12123 uint size_digests = digests_cnt * dgst_size;
12124 uint size_shown = digests_cnt * sizeof (uint);
12125
12126 uint *digests_shown = (uint *) mymalloc (size_shown);
12127 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12128
12129 uint salts_cnt = 0;
12130 uint salts_done = 0;
12131
12132 hashinfo_t **hash_info = NULL;
12133
12134 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12135 {
12136 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12137
12138 if (username && (remove || show))
12139 {
12140 uint user_pos;
12141
12142 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12143 {
12144 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12145
12146 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12147 }
12148 }
12149 }
12150
12151 uint *salts_shown = (uint *) mymalloc (size_shown);
12152
12153 salt_t *salt_buf;
12154
12155 {
12156 // copied from inner loop
12157
12158 salt_buf = &salts_buf_new[salts_cnt];
12159
12160 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12161
12162 if (esalt_size)
12163 {
12164 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12165 }
12166
12167 salt_buf->digests_cnt = 0;
12168 salt_buf->digests_done = 0;
12169 salt_buf->digests_offset = 0;
12170
12171 salts_cnt++;
12172 }
12173
12174 if (hashes_buf[0].cracked == 1)
12175 {
12176 digests_shown[0] = 1;
12177
12178 digests_done++;
12179
12180 salt_buf->digests_done++;
12181 }
12182
12183 salt_buf->digests_cnt++;
12184
12185 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12186
12187 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12188 {
12189 hash_info[0] = hashes_buf[0].hash_info;
12190 }
12191
12192 // copy from inner loop
12193
12194 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12195 {
12196 if (isSalted)
12197 {
12198 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12199 {
12200 salt_buf = &salts_buf_new[salts_cnt];
12201
12202 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12203
12204 if (esalt_size)
12205 {
12206 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12207 }
12208
12209 salt_buf->digests_cnt = 0;
12210 salt_buf->digests_done = 0;
12211 salt_buf->digests_offset = hashes_pos;
12212
12213 salts_cnt++;
12214 }
12215 }
12216
12217 if (hashes_buf[hashes_pos].cracked == 1)
12218 {
12219 digests_shown[hashes_pos] = 1;
12220
12221 digests_done++;
12222
12223 salt_buf->digests_done++;
12224 }
12225
12226 salt_buf->digests_cnt++;
12227
12228 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12229
12230 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12231 {
12232 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12233 }
12234 }
12235
12236 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12237 {
12238 salt_t *salt_buf = &salts_buf_new[salt_pos];
12239
12240 if (salt_buf->digests_done == salt_buf->digests_cnt)
12241 {
12242 salts_shown[salt_pos] = 1;
12243
12244 salts_done++;
12245 }
12246
12247 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12248 }
12249
12250 local_free (digests_buf);
12251 local_free (salts_buf);
12252 local_free (esalts_buf);
12253
12254 digests_buf = digests_buf_new;
12255 salts_buf = salts_buf_new;
12256 esalts_buf = esalts_buf_new;
12257
12258 local_free (hashes_buf);
12259
12260 /**
12261 * special modification not set from parser
12262 */
12263
12264 switch (hash_mode)
12265 {
12266 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12267 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12268 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12269 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12270 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12271 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12272 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12273 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12274 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12275 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12276 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12277 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12278 }
12279
12280 if (truecrypt_keyfiles)
12281 {
12282 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12283
12284 char *keyfiles = strdup (truecrypt_keyfiles);
12285
12286 char *keyfile = strtok (keyfiles, ",");
12287
12288 do
12289 {
12290 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12291
12292 } while ((keyfile = strtok (NULL, ",")) != NULL);
12293
12294 free (keyfiles);
12295 }
12296
12297 data.digests_cnt = digests_cnt;
12298 data.digests_done = digests_done;
12299 data.digests_buf = digests_buf;
12300 data.digests_shown = digests_shown;
12301 data.digests_shown_tmp = digests_shown_tmp;
12302
12303 data.salts_cnt = salts_cnt;
12304 data.salts_done = salts_done;
12305 data.salts_buf = salts_buf;
12306 data.salts_shown = salts_shown;
12307
12308 data.esalts_buf = esalts_buf;
12309 data.hash_info = hash_info;
12310
12311 /**
12312 * Automatic Optimizers
12313 */
12314
12315 if (salts_cnt == 1)
12316 opti_type |= OPTI_TYPE_SINGLE_SALT;
12317
12318 if (digests_cnt == 1)
12319 opti_type |= OPTI_TYPE_SINGLE_HASH;
12320
12321 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12322 opti_type |= OPTI_TYPE_NOT_ITERATED;
12323
12324 if (attack_mode == ATTACK_MODE_BF)
12325 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12326
12327 data.opti_type = opti_type;
12328
12329 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12330 {
12331 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12332 {
12333 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12334 {
12335 if (opts_type & OPTS_TYPE_ST_ADD80)
12336 {
12337 opts_type &= ~OPTS_TYPE_ST_ADD80;
12338 opts_type |= OPTS_TYPE_PT_ADD80;
12339 }
12340
12341 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12342 {
12343 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12344 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12345 }
12346
12347 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12348 {
12349 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12350 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12351 }
12352 }
12353 }
12354 }
12355
12356 /**
12357 * Some algorithm, like descrypt, can benefit from JIT compilation
12358 */
12359
12360 int force_jit_compilation = -1;
12361
12362 if (hash_mode == 8900)
12363 {
12364 force_jit_compilation = 8900;
12365 }
12366 else if (hash_mode == 9300)
12367 {
12368 force_jit_compilation = 8900;
12369 }
12370 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12371 {
12372 force_jit_compilation = 1500;
12373 }
12374
12375 /**
12376 * generate bitmap tables
12377 */
12378
12379 const uint bitmap_shift1 = 5;
12380 const uint bitmap_shift2 = 13;
12381
12382 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12383
12384 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12385 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12386 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12387 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12388 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12389 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12390 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12391 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12392
12393 uint bitmap_bits;
12394 uint bitmap_nums;
12395 uint bitmap_mask;
12396 uint bitmap_size;
12397
12398 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12399 {
12400 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12401
12402 bitmap_nums = 1 << bitmap_bits;
12403
12404 bitmap_mask = bitmap_nums - 1;
12405
12406 bitmap_size = bitmap_nums * sizeof (uint);
12407
12408 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12409
12410 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;
12411 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;
12412
12413 break;
12414 }
12415
12416 bitmap_nums = 1 << bitmap_bits;
12417
12418 bitmap_mask = bitmap_nums - 1;
12419
12420 bitmap_size = bitmap_nums * sizeof (uint);
12421
12422 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);
12423 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);
12424
12425 /**
12426 * prepare quick rule
12427 */
12428
12429 data.rule_buf_l = rule_buf_l;
12430 data.rule_buf_r = rule_buf_r;
12431
12432 int rule_len_l = (int) strlen (rule_buf_l);
12433 int rule_len_r = (int) strlen (rule_buf_r);
12434
12435 data.rule_len_l = rule_len_l;
12436 data.rule_len_r = rule_len_r;
12437
12438 /**
12439 * load rules
12440 */
12441
12442 uint *all_kernel_rules_cnt = NULL;
12443
12444 kernel_rule_t **all_kernel_rules_buf = NULL;
12445
12446 if (rp_files_cnt)
12447 {
12448 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12449
12450 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12451 }
12452
12453 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12454
12455 int rule_len = 0;
12456
12457 for (uint i = 0; i < rp_files_cnt; i++)
12458 {
12459 uint kernel_rules_avail = 0;
12460
12461 uint kernel_rules_cnt = 0;
12462
12463 kernel_rule_t *kernel_rules_buf = NULL;
12464
12465 char *rp_file = rp_files[i];
12466
12467 char in[BLOCK_SIZE] = { 0 };
12468 char out[BLOCK_SIZE] = { 0 };
12469
12470 FILE *fp = NULL;
12471
12472 uint rule_line = 0;
12473
12474 if ((fp = fopen (rp_file, "rb")) == NULL)
12475 {
12476 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12477
12478 return (-1);
12479 }
12480
12481 while (!feof (fp))
12482 {
12483 memset (rule_buf, 0, HCBUFSIZ);
12484
12485 rule_len = fgetl (fp, rule_buf);
12486
12487 rule_line++;
12488
12489 if (rule_len == 0) continue;
12490
12491 if (rule_buf[0] == '#') continue;
12492
12493 if (kernel_rules_avail == kernel_rules_cnt)
12494 {
12495 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12496
12497 kernel_rules_avail += INCR_RULES;
12498 }
12499
12500 memset (in, 0, BLOCK_SIZE);
12501 memset (out, 0, BLOCK_SIZE);
12502
12503 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12504
12505 if (result == -1)
12506 {
12507 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12508
12509 continue;
12510 }
12511
12512 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12513 {
12514 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12515
12516 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12517
12518 continue;
12519 }
12520
12521 /* its so slow
12522 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12523 {
12524 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12525
12526 continue;
12527 }
12528 */
12529
12530 kernel_rules_cnt++;
12531 }
12532
12533 fclose (fp);
12534
12535 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12536
12537 all_kernel_rules_buf[i] = kernel_rules_buf;
12538 }
12539
12540 /**
12541 * merge rules or automatic rule generator
12542 */
12543
12544 uint kernel_rules_cnt = 0;
12545
12546 kernel_rule_t *kernel_rules_buf = NULL;
12547
12548 if (attack_mode == ATTACK_MODE_STRAIGHT)
12549 {
12550 if (rp_files_cnt)
12551 {
12552 kernel_rules_cnt = 1;
12553
12554 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12555
12556 repeats[0] = kernel_rules_cnt;
12557
12558 for (uint i = 0; i < rp_files_cnt; i++)
12559 {
12560 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12561
12562 repeats[i + 1] = kernel_rules_cnt;
12563 }
12564
12565 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12566
12567 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12568
12569 for (uint i = 0; i < kernel_rules_cnt; i++)
12570 {
12571 uint out_pos = 0;
12572
12573 kernel_rule_t *out = &kernel_rules_buf[i];
12574
12575 for (uint j = 0; j < rp_files_cnt; j++)
12576 {
12577 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12578 uint in_pos;
12579
12580 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12581
12582 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12583 {
12584 if (out_pos == RULES_MAX - 1)
12585 {
12586 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12587
12588 break;
12589 }
12590
12591 out->cmds[out_pos] = in->cmds[in_pos];
12592 }
12593 }
12594 }
12595
12596 local_free (repeats);
12597 }
12598 else if (rp_gen)
12599 {
12600 uint kernel_rules_avail = 0;
12601
12602 while (kernel_rules_cnt < rp_gen)
12603 {
12604 if (kernel_rules_avail == kernel_rules_cnt)
12605 {
12606 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12607
12608 kernel_rules_avail += INCR_RULES;
12609 }
12610
12611 memset (rule_buf, 0, HCBUFSIZ);
12612
12613 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12614
12615 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12616
12617 kernel_rules_cnt++;
12618 }
12619 }
12620 }
12621
12622 myfree (rule_buf);
12623
12624 /**
12625 * generate NOP rules
12626 */
12627
12628 if (kernel_rules_cnt == 0)
12629 {
12630 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12631
12632 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12633
12634 kernel_rules_cnt++;
12635 }
12636
12637 data.kernel_rules_cnt = kernel_rules_cnt;
12638 data.kernel_rules_buf = kernel_rules_buf;
12639
12640 /**
12641 * OpenCL platforms: detect
12642 */
12643
12644 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12645 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12646
12647 cl_uint platforms_cnt = 0;
12648 cl_uint platform_devices_cnt = 0;
12649
12650 if (keyspace == 0)
12651 {
12652 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12653
12654 if (platforms_cnt == 0)
12655 {
12656 log_error ("ERROR: No OpenCL compatible platform found");
12657
12658 return (-1);
12659 }
12660
12661 if (opencl_platforms_filter != (uint) -1)
12662 {
12663 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12664
12665 if (opencl_platforms_filter > platform_cnt_mask)
12666 {
12667 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12668
12669 return (-1);
12670 }
12671 }
12672 }
12673
12674 /**
12675 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12676 */
12677
12678 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12679 {
12680 cl_platform_id platform = platforms[platform_id];
12681
12682 char platform_vendor[INFOSZ] = { 0 };
12683
12684 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12685
12686 #ifdef HAVE_HWMON
12687 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12688 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12689 {
12690 // make sure that we do not directly control the fan for NVidia
12691
12692 gpu_temp_retain = 0;
12693
12694 data.gpu_temp_retain = gpu_temp_retain;
12695 }
12696 #endif // HAVE_NVML || HAVE_NVAPI
12697 #endif
12698 }
12699
12700 /**
12701 * OpenCL devices: simply push all devices from all platforms into the same device array
12702 */
12703
12704 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12705
12706 data.devices_param = devices_param;
12707
12708 uint devices_cnt = 0;
12709
12710 uint devices_active = 0;
12711
12712 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12713 {
12714 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12715
12716 cl_platform_id platform = platforms[platform_id];
12717
12718 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12719
12720 char platform_vendor[INFOSZ] = { 0 };
12721
12722 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12723
12724 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12725 // this causes trouble with vendor id based macros
12726 // we'll assign generic to those without special optimization available
12727
12728 cl_uint vendor_id = 0;
12729
12730 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12731 {
12732 vendor_id = VENDOR_ID_AMD;
12733 }
12734 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12735 {
12736 vendor_id = VENDOR_ID_GENERIC;
12737 }
12738 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12739 {
12740 vendor_id = VENDOR_ID_GENERIC;
12741 }
12742 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12743 {
12744 vendor_id = VENDOR_ID_GENERIC;
12745 }
12746 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12747 {
12748 vendor_id = VENDOR_ID_GENERIC;
12749 }
12750 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12751 {
12752 vendor_id = VENDOR_ID_NV;
12753 }
12754 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12755 {
12756 vendor_id = VENDOR_ID_GENERIC;
12757 }
12758 else
12759 {
12760 vendor_id = VENDOR_ID_GENERIC;
12761 }
12762
12763 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12764 {
12765 size_t param_value_size = 0;
12766
12767 const uint device_id = devices_cnt;
12768
12769 hc_device_param_t *device_param = &data.devices_param[device_id];
12770
12771 device_param->vendor_id = vendor_id;
12772
12773 device_param->device = platform_devices[platform_devices_id];
12774
12775 device_param->device_id = device_id;
12776
12777 device_param->platform_devices_id = platform_devices_id;
12778
12779 // device_type
12780
12781 cl_device_type device_type;
12782
12783 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12784
12785 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12786
12787 device_param->device_type = device_type;
12788
12789 // device_name
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12792
12793 char *device_name = (char *) mymalloc (param_value_size);
12794
12795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12796
12797 device_param->device_name = device_name;
12798
12799 // tuning db
12800
12801 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12802
12803 // device_version
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12806
12807 char *device_version = (char *) mymalloc (param_value_size);
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12810
12811 device_param->device_version = device_version;
12812
12813 // device_opencl_version
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12816
12817 char *device_opencl_version = (char *) mymalloc (param_value_size);
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12820
12821 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12822
12823 myfree (device_opencl_version);
12824
12825 // vector_width
12826
12827 cl_uint vector_width;
12828
12829 if (opencl_vector_width_chgd == 0)
12830 {
12831 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12832 {
12833 if (opti_type & OPTI_TYPE_USES_BITS_64)
12834 {
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12836 }
12837 else
12838 {
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12840 }
12841 }
12842 else
12843 {
12844 vector_width = (cl_uint) tuningdb_entry->vector_width;
12845 }
12846 }
12847 else
12848 {
12849 vector_width = opencl_vector_width;
12850 }
12851
12852 if (vector_width > 16) vector_width = 16;
12853
12854 device_param->vector_width = vector_width;
12855
12856 // max_compute_units
12857
12858 cl_uint device_processors;
12859
12860 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12861
12862 device_param->device_processors = device_processors;
12863
12864 // max_mem_alloc_size
12865
12866 cl_ulong device_maxmem_alloc;
12867
12868 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12869
12870 device_param->device_maxmem_alloc = device_maxmem_alloc;
12871
12872 // max_mem_alloc_size
12873
12874 cl_ulong device_global_mem;
12875
12876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12877
12878 device_param->device_global_mem = device_global_mem;
12879
12880 // max_clock_frequency
12881
12882 cl_uint device_maxclock_frequency;
12883
12884 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12885
12886 device_param->device_maxclock_frequency = device_maxclock_frequency;
12887
12888 // skipped
12889
12890 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12891 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12892
12893 device_param->skipped = (skipped1 || skipped2);
12894
12895 // driver_version
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12897
12898 char *driver_version = (char *) mymalloc (param_value_size);
12899
12900 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12901
12902 device_param->driver_version = driver_version;
12903
12904 // device_name_chksum
12905
12906 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12907
12908 #if __x86_64__
12909 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);
12910 #else
12911 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);
12912 #endif
12913
12914 uint device_name_digest[4] = { 0 };
12915
12916 md5_64 ((uint *) device_name_chksum, device_name_digest);
12917
12918 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12919
12920 device_param->device_name_chksum = device_name_chksum;
12921
12922 // device_processor_cores
12923
12924 if (device_type & CL_DEVICE_TYPE_CPU)
12925 {
12926 cl_uint device_processor_cores = 1;
12927
12928 device_param->device_processor_cores = device_processor_cores;
12929 }
12930
12931 if (device_type & CL_DEVICE_TYPE_GPU)
12932 {
12933 if (vendor_id == VENDOR_ID_AMD)
12934 {
12935 cl_uint device_processor_cores = 0;
12936
12937 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12938
12939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12940
12941 device_param->device_processor_cores = device_processor_cores;
12942 }
12943 else if (vendor_id == VENDOR_ID_NV)
12944 {
12945 cl_uint kernel_exec_timeout = 0;
12946
12947 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12948
12949 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12950
12951 device_param->kernel_exec_timeout = kernel_exec_timeout;
12952
12953 cl_uint device_processor_cores = 0;
12954
12955 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12956
12957 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12958
12959 device_param->device_processor_cores = device_processor_cores;
12960
12961 cl_uint sm_minor = 0;
12962 cl_uint sm_major = 0;
12963
12964 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12965 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12966
12967 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12968 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12969
12970 device_param->sm_minor = sm_minor;
12971 device_param->sm_major = sm_major;
12972 }
12973 else
12974 {
12975 cl_uint device_processor_cores = 1;
12976
12977 device_param->device_processor_cores = device_processor_cores;
12978 }
12979 }
12980
12981 // display results
12982
12983 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12984 {
12985 if (device_param->skipped == 0)
12986 {
12987 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12988 device_id + 1,
12989 device_name,
12990 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12991 (unsigned int) (device_global_mem / 1024 / 1024),
12992 (unsigned int) (device_maxclock_frequency),
12993 (unsigned int) device_processors);
12994 }
12995 else
12996 {
12997 log_info ("Device #%u: %s, skipped",
12998 device_id + 1,
12999 device_name);
13000 }
13001 }
13002
13003 // common driver check
13004
13005 if (device_param->skipped == 0)
13006 {
13007 if (device_type & CL_DEVICE_TYPE_GPU)
13008 {
13009 if (vendor_id == VENDOR_ID_AMD)
13010 {
13011 int catalyst_check = (force == 1) ? 0 : 1;
13012
13013 int catalyst_warn = 0;
13014
13015 int catalyst_broken = 0;
13016
13017 if (catalyst_check == 1)
13018 {
13019 catalyst_warn = 1;
13020
13021 // v14.9 and higher
13022 if (atoi (device_param->driver_version) >= 1573)
13023 {
13024 catalyst_warn = 0;
13025 }
13026
13027 catalyst_check = 0;
13028 }
13029
13030 if (catalyst_broken == 1)
13031 {
13032 log_info ("");
13033 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13034 log_info ("It will pass over cracked hashes and does not report them as cracked");
13035 log_info ("You are STRONGLY encouraged not to use it");
13036 log_info ("You can use --force to override this but do not post error reports if you do so");
13037 log_info ("");
13038
13039 return (-1);
13040 }
13041
13042 if (catalyst_warn == 1)
13043 {
13044 log_info ("");
13045 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13046 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13047 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13048 #ifdef _WIN
13049 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13050 #endif
13051 log_info ("You can use --force to override this but do not post error reports if you do so");
13052 log_info ("");
13053
13054 return (-1);
13055 }
13056 }
13057 else if (vendor_id == VENDOR_ID_NV)
13058 {
13059 if (device_param->kernel_exec_timeout != 0)
13060 {
13061 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);
13062 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13063 }
13064 }
13065 else if (vendor_id == VENDOR_ID_POCL)
13066 {
13067 if (force == 0)
13068 {
13069 log_info ("");
13070 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
13071 log_info ("You are STRONGLY encouraged not to use it");
13072 log_info ("You can use --force to override this but do not post error reports if you do so");
13073 log_info ("");
13074
13075 return (-1);
13076 }
13077 }
13078 }
13079
13080 /**
13081 * kernel accel and loops tuning db adjustment
13082 */
13083
13084 device_param->kernel_accel_min = 1;
13085 device_param->kernel_accel_max = 1024;
13086
13087 device_param->kernel_loops_min = 1;
13088 device_param->kernel_loops_max = 1024;
13089
13090 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13091
13092 if (tuningdb_entry)
13093 {
13094 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13095 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13096
13097 if (_kernel_accel)
13098 {
13099 device_param->kernel_accel_min = _kernel_accel;
13100 device_param->kernel_accel_max = _kernel_accel;
13101 }
13102
13103 if (_kernel_loops)
13104 {
13105 if (workload_profile == 1)
13106 {
13107 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13108 }
13109 else if (workload_profile == 2)
13110 {
13111 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13112 }
13113
13114 device_param->kernel_loops_min = _kernel_loops;
13115 device_param->kernel_loops_max = _kernel_loops;
13116 }
13117 }
13118
13119 // commandline parameters overwrite tuningdb entries
13120
13121 if (kernel_accel)
13122 {
13123 device_param->kernel_accel_min = kernel_accel;
13124 device_param->kernel_accel_max = kernel_accel;
13125 }
13126
13127 if (kernel_loops)
13128 {
13129 device_param->kernel_loops_min = kernel_loops;
13130 device_param->kernel_loops_max = kernel_loops;
13131 }
13132
13133 /**
13134 * activate device
13135 */
13136
13137 devices_active++;
13138 }
13139
13140 // next please
13141
13142 devices_cnt++;
13143 }
13144 }
13145
13146 if (keyspace == 0 && devices_active == 0)
13147 {
13148 log_error ("ERROR: No devices found/left");
13149
13150 return (-1);
13151 }
13152
13153 // 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)
13154
13155 if (devices_filter != (uint) -1)
13156 {
13157 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13158
13159 if (devices_filter > devices_cnt_mask)
13160 {
13161 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13162
13163 return (-1);
13164 }
13165 }
13166
13167 data.devices_cnt = devices_cnt;
13168
13169 data.devices_active = devices_active;
13170
13171 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13172 {
13173 log_info ("");
13174 }
13175
13176 /**
13177 * HM devices: init
13178 */
13179
13180 #ifdef HAVE_HWMON
13181 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13182 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13183 #endif
13184
13185 #ifdef HAVE_ADL
13186 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13187 #endif
13188
13189 if (gpu_temp_disable == 0)
13190 {
13191 #if defined(WIN) && defined(HAVE_NVAPI)
13192 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13193
13194 if (nvapi_init (nvapi) == 0)
13195 data.hm_nv = nvapi;
13196
13197 if (data.hm_nv)
13198 {
13199 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13200 {
13201 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13202
13203 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13204
13205 int tmp_out = 0;
13206
13207 for (int i = 0; i < tmp_in; i++)
13208 {
13209 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13210 }
13211
13212 for (int i = 0; i < tmp_out; i++)
13213 {
13214 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13215
13216 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13217
13218 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;
13219 }
13220 }
13221 }
13222 #endif // WIN && HAVE_NVAPI
13223
13224 #if defined(LINUX) && defined(HAVE_NVML)
13225 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13226
13227 if (nvml_init (nvml) == 0)
13228 data.hm_nv = nvml;
13229
13230 if (data.hm_nv)
13231 {
13232 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13233 {
13234 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13235
13236 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13237
13238 int tmp_out = 0;
13239
13240 for (int i = 0; i < tmp_in; i++)
13241 {
13242 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13243 }
13244
13245 for (int i = 0; i < tmp_out; i++)
13246 {
13247 unsigned int speed;
13248
13249 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;
13250 }
13251 }
13252 }
13253 #endif // LINUX && HAVE_NVML
13254
13255 data.hm_amd = NULL;
13256
13257 #ifdef HAVE_ADL
13258 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13259
13260 if (adl_init (adl) == 0)
13261 data.hm_amd = adl;
13262
13263 if (data.hm_amd)
13264 {
13265 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13266 {
13267 // total number of adapters
13268
13269 int hm_adapters_num;
13270
13271 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13272
13273 // adapter info
13274
13275 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13276
13277 if (lpAdapterInfo == NULL) return (-1);
13278
13279 // get a list (of ids of) valid/usable adapters
13280
13281 int num_adl_adapters = 0;
13282
13283 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13284
13285 if (num_adl_adapters > 0)
13286 {
13287 hc_thread_mutex_lock (mux_adl);
13288
13289 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13290
13291 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13292
13293 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13294 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13295
13296 hc_thread_mutex_unlock (mux_adl);
13297 }
13298
13299 myfree (valid_adl_device_list);
13300 myfree (lpAdapterInfo);
13301 }
13302 }
13303 #endif // HAVE_ADL
13304
13305 if (data.hm_amd == NULL && data.hm_nv == NULL)
13306 {
13307 gpu_temp_disable = 1;
13308 }
13309 }
13310
13311 /**
13312 * OpenCL devices: allocate buffer for device specific information
13313 */
13314
13315 #ifdef HAVE_HWMON
13316 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13317
13318 #ifdef HAVE_ADL
13319 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13320
13321 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13322 #endif // ADL
13323 #endif
13324
13325 /**
13326 * enable custom signal handler(s)
13327 */
13328
13329 if (benchmark == 0)
13330 {
13331 hc_signal (sigHandler_default);
13332 }
13333 else
13334 {
13335 hc_signal (sigHandler_benchmark);
13336 }
13337
13338 /**
13339 * User-defined GPU temp handling
13340 */
13341
13342 #ifdef HAVE_HWMON
13343 if (gpu_temp_disable == 1)
13344 {
13345 gpu_temp_abort = 0;
13346 gpu_temp_retain = 0;
13347 }
13348
13349 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13350 {
13351 if (gpu_temp_abort < gpu_temp_retain)
13352 {
13353 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13354
13355 return (-1);
13356 }
13357 }
13358
13359 data.gpu_temp_disable = gpu_temp_disable;
13360 data.gpu_temp_abort = gpu_temp_abort;
13361 data.gpu_temp_retain = gpu_temp_retain;
13362 #endif
13363
13364 /**
13365 * inform the user
13366 */
13367
13368 if (data.quiet == 0)
13369 {
13370 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13371
13372 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);
13373
13374 if (attack_mode == ATTACK_MODE_STRAIGHT)
13375 {
13376 log_info ("Rules: %u", kernel_rules_cnt);
13377 }
13378
13379 if (opti_type)
13380 {
13381 log_info ("Applicable Optimizers:");
13382
13383 for (uint i = 0; i < 32; i++)
13384 {
13385 const uint opti_bit = 1u << i;
13386
13387 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13388 }
13389 }
13390
13391 /**
13392 * Watchdog and Temperature balance
13393 */
13394
13395 #ifdef HAVE_HWMON
13396 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13397 {
13398 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13399 }
13400
13401 if (gpu_temp_abort == 0)
13402 {
13403 log_info ("Watchdog: Temperature abort trigger disabled");
13404 }
13405 else
13406 {
13407 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13408 }
13409
13410 if (gpu_temp_retain == 0)
13411 {
13412 log_info ("Watchdog: Temperature retain trigger disabled");
13413 }
13414 else
13415 {
13416 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13417 }
13418 #endif
13419 }
13420
13421 if (data.quiet == 0) log_info ("");
13422
13423 /**
13424 * HM devices: copy
13425 */
13426
13427 if (gpu_temp_disable == 0)
13428 {
13429 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13430 {
13431 hc_device_param_t *device_param = &data.devices_param[device_id];
13432
13433 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13434
13435 if (device_param->skipped) continue;
13436
13437 const uint platform_devices_id = device_param->platform_devices_id;
13438
13439 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13440 if (device_param->vendor_id == VENDOR_ID_NV)
13441 {
13442 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13443 }
13444 #endif
13445
13446 #ifdef HAVE_ADL
13447 if (device_param->vendor_id == VENDOR_ID_AMD)
13448 {
13449 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13450 }
13451 #endif
13452 }
13453 }
13454
13455 /*
13456 * Temporary fix:
13457 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13458 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13459 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13460 * Driver / ADL bug?
13461 */
13462
13463 #ifdef HAVE_ADL
13464 if (powertune_enable == 1)
13465 {
13466 hc_thread_mutex_lock (mux_adl);
13467
13468 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13469 {
13470 hc_device_param_t *device_param = &data.devices_param[device_id];
13471
13472 if (device_param->skipped) continue;
13473
13474 if (data.hm_device[device_id].od_version == 6)
13475 {
13476 // set powertune value only
13477
13478 int powertune_supported = 0;
13479
13480 int ADL_rc = 0;
13481
13482 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13483 {
13484 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13485
13486 return (-1);
13487 }
13488
13489 if (powertune_supported != 0)
13490 {
13491 // powertune set
13492 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13493
13494 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13495 {
13496 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13497
13498 return (-1);
13499 }
13500
13501 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13502 {
13503 log_error ("ERROR: Failed to set new ADL PowerControl values");
13504
13505 return (-1);
13506 }
13507 }
13508 }
13509 }
13510
13511 hc_thread_mutex_unlock (mux_adl);
13512 }
13513 #endif // HAVE_ADK
13514 #endif // HAVE_HWMON
13515
13516 #ifdef DEBUG
13517 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13518 #endif
13519
13520 uint kernel_power_all = 0;
13521
13522 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13523 {
13524 /**
13525 * host buffer
13526 */
13527
13528 hc_device_param_t *device_param = &data.devices_param[device_id];
13529
13530 if (device_param->skipped) continue;
13531
13532 /**
13533 * device properties
13534 */
13535
13536 const char *device_name_chksum = device_param->device_name_chksum;
13537 const u32 device_processors = device_param->device_processors;
13538 const u32 device_processor_cores = device_param->device_processor_cores;
13539
13540 /**
13541 * create context for each device
13542 */
13543
13544 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13545
13546 /**
13547 * create command-queue
13548 */
13549
13550 // not supported with NV
13551 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13552
13553 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13554
13555 /**
13556 * create input buffers on device : calculate size of fixed memory buffers
13557 */
13558
13559 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13560 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13561
13562 device_param->size_root_css = size_root_css;
13563 device_param->size_markov_css = size_markov_css;
13564
13565 uint size_results = KERNEL_THREADS * sizeof (uint);
13566
13567 device_param->size_results = size_results;
13568
13569 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13570 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13571
13572 uint size_plains = digests_cnt * sizeof (plain_t);
13573 uint size_salts = salts_cnt * sizeof (salt_t);
13574 uint size_esalts = salts_cnt * esalt_size;
13575
13576 device_param->size_plains = size_plains;
13577 device_param->size_digests = size_digests;
13578 device_param->size_shown = size_shown;
13579 device_param->size_salts = size_salts;
13580
13581 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13582 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13583 uint size_tm = 32 * sizeof (bs_word_t);
13584
13585 // scryptV stuff
13586
13587 u64 size_scryptV = 1;
13588
13589 if ((hash_mode == 8900) || (hash_mode == 9300))
13590 {
13591 uint tmto_start = 0;
13592 uint tmto_stop = 10;
13593
13594 if (scrypt_tmto)
13595 {
13596 tmto_start = scrypt_tmto;
13597 }
13598 else
13599 {
13600 // in case the user did not specify the tmto manually
13601 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13602 // but set the lower end only in case the user has a device with too less memory
13603
13604 if (hash_mode == 8900)
13605 {
13606 if (device_param->vendor_id == VENDOR_ID_AMD)
13607 {
13608 tmto_start = 1;
13609 }
13610 else if (device_param->vendor_id == VENDOR_ID_NV)
13611 {
13612 tmto_start = 3;
13613 }
13614 }
13615 else if (hash_mode == 9300)
13616 {
13617 if (device_param->vendor_id == VENDOR_ID_AMD)
13618 {
13619 tmto_start = 3;
13620 }
13621 else if (device_param->vendor_id == VENDOR_ID_NV)
13622 {
13623 tmto_start = 5;
13624 }
13625 }
13626 }
13627
13628 if (quiet == 0) log_info ("");
13629
13630 uint shader_per_mp = 1;
13631
13632 if (device_param->vendor_id == VENDOR_ID_AMD)
13633 {
13634 shader_per_mp = 8;
13635 }
13636 else if (device_param->vendor_id == VENDOR_ID_NV)
13637 {
13638 shader_per_mp = 32;
13639 }
13640
13641 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13642 {
13643 // TODO: in theory the following calculation needs to be done per salt, not global
13644 // we assume all hashes have the same scrypt settings
13645
13646 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13647
13648 size_scryptV /= 1 << tmto;
13649
13650 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13651
13652 if (size_scryptV > device_param->device_maxmem_alloc)
13653 {
13654 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13655
13656 continue;
13657 }
13658
13659 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13660 {
13661 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13662 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13663 }
13664
13665 break;
13666 }
13667
13668 if (data.salts_buf[0].scrypt_phy == 0)
13669 {
13670 log_error ("ERROR: can't allocate enough device memory");
13671
13672 return -1;
13673 }
13674
13675 if (quiet == 0) log_info ("");
13676 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13677 }
13678
13679 /**
13680 * create input buffers on device : calculate size of dynamic size memory buffers
13681 */
13682
13683 uint kernel_threads = KERNEL_THREADS;
13684
13685 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13686
13687 if (hash_mode == 3200) kernel_threads = 8;
13688 if (hash_mode == 9000) kernel_threads = 8;
13689
13690 /**
13691 * some algorithms need a fixed kernel-loops count
13692 */
13693
13694 if (hash_mode == 1500)
13695 {
13696 const u32 kernel_loops_fixed = 1024;
13697
13698 device_param->kernel_loops_min = kernel_loops_fixed;
13699 device_param->kernel_loops_max = kernel_loops_fixed;
13700 }
13701
13702 if (hash_mode == 3000)
13703 {
13704 const u32 kernel_loops_fixed = 1024;
13705
13706 device_param->kernel_loops_min = kernel_loops_fixed;
13707 device_param->kernel_loops_max = kernel_loops_fixed;
13708 }
13709
13710 if (hash_mode == 8900)
13711 {
13712 const u32 kernel_loops_fixed = 1;
13713
13714 device_param->kernel_loops_min = kernel_loops_fixed;
13715 device_param->kernel_loops_max = kernel_loops_fixed;
13716 }
13717
13718 if (hash_mode == 9300)
13719 {
13720 const u32 kernel_loops_fixed = 1;
13721
13722 device_param->kernel_loops_min = kernel_loops_fixed;
13723 device_param->kernel_loops_max = kernel_loops_fixed;
13724 }
13725
13726 if (hash_mode == 12500)
13727 {
13728 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13729
13730 device_param->kernel_loops_min = kernel_loops_fixed;
13731 device_param->kernel_loops_max = kernel_loops_fixed;
13732 }
13733
13734 /**
13735 * some algorithms have a maximum kernel-loops count
13736 */
13737
13738 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13739 {
13740 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13741 {
13742 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13743 }
13744 }
13745
13746 /**
13747 * some algorithms need a special kernel-accel
13748 */
13749
13750 if (hash_mode == 8900)
13751 {
13752 device_param->kernel_accel_min = 1;
13753 device_param->kernel_accel_max = 64;
13754 }
13755
13756 if (hash_mode == 9300)
13757 {
13758 device_param->kernel_accel_min = 1;
13759 device_param->kernel_accel_max = 64;
13760 }
13761
13762 u32 kernel_accel_min = device_param->kernel_accel_min;
13763 u32 kernel_accel_max = device_param->kernel_accel_max;
13764
13765 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13766
13767 uint size_pws = 4;
13768 uint size_tmps = 4;
13769 uint size_hooks = 4;
13770
13771 while (kernel_accel_max >= kernel_accel_min)
13772 {
13773 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13774
13775 // size_pws
13776
13777 size_pws = kernel_power_max * sizeof (pw_t);
13778
13779 // size_tmps
13780
13781 switch (hash_mode)
13782 {
13783 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13784 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13785 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13786 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13787 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13788 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13789 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13790 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13791 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13792 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13793 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13794 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13795 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13796 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13797 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13798 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13799 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13800 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13801 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13802 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13803 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13804 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13805 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13806 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13807 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13808 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13809 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13810 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13811 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13812 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13813 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13814 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13815 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13816 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13817 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13818 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13819 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13820 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13821 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13822 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13823 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13824 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13825 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13826 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13827 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13828 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13829 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13830 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13831 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13832 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13833 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13834 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13835 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13836 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13837 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13838 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13839 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13840 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13841 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13842 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13843 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13844 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13845 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13846 };
13847
13848 // size_hooks
13849
13850 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13851 {
13852 // none yet
13853 }
13854
13855 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13856 // if not, decrease amplifier and try again
13857
13858 int skip = 0;
13859
13860 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13861 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13862 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13863
13864 if (( bitmap_size
13865 + bitmap_size
13866 + bitmap_size
13867 + bitmap_size
13868 + bitmap_size
13869 + bitmap_size
13870 + bitmap_size
13871 + bitmap_size
13872 + size_bfs
13873 + size_combs
13874 + size_digests
13875 + size_esalts
13876 + size_hooks
13877 + size_markov_css
13878 + size_plains
13879 + size_pws
13880 + size_results
13881 + size_root_css
13882 + size_rules
13883 + size_rules_c
13884 + size_salts
13885 + size_scryptV
13886 + size_shown
13887 + size_tm
13888 + size_tmps) > device_param->device_global_mem) skip = 1;
13889
13890 if (skip == 1)
13891 {
13892 kernel_accel_max--;
13893
13894 continue;
13895 }
13896
13897 break;
13898 }
13899
13900 /*
13901 if (kernel_accel_max == 0)
13902 {
13903 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13904
13905 return -1;
13906 }
13907 */
13908
13909 device_param->kernel_accel_min = kernel_accel_min;
13910 device_param->kernel_accel_max = kernel_accel_max;
13911
13912 /*
13913 if (kernel_accel_max < kernel_accel)
13914 {
13915 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13916
13917 device_param->kernel_accel = kernel_accel_max;
13918 }
13919 */
13920
13921 device_param->size_bfs = size_bfs;
13922 device_param->size_combs = size_combs;
13923 device_param->size_rules = size_rules;
13924 device_param->size_rules_c = size_rules_c;
13925 device_param->size_pws = size_pws;
13926 device_param->size_tmps = size_tmps;
13927 device_param->size_hooks = size_hooks;
13928
13929 // do not confuse kernel_accel_max with kernel_accel here
13930
13931 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13932
13933 device_param->kernel_threads = kernel_threads;
13934 device_param->kernel_power_user = kernel_power;
13935
13936 kernel_power_all += kernel_power;
13937
13938 /**
13939 * default building options
13940 */
13941
13942 char build_opts[1024] = { 0 };
13943
13944 // we don't have sm_* on vendors not NV but it doesn't matter
13945
13946 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);
13947
13948 /**
13949 * main kernel
13950 */
13951
13952 {
13953 /**
13954 * kernel source filename
13955 */
13956
13957 char source_file[256] = { 0 };
13958
13959 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13960
13961 struct stat sst;
13962
13963 if (stat (source_file, &sst) == -1)
13964 {
13965 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13966
13967 return -1;
13968 }
13969
13970 /**
13971 * kernel cached filename
13972 */
13973
13974 char cached_file[256] = { 0 };
13975
13976 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13977
13978 int cached = 1;
13979
13980 struct stat cst;
13981
13982 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13983 {
13984 cached = 0;
13985 }
13986
13987 /**
13988 * kernel compile or load
13989 */
13990
13991 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13992
13993 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13994
13995 if (force_jit_compilation == -1)
13996 {
13997 if (cached == 0)
13998 {
13999 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14000
14001 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14002
14003 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14004
14005 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14006
14007 #ifdef DEBUG
14008 size_t build_log_size = 0;
14009
14010 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14011
14012 if (build_log_size > 1)
14013 {
14014 char *build_log = (char *) malloc (build_log_size + 1);
14015
14016 memset (build_log, 0, build_log_size + 1);
14017
14018 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14019
14020 puts (build_log);
14021
14022 free (build_log);
14023 }
14024 #endif
14025
14026 if (rc != 0)
14027 {
14028 device_param->skipped = true;
14029 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14030 continue;
14031 }
14032
14033 size_t binary_size;
14034
14035 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14036
14037 u8 *binary = (u8 *) mymalloc (binary_size);
14038
14039 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14040
14041 writeProgramBin (cached_file, binary, binary_size);
14042
14043 local_free (binary);
14044 }
14045 else
14046 {
14047 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14048
14049 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14050
14051 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14052
14053 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14054 }
14055 }
14056 else
14057 {
14058 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14059
14060 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14061
14062 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14063
14064 char build_opts_update[1024] = { 0 };
14065
14066 if (force_jit_compilation == 1500)
14067 {
14068 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14069 }
14070 else if (force_jit_compilation == 8900)
14071 {
14072 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);
14073 }
14074 else
14075 {
14076 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14077 }
14078
14079 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14080
14081 #ifdef DEBUG
14082 size_t build_log_size = 0;
14083
14084 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14085
14086 if (build_log_size > 1)
14087 {
14088 char *build_log = (char *) malloc (build_log_size + 1);
14089
14090 memset (build_log, 0, build_log_size + 1);
14091
14092 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14093
14094 puts (build_log);
14095
14096 free (build_log);
14097 }
14098 #endif
14099
14100 if (rc != 0)
14101 {
14102 device_param->skipped = true;
14103
14104 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14105 }
14106 }
14107
14108 local_free (kernel_lengths);
14109 local_free (kernel_sources[0]);
14110 local_free (kernel_sources);
14111 }
14112
14113 /**
14114 * word generator kernel
14115 */
14116
14117 if (attack_mode != ATTACK_MODE_STRAIGHT)
14118 {
14119 /**
14120 * kernel mp source filename
14121 */
14122
14123 char source_file[256] = { 0 };
14124
14125 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14126
14127 struct stat sst;
14128
14129 if (stat (source_file, &sst) == -1)
14130 {
14131 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14132
14133 return -1;
14134 }
14135
14136 /**
14137 * kernel mp cached filename
14138 */
14139
14140 char cached_file[256] = { 0 };
14141
14142 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14143
14144 int cached = 1;
14145
14146 struct stat cst;
14147
14148 if (stat (cached_file, &cst) == -1)
14149 {
14150 cached = 0;
14151 }
14152
14153 /**
14154 * kernel compile or load
14155 */
14156
14157 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14158
14159 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14160
14161 if (cached == 0)
14162 {
14163 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14164
14165 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14166
14167 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14168
14169 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14170
14171 if (rc != 0)
14172 {
14173 device_param->skipped = true;
14174 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14175 continue;
14176 }
14177
14178 size_t binary_size;
14179
14180 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14181
14182 u8 *binary = (u8 *) mymalloc (binary_size);
14183
14184 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14185
14186 writeProgramBin (cached_file, binary, binary_size);
14187
14188 local_free (binary);
14189 }
14190 else
14191 {
14192 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14193
14194 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14195
14196 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14197
14198 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14199 }
14200
14201 local_free (kernel_lengths);
14202 local_free (kernel_sources[0]);
14203 local_free (kernel_sources);
14204 }
14205
14206 /**
14207 * amplifier kernel
14208 */
14209
14210 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14211 {
14212
14213 }
14214 else
14215 {
14216 /**
14217 * kernel amp source filename
14218 */
14219
14220 char source_file[256] = { 0 };
14221
14222 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14223
14224 struct stat sst;
14225
14226 if (stat (source_file, &sst) == -1)
14227 {
14228 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14229
14230 return -1;
14231 }
14232
14233 /**
14234 * kernel amp cached filename
14235 */
14236
14237 char cached_file[256] = { 0 };
14238
14239 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14240
14241 int cached = 1;
14242
14243 struct stat cst;
14244
14245 if (stat (cached_file, &cst) == -1)
14246 {
14247 cached = 0;
14248 }
14249
14250 /**
14251 * kernel compile or load
14252 */
14253
14254 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14255
14256 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14257
14258 if (cached == 0)
14259 {
14260 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14261
14262 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14263
14264 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14265
14266 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14267
14268 if (rc != 0)
14269 {
14270 device_param->skipped = true;
14271 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14272 continue;
14273 }
14274
14275 size_t binary_size;
14276
14277 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14278
14279 u8 *binary = (u8 *) mymalloc (binary_size);
14280
14281 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14282
14283 writeProgramBin (cached_file, binary, binary_size);
14284
14285 local_free (binary);
14286 }
14287 else
14288 {
14289 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14290
14291 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14292
14293 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14294
14295 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14296 }
14297
14298 local_free (kernel_lengths);
14299 local_free (kernel_sources[0]);
14300 local_free (kernel_sources);
14301 }
14302
14303 // some algorithm collide too fast, make that impossible
14304
14305 if (benchmark == 1)
14306 {
14307 ((uint *) digests_buf)[0] = -1;
14308 ((uint *) digests_buf)[1] = -1;
14309 ((uint *) digests_buf)[2] = -1;
14310 ((uint *) digests_buf)[3] = -1;
14311 }
14312
14313 /**
14314 * global buffers
14315 */
14316
14317 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14318 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14319 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14320 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14321 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14322 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14323 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14324 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14325 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14326 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14327 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14328 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14329 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14330 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14331 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14332 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14333 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14334 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14335
14336 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);
14337 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);
14338 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);
14339 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);
14340 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);
14341 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);
14342 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);
14343 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);
14344 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14345 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14346 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14347
14348 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14349 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14350 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14351 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14352 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14353 run_kernel_bzero (device_param, device_param->d_result, size_results);
14354
14355 /**
14356 * special buffers
14357 */
14358
14359 if (attack_kern == ATTACK_KERN_STRAIGHT)
14360 {
14361 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14362 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14363
14364 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14365
14366 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14367 }
14368 else if (attack_kern == ATTACK_KERN_COMBI)
14369 {
14370 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14371 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14372 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14373 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14374
14375 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14376 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14377 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14378 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14379 }
14380 else if (attack_kern == ATTACK_KERN_BF)
14381 {
14382 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14383 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14384 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14385 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14386 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14387
14388 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14389 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14390 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14391 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14392 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14393 }
14394
14395 if (size_esalts)
14396 {
14397 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14398
14399 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14400 }
14401
14402 /**
14403 * main host data
14404 */
14405
14406 uint *result = (uint *) mymalloc (size_results);
14407
14408 device_param->result = result;
14409
14410 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14411
14412 device_param->pws_buf = pws_buf;
14413
14414 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14415
14416 device_param->combs_buf = combs_buf;
14417
14418 void *hooks_buf = mymalloc (size_hooks);
14419
14420 device_param->hooks_buf = hooks_buf;
14421
14422 /**
14423 * kernel args
14424 */
14425
14426 device_param->kernel_params_buf32[21] = bitmap_mask;
14427 device_param->kernel_params_buf32[22] = bitmap_shift1;
14428 device_param->kernel_params_buf32[23] = bitmap_shift2;
14429 device_param->kernel_params_buf32[24] = 0; // salt_pos
14430 device_param->kernel_params_buf32[25] = 0; // loop_pos
14431 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14432 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14433 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14434 device_param->kernel_params_buf32[29] = 0; // digests_offset
14435 device_param->kernel_params_buf32[30] = 0; // combs_mode
14436 device_param->kernel_params_buf32[31] = 0; // gid_max
14437
14438 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14439 ? &device_param->d_pws_buf
14440 : &device_param->d_pws_amp_buf;
14441 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14442 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14443 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14444 device_param->kernel_params[ 4] = &device_param->d_tmps;
14445 device_param->kernel_params[ 5] = &device_param->d_hooks;
14446 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14447 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14448 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14449 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14450 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14451 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14452 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14453 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14454 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14455 device_param->kernel_params[15] = &device_param->d_digests_buf;
14456 device_param->kernel_params[16] = &device_param->d_digests_shown;
14457 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14458 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14459 device_param->kernel_params[19] = &device_param->d_result;
14460 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14461 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14462 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14463 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14464 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14465 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14466 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14467 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14468 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14469 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14470 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14471 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14472
14473 device_param->kernel_params_mp_buf64[3] = 0;
14474 device_param->kernel_params_mp_buf32[4] = 0;
14475 device_param->kernel_params_mp_buf32[5] = 0;
14476 device_param->kernel_params_mp_buf32[6] = 0;
14477 device_param->kernel_params_mp_buf32[7] = 0;
14478 device_param->kernel_params_mp_buf32[8] = 0;
14479
14480 device_param->kernel_params_mp[0] = NULL;
14481 device_param->kernel_params_mp[1] = NULL;
14482 device_param->kernel_params_mp[2] = NULL;
14483 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14484 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14485 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14486 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14487 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14488 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14489
14490 device_param->kernel_params_mp_l_buf64[3] = 0;
14491 device_param->kernel_params_mp_l_buf32[4] = 0;
14492 device_param->kernel_params_mp_l_buf32[5] = 0;
14493 device_param->kernel_params_mp_l_buf32[6] = 0;
14494 device_param->kernel_params_mp_l_buf32[7] = 0;
14495 device_param->kernel_params_mp_l_buf32[8] = 0;
14496 device_param->kernel_params_mp_l_buf32[9] = 0;
14497
14498 device_param->kernel_params_mp_l[0] = NULL;
14499 device_param->kernel_params_mp_l[1] = NULL;
14500 device_param->kernel_params_mp_l[2] = NULL;
14501 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14502 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14503 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14504 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14505 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14506 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14507 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14508
14509 device_param->kernel_params_mp_r_buf64[3] = 0;
14510 device_param->kernel_params_mp_r_buf32[4] = 0;
14511 device_param->kernel_params_mp_r_buf32[5] = 0;
14512 device_param->kernel_params_mp_r_buf32[6] = 0;
14513 device_param->kernel_params_mp_r_buf32[7] = 0;
14514 device_param->kernel_params_mp_r_buf32[8] = 0;
14515
14516 device_param->kernel_params_mp_r[0] = NULL;
14517 device_param->kernel_params_mp_r[1] = NULL;
14518 device_param->kernel_params_mp_r[2] = NULL;
14519 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14520 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14521 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14522 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14523 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14524 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14525
14526 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14527 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14528
14529 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14530 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14531 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14532 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14533 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14534 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14535 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14536
14537 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14538 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14539
14540 /**
14541 * kernel name
14542 */
14543
14544 char kernel_name[64] = { 0 };
14545
14546 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14547 {
14548 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14549 {
14550 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14551
14552 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14553
14554 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14555
14556 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14557
14558 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14559
14560 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14561 }
14562 else
14563 {
14564 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14565
14566 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14567
14568 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14569
14570 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14571
14572 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14573
14574 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14575 }
14576
14577 if (data.attack_mode == ATTACK_MODE_BF)
14578 {
14579 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14580 {
14581 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14582
14583 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14584 }
14585 }
14586 }
14587 else
14588 {
14589 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14590
14591 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14592
14593 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14594
14595 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14596
14597 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14598
14599 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14600
14601 if (opts_type & OPTS_TYPE_HOOK12)
14602 {
14603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14604
14605 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14606 }
14607
14608 if (opts_type & OPTS_TYPE_HOOK23)
14609 {
14610 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14611
14612 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14613 }
14614 }
14615
14616 for (uint i = 0; i <= 20; i++)
14617 {
14618 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14619 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14620 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14621
14622 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14623 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14624 }
14625
14626 for (uint i = 21; i <= 31; i++)
14627 {
14628 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14629 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14630 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14631
14632 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14633 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14634 }
14635
14636 if (attack_mode == ATTACK_MODE_BF)
14637 {
14638 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14639 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14640
14641 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14642 {
14643 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14644 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14645 }
14646 }
14647 else if (attack_mode == ATTACK_MODE_HYBRID1)
14648 {
14649 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14650 }
14651 else if (attack_mode == ATTACK_MODE_HYBRID2)
14652 {
14653 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14654 }
14655
14656 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14657 {
14658 // nothing to do
14659 }
14660 else
14661 {
14662 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14663 }
14664
14665 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14666 {
14667 // nothing to do
14668 }
14669 else
14670 {
14671 for (uint i = 0; i < 5; i++)
14672 {
14673 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14674 }
14675
14676 for (uint i = 5; i < 7; i++)
14677 {
14678 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14679 }
14680 }
14681
14682 /**
14683 * Store initial fanspeed if gpu_temp_retain is enabled
14684 */
14685
14686 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14687 int gpu_temp_retain_set = 0;
14688
14689 if (gpu_temp_disable == 0)
14690 {
14691 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14692 {
14693 hc_thread_mutex_lock (mux_adl);
14694
14695 if (data.hm_device[device_id].fan_supported == 1)
14696 {
14697 if (gpu_temp_retain_chgd == 0)
14698 {
14699 uint cur_temp = 0;
14700 uint default_temp = 0;
14701
14702 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);
14703
14704 if (ADL_rc == ADL_OK)
14705 {
14706 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14707
14708 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14709
14710 // special case with multi gpu setups: always use minimum retain
14711
14712 if (gpu_temp_retain_set == 0)
14713 {
14714 gpu_temp_retain = gpu_temp_retain_target;
14715 gpu_temp_retain_set = 1;
14716 }
14717 else
14718 {
14719 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14720 }
14721
14722 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14723 }
14724 }
14725
14726 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14727
14728 temp_retain_fanspeed_value[device_id] = fan_speed;
14729
14730 if (fan_speed == -1)
14731 {
14732 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14733
14734 temp_retain_fanspeed_value[device_id] = 0;
14735 }
14736 }
14737
14738 hc_thread_mutex_unlock (mux_adl);
14739 }
14740 }
14741
14742 /**
14743 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14744 */
14745
14746 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14747 {
14748 hc_thread_mutex_lock (mux_adl);
14749
14750 if (data.hm_device[device_id].od_version == 6)
14751 {
14752 int ADL_rc;
14753
14754 // check powertune capabilities first, if not available then skip device
14755
14756 int powertune_supported = 0;
14757
14758 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14759 {
14760 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14761
14762 return (-1);
14763 }
14764
14765 if (powertune_supported != 0)
14766 {
14767 // powercontrol settings
14768
14769 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14770
14771 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14772 {
14773 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14774 }
14775
14776 if (ADL_rc != ADL_OK)
14777 {
14778 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14779
14780 return (-1);
14781 }
14782
14783 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14784 {
14785 log_error ("ERROR: Failed to set new ADL PowerControl values");
14786
14787 return (-1);
14788 }
14789
14790 // clocks
14791
14792 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14793
14794 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14795
14796 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)
14797 {
14798 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14799
14800 return (-1);
14801 }
14802
14803 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14804
14805 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14806
14807 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14808 {
14809 log_error ("ERROR: Failed to get ADL device capabilities");
14810
14811 return (-1);
14812 }
14813
14814 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14815 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14816
14817 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14818 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14819
14820 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14821 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14822
14823 // warning if profile has too low max values
14824
14825 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14826 {
14827 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14828 }
14829
14830 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14831 {
14832 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14833 }
14834
14835 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14836
14837 performance_state->iNumberOfPerformanceLevels = 2;
14838
14839 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14840 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14841 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14842 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14843
14844 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)
14845 {
14846 log_info ("ERROR: Failed to set ADL performance state");
14847
14848 return (-1);
14849 }
14850
14851 local_free (performance_state);
14852 }
14853 }
14854
14855 hc_thread_mutex_unlock (mux_adl);
14856 }
14857 #endif // HAVE_HWMON && HAVE_ADL
14858 }
14859
14860 data.kernel_power_all = kernel_power_all;
14861
14862 if (data.quiet == 0) log_info ("");
14863
14864 /**
14865 * In benchmark-mode, inform user which algorithm is checked
14866 */
14867
14868 if (benchmark == 1)
14869 {
14870 quiet = 0;
14871
14872 data.quiet = quiet;
14873
14874 char *hash_type = strhashtype (data.hash_mode); // not a bug
14875
14876 log_info ("Hashtype: %s", hash_type);
14877 log_info ("");
14878 }
14879
14880 /**
14881 * keep track of the progress
14882 */
14883
14884 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14885 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14886 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14887
14888 /**
14889 * open filehandles
14890 */
14891
14892 #if _WIN
14893 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14894 {
14895 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14896
14897 return (-1);
14898 }
14899
14900 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14901 {
14902 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14903
14904 return (-1);
14905 }
14906
14907 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14908 {
14909 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14910
14911 return (-1);
14912 }
14913 #endif
14914
14915 /**
14916 * dictionary pad
14917 */
14918
14919 segment_size *= (1024 * 1024);
14920
14921 data.segment_size = segment_size;
14922
14923 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14924
14925 wl_data->buf = (char *) mymalloc (segment_size);
14926 wl_data->avail = segment_size;
14927 wl_data->incr = segment_size;
14928 wl_data->cnt = 0;
14929 wl_data->pos = 0;
14930
14931 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14932
14933 data.wordlist_mode = wordlist_mode;
14934
14935 cs_t *css_buf = NULL;
14936 uint css_cnt = 0;
14937 uint dictcnt = 0;
14938 uint maskcnt = 1;
14939 char **masks = NULL;
14940 char **dictfiles = NULL;
14941
14942 uint mask_from_file = 0;
14943
14944 if (attack_mode == ATTACK_MODE_STRAIGHT)
14945 {
14946 if (wordlist_mode == WL_MODE_FILE)
14947 {
14948 int wls_left = myargc - (optind + 1);
14949
14950 for (int i = 0; i < wls_left; i++)
14951 {
14952 char *l0_filename = myargv[optind + 1 + i];
14953
14954 struct stat l0_stat;
14955
14956 if (stat (l0_filename, &l0_stat) == -1)
14957 {
14958 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14959
14960 return (-1);
14961 }
14962
14963 uint is_dir = S_ISDIR (l0_stat.st_mode);
14964
14965 if (is_dir == 0)
14966 {
14967 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14968
14969 dictcnt++;
14970
14971 dictfiles[dictcnt - 1] = l0_filename;
14972 }
14973 else
14974 {
14975 // do not allow --keyspace w/ a directory
14976
14977 if (keyspace == 1)
14978 {
14979 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14980
14981 return (-1);
14982 }
14983
14984 char **dictionary_files = NULL;
14985
14986 dictionary_files = scan_directory (l0_filename);
14987
14988 if (dictionary_files != NULL)
14989 {
14990 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14991
14992 for (int d = 0; dictionary_files[d] != NULL; d++)
14993 {
14994 char *l1_filename = dictionary_files[d];
14995
14996 struct stat l1_stat;
14997
14998 if (stat (l1_filename, &l1_stat) == -1)
14999 {
15000 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15001
15002 return (-1);
15003 }
15004
15005 if (S_ISREG (l1_stat.st_mode))
15006 {
15007 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15008
15009 dictcnt++;
15010
15011 dictfiles[dictcnt - 1] = strdup (l1_filename);
15012 }
15013 }
15014 }
15015
15016 local_free (dictionary_files);
15017 }
15018 }
15019
15020 if (dictcnt < 1)
15021 {
15022 log_error ("ERROR: No usable dictionary file found.");
15023
15024 return (-1);
15025 }
15026 }
15027 else if (wordlist_mode == WL_MODE_STDIN)
15028 {
15029 dictcnt = 1;
15030 }
15031 }
15032 else if (attack_mode == ATTACK_MODE_COMBI)
15033 {
15034 // display
15035
15036 char *dictfile1 = myargv[optind + 1 + 0];
15037 char *dictfile2 = myargv[optind + 1 + 1];
15038
15039 // find the bigger dictionary and use as base
15040
15041 FILE *fp1 = NULL;
15042 FILE *fp2 = NULL;
15043
15044 struct stat tmp_stat;
15045
15046 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15047 {
15048 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15049
15050 return (-1);
15051 }
15052
15053 if (stat (dictfile1, &tmp_stat) == -1)
15054 {
15055 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15056
15057 fclose (fp1);
15058
15059 return (-1);
15060 }
15061
15062 if (S_ISDIR (tmp_stat.st_mode))
15063 {
15064 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15065
15066 fclose (fp1);
15067
15068 return (-1);
15069 }
15070
15071 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15072 {
15073 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15074
15075 fclose (fp1);
15076
15077 return (-1);
15078 }
15079
15080 if (stat (dictfile2, &tmp_stat) == -1)
15081 {
15082 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15083
15084 fclose (fp1);
15085 fclose (fp2);
15086
15087 return (-1);
15088 }
15089
15090 if (S_ISDIR (tmp_stat.st_mode))
15091 {
15092 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15093
15094 fclose (fp1);
15095 fclose (fp2);
15096
15097 return (-1);
15098 }
15099
15100 data.combs_cnt = 1;
15101
15102 data.quiet = 1;
15103
15104 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15105
15106 data.quiet = quiet;
15107
15108 if (words1_cnt == 0)
15109 {
15110 log_error ("ERROR: %s: empty file", dictfile1);
15111
15112 fclose (fp1);
15113 fclose (fp2);
15114
15115 return (-1);
15116 }
15117
15118 data.combs_cnt = 1;
15119
15120 data.quiet = 1;
15121
15122 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15123
15124 data.quiet = quiet;
15125
15126 if (words2_cnt == 0)
15127 {
15128 log_error ("ERROR: %s: empty file", dictfile2);
15129
15130 fclose (fp1);
15131 fclose (fp2);
15132
15133 return (-1);
15134 }
15135
15136 fclose (fp1);
15137 fclose (fp2);
15138
15139 data.dictfile = dictfile1;
15140 data.dictfile2 = dictfile2;
15141
15142 if (words1_cnt >= words2_cnt)
15143 {
15144 data.combs_cnt = words2_cnt;
15145 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15146
15147 dictfiles = &data.dictfile;
15148
15149 dictcnt = 1;
15150 }
15151 else
15152 {
15153 data.combs_cnt = words1_cnt;
15154 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15155
15156 dictfiles = &data.dictfile2;
15157
15158 dictcnt = 1;
15159
15160 // we also have to switch wordlist related rules!
15161
15162 char *tmpc = data.rule_buf_l;
15163
15164 data.rule_buf_l = data.rule_buf_r;
15165 data.rule_buf_r = tmpc;
15166
15167 int tmpi = data.rule_len_l;
15168
15169 data.rule_len_l = data.rule_len_r;
15170 data.rule_len_r = tmpi;
15171 }
15172 }
15173 else if (attack_mode == ATTACK_MODE_BF)
15174 {
15175 char *mask = NULL;
15176
15177 maskcnt = 0;
15178
15179 if (benchmark == 0)
15180 {
15181 mask = myargv[optind + 1];
15182
15183 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15184
15185 if ((optind + 2) <= myargc)
15186 {
15187 struct stat file_stat;
15188
15189 if (stat (mask, &file_stat) == -1)
15190 {
15191 maskcnt = 1;
15192
15193 masks[maskcnt - 1] = mystrdup (mask);
15194 }
15195 else
15196 {
15197 int wls_left = myargc - (optind + 1);
15198
15199 uint masks_avail = INCR_MASKS;
15200
15201 for (int i = 0; i < wls_left; i++)
15202 {
15203 if (i != 0)
15204 {
15205 mask = myargv[optind + 1 + i];
15206
15207 if (stat (mask, &file_stat) == -1)
15208 {
15209 log_error ("ERROR: %s: %s", mask, strerror (errno));
15210
15211 return (-1);
15212 }
15213 }
15214
15215 uint is_file = S_ISREG (file_stat.st_mode);
15216
15217 if (is_file == 1)
15218 {
15219 FILE *mask_fp;
15220
15221 if ((mask_fp = fopen (mask, "r")) == NULL)
15222 {
15223 log_error ("ERROR: %s: %s", mask, strerror (errno));
15224
15225 return (-1);
15226 }
15227
15228 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15229
15230 while (!feof (mask_fp))
15231 {
15232 memset (line_buf, 0, HCBUFSIZ);
15233
15234 int line_len = fgetl (mask_fp, line_buf);
15235
15236 if (line_len == 0) continue;
15237
15238 if (line_buf[0] == '#') continue;
15239
15240 if (masks_avail == maskcnt)
15241 {
15242 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15243
15244 masks_avail += INCR_MASKS;
15245 }
15246
15247 masks[maskcnt] = mystrdup (line_buf);
15248
15249 maskcnt++;
15250 }
15251
15252 myfree (line_buf);
15253
15254 fclose (mask_fp);
15255 }
15256 else
15257 {
15258 log_error ("ERROR: %s: unsupported file-type", mask);
15259
15260 return (-1);
15261 }
15262 }
15263
15264 mask_from_file = 1;
15265 }
15266 }
15267 else
15268 {
15269 custom_charset_1 = (char *) "?l?d?u";
15270 custom_charset_2 = (char *) "?l?d";
15271 custom_charset_3 = (char *) "?l?d*!$@_";
15272
15273 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15274 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15275 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15276
15277 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15278
15279 wordlist_mode = WL_MODE_MASK;
15280
15281 data.wordlist_mode = wordlist_mode;
15282
15283 increment = 1;
15284
15285 maskcnt = 1;
15286 }
15287 }
15288 else
15289 {
15290 /**
15291 * generate full masks and charsets
15292 */
15293
15294 masks = (char **) mymalloc (sizeof (char *));
15295
15296 switch (hash_mode)
15297 {
15298 case 1731: pw_min = 5;
15299 pw_max = 5;
15300 mask = mystrdup ("?b?b?b?b?b");
15301 break;
15302 case 12500: pw_min = 5;
15303 pw_max = 5;
15304 mask = mystrdup ("?b?b?b?b?b");
15305 break;
15306 default: pw_min = 7;
15307 pw_max = 7;
15308 mask = mystrdup ("?b?b?b?b?b?b?b");
15309 break;
15310 }
15311
15312 maskcnt = 1;
15313
15314 masks[maskcnt - 1] = mystrdup (mask);
15315
15316 wordlist_mode = WL_MODE_MASK;
15317
15318 data.wordlist_mode = wordlist_mode;
15319
15320 increment = 1;
15321 }
15322
15323 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15324
15325 if (increment)
15326 {
15327 if (increment_min > pw_min) pw_min = increment_min;
15328
15329 if (increment_max < pw_max) pw_max = increment_max;
15330 }
15331 }
15332 else if (attack_mode == ATTACK_MODE_HYBRID1)
15333 {
15334 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15335
15336 // display
15337
15338 char *mask = myargv[myargc - 1];
15339
15340 maskcnt = 0;
15341
15342 masks = (char **) mymalloc (1 * sizeof (char *));
15343
15344 // mod
15345
15346 struct stat file_stat;
15347
15348 if (stat (mask, &file_stat) == -1)
15349 {
15350 maskcnt = 1;
15351
15352 masks[maskcnt - 1] = mystrdup (mask);
15353 }
15354 else
15355 {
15356 uint is_file = S_ISREG (file_stat.st_mode);
15357
15358 if (is_file == 1)
15359 {
15360 FILE *mask_fp;
15361
15362 if ((mask_fp = fopen (mask, "r")) == NULL)
15363 {
15364 log_error ("ERROR: %s: %s", mask, strerror (errno));
15365
15366 return (-1);
15367 }
15368
15369 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15370
15371 uint masks_avail = 1;
15372
15373 while (!feof (mask_fp))
15374 {
15375 memset (line_buf, 0, HCBUFSIZ);
15376
15377 int line_len = fgetl (mask_fp, line_buf);
15378
15379 if (line_len == 0) continue;
15380
15381 if (line_buf[0] == '#') continue;
15382
15383 if (masks_avail == maskcnt)
15384 {
15385 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15386
15387 masks_avail += INCR_MASKS;
15388 }
15389
15390 masks[maskcnt] = mystrdup (line_buf);
15391
15392 maskcnt++;
15393 }
15394
15395 myfree (line_buf);
15396
15397 fclose (mask_fp);
15398
15399 mask_from_file = 1;
15400 }
15401 else
15402 {
15403 maskcnt = 1;
15404
15405 masks[maskcnt - 1] = mystrdup (mask);
15406 }
15407 }
15408
15409 // base
15410
15411 int wls_left = myargc - (optind + 2);
15412
15413 for (int i = 0; i < wls_left; i++)
15414 {
15415 char *filename = myargv[optind + 1 + i];
15416
15417 struct stat file_stat;
15418
15419 if (stat (filename, &file_stat) == -1)
15420 {
15421 log_error ("ERROR: %s: %s", filename, strerror (errno));
15422
15423 return (-1);
15424 }
15425
15426 uint is_dir = S_ISDIR (file_stat.st_mode);
15427
15428 if (is_dir == 0)
15429 {
15430 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15431
15432 dictcnt++;
15433
15434 dictfiles[dictcnt - 1] = filename;
15435 }
15436 else
15437 {
15438 // do not allow --keyspace w/ a directory
15439
15440 if (keyspace == 1)
15441 {
15442 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15443
15444 return (-1);
15445 }
15446
15447 char **dictionary_files = NULL;
15448
15449 dictionary_files = scan_directory (filename);
15450
15451 if (dictionary_files != NULL)
15452 {
15453 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15454
15455 for (int d = 0; dictionary_files[d] != NULL; d++)
15456 {
15457 char *l1_filename = dictionary_files[d];
15458
15459 struct stat l1_stat;
15460
15461 if (stat (l1_filename, &l1_stat) == -1)
15462 {
15463 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15464
15465 return (-1);
15466 }
15467
15468 if (S_ISREG (l1_stat.st_mode))
15469 {
15470 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15471
15472 dictcnt++;
15473
15474 dictfiles[dictcnt - 1] = strdup (l1_filename);
15475 }
15476 }
15477 }
15478
15479 local_free (dictionary_files);
15480 }
15481 }
15482
15483 if (dictcnt < 1)
15484 {
15485 log_error ("ERROR: No usable dictionary file found.");
15486
15487 return (-1);
15488 }
15489
15490 if (increment)
15491 {
15492 maskcnt = 0;
15493
15494 uint mask_min = increment_min; // we can't reject smaller masks here
15495 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15496
15497 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15498 {
15499 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15500
15501 if (cur_mask == NULL) break;
15502
15503 masks[maskcnt] = cur_mask;
15504
15505 maskcnt++;
15506
15507 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15508 }
15509 }
15510 }
15511 else if (attack_mode == ATTACK_MODE_HYBRID2)
15512 {
15513 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15514
15515 // display
15516
15517 char *mask = myargv[optind + 1 + 0];
15518
15519 maskcnt = 0;
15520
15521 masks = (char **) mymalloc (1 * sizeof (char *));
15522
15523 // mod
15524
15525 struct stat file_stat;
15526
15527 if (stat (mask, &file_stat) == -1)
15528 {
15529 maskcnt = 1;
15530
15531 masks[maskcnt - 1] = mystrdup (mask);
15532 }
15533 else
15534 {
15535 uint is_file = S_ISREG (file_stat.st_mode);
15536
15537 if (is_file == 1)
15538 {
15539 FILE *mask_fp;
15540
15541 if ((mask_fp = fopen (mask, "r")) == NULL)
15542 {
15543 log_error ("ERROR: %s: %s", mask, strerror (errno));
15544
15545 return (-1);
15546 }
15547
15548 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15549
15550 uint masks_avail = 1;
15551
15552 while (!feof (mask_fp))
15553 {
15554 memset (line_buf, 0, HCBUFSIZ);
15555
15556 int line_len = fgetl (mask_fp, line_buf);
15557
15558 if (line_len == 0) continue;
15559
15560 if (line_buf[0] == '#') continue;
15561
15562 if (masks_avail == maskcnt)
15563 {
15564 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15565
15566 masks_avail += INCR_MASKS;
15567 }
15568
15569 masks[maskcnt] = mystrdup (line_buf);
15570
15571 maskcnt++;
15572 }
15573
15574 myfree (line_buf);
15575
15576 fclose (mask_fp);
15577
15578 mask_from_file = 1;
15579 }
15580 else
15581 {
15582 maskcnt = 1;
15583
15584 masks[maskcnt - 1] = mystrdup (mask);
15585 }
15586 }
15587
15588 // base
15589
15590 int wls_left = myargc - (optind + 2);
15591
15592 for (int i = 0; i < wls_left; i++)
15593 {
15594 char *filename = myargv[optind + 2 + i];
15595
15596 struct stat file_stat;
15597
15598 if (stat (filename, &file_stat) == -1)
15599 {
15600 log_error ("ERROR: %s: %s", filename, strerror (errno));
15601
15602 return (-1);
15603 }
15604
15605 uint is_dir = S_ISDIR (file_stat.st_mode);
15606
15607 if (is_dir == 0)
15608 {
15609 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15610
15611 dictcnt++;
15612
15613 dictfiles[dictcnt - 1] = filename;
15614 }
15615 else
15616 {
15617 // do not allow --keyspace w/ a directory
15618
15619 if (keyspace == 1)
15620 {
15621 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15622
15623 return (-1);
15624 }
15625
15626 char **dictionary_files = NULL;
15627
15628 dictionary_files = scan_directory (filename);
15629
15630 if (dictionary_files != NULL)
15631 {
15632 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15633
15634 for (int d = 0; dictionary_files[d] != NULL; d++)
15635 {
15636 char *l1_filename = dictionary_files[d];
15637
15638 struct stat l1_stat;
15639
15640 if (stat (l1_filename, &l1_stat) == -1)
15641 {
15642 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15643
15644 return (-1);
15645 }
15646
15647 if (S_ISREG (l1_stat.st_mode))
15648 {
15649 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15650
15651 dictcnt++;
15652
15653 dictfiles[dictcnt - 1] = strdup (l1_filename);
15654 }
15655 }
15656 }
15657
15658 local_free (dictionary_files);
15659 }
15660 }
15661
15662 if (dictcnt < 1)
15663 {
15664 log_error ("ERROR: No usable dictionary file found.");
15665
15666 return (-1);
15667 }
15668
15669 if (increment)
15670 {
15671 maskcnt = 0;
15672
15673 uint mask_min = increment_min; // we can't reject smaller masks here
15674 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15675
15676 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15677 {
15678 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15679
15680 if (cur_mask == NULL) break;
15681
15682 masks[maskcnt] = cur_mask;
15683
15684 maskcnt++;
15685
15686 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15687 }
15688 }
15689 }
15690
15691 data.pw_min = pw_min;
15692 data.pw_max = pw_max;
15693
15694 /**
15695 * weak hash check
15696 */
15697
15698 if (weak_hash_threshold >= salts_cnt)
15699 {
15700 hc_device_param_t *device_param = NULL;
15701
15702 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15703 {
15704 device_param = &data.devices_param[device_id];
15705
15706 if (device_param->skipped) continue;
15707
15708 break;
15709 }
15710
15711 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15712
15713 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15714 {
15715 weak_hash_check (device_param, salt_pos);
15716 }
15717 }
15718
15719 // Display hack, guarantee that there is at least one \r before real start
15720
15721 if (data.quiet == 0) log_info_nn ("");
15722
15723 /**
15724 * status and monitor threads
15725 */
15726
15727 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15728
15729 hc_thread_t i_thread = 0;
15730
15731 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15732 {
15733 hc_thread_create (i_thread, thread_keypress, &benchmark);
15734 }
15735
15736 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15737
15738 uint ni_threads_cnt = 0;
15739
15740 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15741
15742 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15743
15744 ni_threads_cnt++;
15745
15746 /**
15747 * Outfile remove
15748 */
15749
15750 if (keyspace == 0)
15751 {
15752 if (outfile_check_timer != 0)
15753 {
15754 if (data.outfile_check_directory != NULL)
15755 {
15756 if ((hash_mode != 5200) &&
15757 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15758 (hash_mode != 9000))
15759 {
15760 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15761
15762 ni_threads_cnt++;
15763 }
15764 else
15765 {
15766 outfile_check_timer = 0;
15767 }
15768 }
15769 else
15770 {
15771 outfile_check_timer = 0;
15772 }
15773 }
15774 }
15775
15776 /**
15777 * Inform the user if we got some hashes remove because of the pot file remove feature
15778 */
15779
15780 if (data.quiet == 0)
15781 {
15782 if (potfile_remove_cracks > 0)
15783 {
15784 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15785 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15786 }
15787 }
15788
15789 data.outfile_check_timer = outfile_check_timer;
15790
15791 /**
15792 * main loop
15793 */
15794
15795 char **induction_dictionaries = NULL;
15796
15797 int induction_dictionaries_cnt = 0;
15798
15799 hcstat_table_t *root_table_buf = NULL;
15800 hcstat_table_t *markov_table_buf = NULL;
15801
15802 uint initial_restore_done = 0;
15803
15804 data.maskcnt = maskcnt;
15805
15806 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15807 {
15808 if (data.devices_status == STATUS_CRACKED) break;
15809
15810 data.devices_status = STATUS_INIT;
15811
15812 if (maskpos > rd->maskpos)
15813 {
15814 rd->dictpos = 0;
15815 }
15816
15817 rd->maskpos = maskpos;
15818 data.maskpos = maskpos;
15819
15820 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15821 {
15822 char *mask = masks[maskpos];
15823
15824 if (mask_from_file == 1)
15825 {
15826 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15827
15828 char *str_ptr;
15829 uint str_pos;
15830
15831 uint mask_offset = 0;
15832
15833 uint separator_cnt;
15834
15835 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15836 {
15837 str_ptr = strstr (mask + mask_offset, ",");
15838
15839 if (str_ptr == NULL) break;
15840
15841 str_pos = str_ptr - mask;
15842
15843 // escaped separator, i.e. "\,"
15844
15845 if (str_pos > 0)
15846 {
15847 if (mask[str_pos - 1] == '\\')
15848 {
15849 separator_cnt --;
15850
15851 mask_offset = str_pos + 1;
15852
15853 continue;
15854 }
15855 }
15856
15857 // reset the offset
15858
15859 mask_offset = 0;
15860
15861 mask[str_pos] = '\0';
15862
15863 switch (separator_cnt)
15864 {
15865 case 0:
15866 mp_reset_usr (mp_usr, 0);
15867
15868 custom_charset_1 = mask;
15869 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15870 break;
15871
15872 case 1:
15873 mp_reset_usr (mp_usr, 1);
15874
15875 custom_charset_2 = mask;
15876 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15877 break;
15878
15879 case 2:
15880 mp_reset_usr (mp_usr, 2);
15881
15882 custom_charset_3 = mask;
15883 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15884 break;
15885
15886 case 3:
15887 mp_reset_usr (mp_usr, 3);
15888
15889 custom_charset_4 = mask;
15890 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15891 break;
15892 }
15893
15894 mask = mask + str_pos + 1;
15895 }
15896 }
15897
15898 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15899 {
15900 if (maskpos > 0)
15901 {
15902 local_free (css_buf);
15903 local_free (data.root_css_buf);
15904 local_free (data.markov_css_buf);
15905
15906 local_free (masks[maskpos - 1]);
15907 }
15908
15909 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15910
15911 data.mask = mask;
15912 data.css_cnt = css_cnt;
15913 data.css_buf = css_buf;
15914
15915 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15916
15917 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15918
15919 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15920 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15921
15922 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15923
15924 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15925
15926 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15927 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15928
15929 data.root_css_buf = root_css_buf;
15930 data.markov_css_buf = markov_css_buf;
15931
15932 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15933
15934 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15935
15936 local_free (root_table_buf);
15937 local_free (markov_table_buf);
15938
15939 // args
15940
15941 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15942 {
15943 hc_device_param_t *device_param = &data.devices_param[device_id];
15944
15945 if (device_param->skipped) continue;
15946
15947 device_param->kernel_params_mp[0] = &device_param->d_combs;
15948 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15949 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15950
15951 device_param->kernel_params_mp_buf64[3] = 0;
15952 device_param->kernel_params_mp_buf32[4] = css_cnt;
15953 device_param->kernel_params_mp_buf32[5] = 0;
15954 device_param->kernel_params_mp_buf32[6] = 0;
15955 device_param->kernel_params_mp_buf32[7] = 0;
15956
15957 if (attack_mode == ATTACK_MODE_HYBRID1)
15958 {
15959 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15960 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15961 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15962 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15963 }
15964 else if (attack_mode == ATTACK_MODE_HYBRID2)
15965 {
15966 device_param->kernel_params_mp_buf32[5] = 0;
15967 device_param->kernel_params_mp_buf32[6] = 0;
15968 device_param->kernel_params_mp_buf32[7] = 0;
15969 }
15970
15971 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]);
15972 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]);
15973 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]);
15974
15975 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);
15976 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);
15977 }
15978 }
15979 else if (attack_mode == ATTACK_MODE_BF)
15980 {
15981 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15982
15983 if (increment)
15984 {
15985 for (uint i = 0; i < dictcnt; i++)
15986 {
15987 local_free (dictfiles[i]);
15988 }
15989
15990 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15991 {
15992 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15993
15994 if (l1_filename == NULL) break;
15995
15996 dictcnt++;
15997
15998 dictfiles[dictcnt - 1] = l1_filename;
15999 }
16000 }
16001 else
16002 {
16003 dictcnt++;
16004
16005 dictfiles[dictcnt - 1] = mask;
16006 }
16007
16008 if (dictcnt == 0)
16009 {
16010 log_error ("ERROR: Mask is too small");
16011
16012 return (-1);
16013 }
16014 }
16015 }
16016
16017 free (induction_dictionaries);
16018
16019 // induction_dictionaries_cnt = 0; // implied
16020
16021 if (attack_mode != ATTACK_MODE_BF)
16022 {
16023 if (keyspace == 0)
16024 {
16025 induction_dictionaries = scan_directory (induction_directory);
16026
16027 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16028 }
16029 }
16030
16031 if (induction_dictionaries_cnt)
16032 {
16033 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16034 }
16035
16036 /**
16037 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16038 */
16039 if (keyspace == 1)
16040 {
16041 if ((maskcnt > 1) || (dictcnt > 1))
16042 {
16043 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16044
16045 return (-1);
16046 }
16047 }
16048
16049 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16050 {
16051 char *subid = logfile_generate_subid ();
16052
16053 data.subid = subid;
16054
16055 logfile_sub_msg ("START");
16056
16057 data.devices_status = STATUS_INIT;
16058
16059 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16060 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16061 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16062
16063 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16064
16065 data.cpt_pos = 0;
16066
16067 data.cpt_start = time (NULL);
16068
16069 data.cpt_total = 0;
16070
16071 if (data.restore == 0)
16072 {
16073 rd->words_cur = skip;
16074
16075 skip = 0;
16076
16077 data.skip = 0;
16078 }
16079
16080 data.ms_paused = 0;
16081
16082 data.words_cur = rd->words_cur;
16083
16084 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16085 {
16086 hc_device_param_t *device_param = &data.devices_param[device_id];
16087
16088 if (device_param->skipped) continue;
16089
16090 device_param->speed_pos = 0;
16091
16092 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16093 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16094
16095 device_param->exec_pos = 0;
16096
16097 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16098
16099 device_param->kernel_power = device_param->kernel_power_user;
16100
16101 device_param->outerloop_pos = 0;
16102 device_param->outerloop_left = 0;
16103 device_param->innerloop_pos = 0;
16104 device_param->innerloop_left = 0;
16105
16106 // some more resets:
16107
16108 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16109
16110 device_param->pws_cnt = 0;
16111
16112 device_param->words_off = 0;
16113 device_param->words_done = 0;
16114 }
16115
16116 data.kernel_power_div = 0;
16117
16118 // figure out some workload
16119
16120 if (attack_mode == ATTACK_MODE_STRAIGHT)
16121 {
16122 if (data.wordlist_mode == WL_MODE_FILE)
16123 {
16124 char *dictfile = NULL;
16125
16126 if (induction_dictionaries_cnt)
16127 {
16128 dictfile = induction_dictionaries[0];
16129 }
16130 else
16131 {
16132 dictfile = dictfiles[dictpos];
16133 }
16134
16135 data.dictfile = dictfile;
16136
16137 logfile_sub_string (dictfile);
16138
16139 for (uint i = 0; i < rp_files_cnt; i++)
16140 {
16141 logfile_sub_var_string ("rulefile", rp_files[i]);
16142 }
16143
16144 FILE *fd2 = fopen (dictfile, "rb");
16145
16146 if (fd2 == NULL)
16147 {
16148 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16149
16150 return (-1);
16151 }
16152
16153 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16154
16155 fclose (fd2);
16156
16157 if (data.words_cnt == 0)
16158 {
16159 if (data.devices_status == STATUS_CRACKED) break;
16160 if (data.devices_status == STATUS_ABORTED) break;
16161
16162 dictpos++;
16163
16164 continue;
16165 }
16166 }
16167 }
16168 else if (attack_mode == ATTACK_MODE_COMBI)
16169 {
16170 char *dictfile = data.dictfile;
16171 char *dictfile2 = data.dictfile2;
16172
16173 logfile_sub_string (dictfile);
16174 logfile_sub_string (dictfile2);
16175
16176 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16177 {
16178 FILE *fd2 = fopen (dictfile, "rb");
16179
16180 if (fd2 == NULL)
16181 {
16182 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16183
16184 return (-1);
16185 }
16186
16187 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16188
16189 fclose (fd2);
16190 }
16191 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16192 {
16193 FILE *fd2 = fopen (dictfile2, "rb");
16194
16195 if (fd2 == NULL)
16196 {
16197 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16198
16199 return (-1);
16200 }
16201
16202 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16203
16204 fclose (fd2);
16205 }
16206
16207 if (data.words_cnt == 0)
16208 {
16209 if (data.devices_status == STATUS_CRACKED) break;
16210 if (data.devices_status == STATUS_ABORTED) break;
16211
16212 dictpos++;
16213
16214 continue;
16215 }
16216 }
16217 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16218 {
16219 char *dictfile = NULL;
16220
16221 if (induction_dictionaries_cnt)
16222 {
16223 dictfile = induction_dictionaries[0];
16224 }
16225 else
16226 {
16227 dictfile = dictfiles[dictpos];
16228 }
16229
16230 data.dictfile = dictfile;
16231
16232 char *mask = data.mask;
16233
16234 logfile_sub_string (dictfile);
16235 logfile_sub_string (mask);
16236
16237 FILE *fd2 = fopen (dictfile, "rb");
16238
16239 if (fd2 == NULL)
16240 {
16241 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16242
16243 return (-1);
16244 }
16245
16246 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16247
16248 fclose (fd2);
16249
16250 if (data.words_cnt == 0)
16251 {
16252 if (data.devices_status == STATUS_CRACKED) break;
16253 if (data.devices_status == STATUS_ABORTED) break;
16254
16255 dictpos++;
16256
16257 continue;
16258 }
16259 }
16260 else if (attack_mode == ATTACK_MODE_BF)
16261 {
16262 local_free (css_buf);
16263 local_free (data.root_css_buf);
16264 local_free (data.markov_css_buf);
16265
16266 char *mask = dictfiles[dictpos];
16267
16268 logfile_sub_string (mask);
16269
16270 // base
16271
16272 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16273
16274 if (opts_type & OPTS_TYPE_PT_UNICODE)
16275 {
16276 uint css_cnt_unicode = css_cnt * 2;
16277
16278 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16279
16280 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16281 {
16282 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16283
16284 css_buf_unicode[j + 1].cs_buf[0] = 0;
16285 css_buf_unicode[j + 1].cs_len = 1;
16286 }
16287
16288 free (css_buf);
16289
16290 css_buf = css_buf_unicode;
16291 css_cnt = css_cnt_unicode;
16292 }
16293
16294 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16295
16296 uint mask_min = pw_min;
16297 uint mask_max = pw_max;
16298
16299 if (opts_type & OPTS_TYPE_PT_UNICODE)
16300 {
16301 mask_min *= 2;
16302 mask_max *= 2;
16303 }
16304
16305 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16306 {
16307 if (css_cnt < mask_min)
16308 {
16309 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16310 }
16311
16312 if (css_cnt > mask_max)
16313 {
16314 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16315 }
16316
16317 // skip to next mask
16318
16319 dictpos++;
16320
16321 rd->dictpos = dictpos;
16322
16323 logfile_sub_msg ("STOP");
16324
16325 continue;
16326 }
16327
16328 uint save_css_cnt = css_cnt;
16329
16330 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16331 {
16332 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16333 {
16334 uint salt_len = (uint) data.salts_buf[0].salt_len;
16335 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16336
16337 uint css_cnt_salt = css_cnt + salt_len;
16338
16339 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16340
16341 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16342
16343 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16344 {
16345 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16346 css_buf_salt[j].cs_len = 1;
16347 }
16348
16349 free (css_buf);
16350
16351 css_buf = css_buf_salt;
16352 css_cnt = css_cnt_salt;
16353 }
16354 }
16355
16356 data.mask = mask;
16357 data.css_cnt = css_cnt;
16358 data.css_buf = css_buf;
16359
16360 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16361
16362 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16363
16364 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16365
16366 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16367 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16368
16369 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16370
16371 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16372
16373 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16374 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16375
16376 data.root_css_buf = root_css_buf;
16377 data.markov_css_buf = markov_css_buf;
16378
16379 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16380
16381 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16382
16383 local_free (root_table_buf);
16384 local_free (markov_table_buf);
16385
16386 // copy + args
16387
16388 uint css_cnt_l = css_cnt;
16389 uint css_cnt_r;
16390
16391 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16392 {
16393 if (save_css_cnt < 6)
16394 {
16395 css_cnt_r = 1;
16396 }
16397 else if (save_css_cnt == 6)
16398 {
16399 css_cnt_r = 2;
16400 }
16401 else
16402 {
16403 if (opts_type & OPTS_TYPE_PT_UNICODE)
16404 {
16405 if (save_css_cnt == 8 || save_css_cnt == 10)
16406 {
16407 css_cnt_r = 2;
16408 }
16409 else
16410 {
16411 css_cnt_r = 4;
16412 }
16413 }
16414 else
16415 {
16416 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16417 {
16418 css_cnt_r = 3;
16419 }
16420 else
16421 {
16422 css_cnt_r = 4;
16423 }
16424 }
16425 }
16426 }
16427 else
16428 {
16429 css_cnt_r = 1;
16430
16431 /* unfinished code?
16432 int sum = css_buf[css_cnt_r - 1].cs_len;
16433
16434 for (uint i = 1; i < 4 && i < css_cnt; i++)
16435 {
16436 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16437
16438 css_cnt_r++;
16439
16440 sum *= css_buf[css_cnt_r - 1].cs_len;
16441 }
16442 */
16443 }
16444
16445 css_cnt_l -= css_cnt_r;
16446
16447 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16448
16449 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16450 {
16451 hc_device_param_t *device_param = &data.devices_param[device_id];
16452
16453 if (device_param->skipped) continue;
16454
16455 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16456 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16457 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16458
16459 device_param->kernel_params_mp_l_buf64[3] = 0;
16460 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16461 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16462 device_param->kernel_params_mp_l_buf32[6] = 0;
16463 device_param->kernel_params_mp_l_buf32[7] = 0;
16464 device_param->kernel_params_mp_l_buf32[8] = 0;
16465
16466 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16467 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16468 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16469 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16470
16471 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16472 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16473 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16474
16475 device_param->kernel_params_mp_r_buf64[3] = 0;
16476 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16477 device_param->kernel_params_mp_r_buf32[5] = 0;
16478 device_param->kernel_params_mp_r_buf32[6] = 0;
16479 device_param->kernel_params_mp_r_buf32[7] = 0;
16480
16481 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]);
16482 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]);
16483 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]);
16484
16485 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]);
16486 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]);
16487 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]);
16488
16489 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);
16490 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);
16491 }
16492 }
16493
16494 u64 words_base = data.words_cnt;
16495
16496 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16497 {
16498 if (data.kernel_rules_cnt)
16499 {
16500 words_base /= data.kernel_rules_cnt;
16501 }
16502 }
16503 else if (data.attack_kern == ATTACK_KERN_COMBI)
16504 {
16505 if (data.combs_cnt)
16506 {
16507 words_base /= data.combs_cnt;
16508 }
16509 }
16510 else if (data.attack_kern == ATTACK_KERN_BF)
16511 {
16512 if (data.bfs_cnt)
16513 {
16514 words_base /= data.bfs_cnt;
16515 }
16516 }
16517
16518 data.words_base = words_base;
16519
16520 if (keyspace == 1)
16521 {
16522 log_info ("%llu", (unsigned long long int) words_base);
16523
16524 return (0);
16525 }
16526
16527 if (data.words_cur > data.words_base)
16528 {
16529 log_error ("ERROR: restore value greater keyspace");
16530
16531 return (-1);
16532 }
16533
16534 if (data.words_cur)
16535 {
16536 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16537 {
16538 for (uint i = 0; i < data.salts_cnt; i++)
16539 {
16540 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16541 }
16542 }
16543 else if (data.attack_kern == ATTACK_KERN_COMBI)
16544 {
16545 for (uint i = 0; i < data.salts_cnt; i++)
16546 {
16547 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16548 }
16549 }
16550 else if (data.attack_kern == ATTACK_KERN_BF)
16551 {
16552 for (uint i = 0; i < data.salts_cnt; i++)
16553 {
16554 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16555 }
16556 }
16557 }
16558
16559 /*
16560 * Inform user about possible slow speeds
16561 */
16562
16563 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16564 {
16565 if (data.words_base < kernel_power_all)
16566 {
16567 if (quiet == 0)
16568 {
16569 log_info ("");
16570 log_info ("ATTENTION!");
16571 log_info (" The wordlist or mask you are using is too small.");
16572 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16573 log_info (" The cracking speed will drop.");
16574 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16575 log_info ("");
16576 }
16577 }
16578 }
16579
16580 /*
16581 * Update loopback file
16582 */
16583
16584 if (loopback == 1)
16585 {
16586 time_t now;
16587
16588 time (&now);
16589
16590 uint random_num = get_random_num (0, 9999);
16591
16592 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16593
16594 data.loopback_file = loopback_file;
16595 }
16596
16597 /*
16598 * Update dictionary statistic
16599 */
16600
16601 if (keyspace == 0)
16602 {
16603 dictstat_fp = fopen (dictstat, "wb");
16604
16605 if (dictstat_fp)
16606 {
16607 lock_file (dictstat_fp);
16608
16609 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16610
16611 fclose (dictstat_fp);
16612 }
16613 }
16614
16615 data.devices_status = STATUS_RUNNING;
16616
16617 if (initial_restore_done == 0)
16618 {
16619 if (data.restore_disable == 0) cycle_restore ();
16620
16621 initial_restore_done = 1;
16622 }
16623
16624 hc_timer_set (&data.timer_running);
16625
16626 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16627 {
16628 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16629 {
16630 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16631 if (quiet == 0) fflush (stdout);
16632 }
16633 }
16634 else if (wordlist_mode == WL_MODE_STDIN)
16635 {
16636 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16637 if (data.quiet == 0) log_info ("");
16638 }
16639
16640 time_t runtime_start;
16641
16642 time (&runtime_start);
16643
16644 data.runtime_start = runtime_start;
16645
16646 /**
16647 * create cracker threads
16648 */
16649
16650 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16651
16652 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16653 {
16654 hc_device_param_t *device_param = &devices_param[device_id];
16655
16656 if (wordlist_mode == WL_MODE_STDIN)
16657 {
16658 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16659 }
16660 else
16661 {
16662 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16663 }
16664 }
16665
16666 // wait for crack threads to exit
16667
16668 hc_thread_wait (data.devices_cnt, c_threads);
16669
16670 local_free (c_threads);
16671
16672 data.restore = 0;
16673
16674 // finalize task
16675
16676 logfile_sub_var_uint ("status-after-work", data.devices_status);
16677
16678 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16679
16680 if (data.devices_status == STATUS_CRACKED) break;
16681 if (data.devices_status == STATUS_ABORTED) break;
16682
16683 if (data.devices_status == STATUS_BYPASS)
16684 {
16685 data.devices_status = STATUS_RUNNING;
16686 }
16687
16688 if (induction_dictionaries_cnt)
16689 {
16690 unlink (induction_dictionaries[0]);
16691 }
16692
16693 free (induction_dictionaries);
16694
16695 if (attack_mode != ATTACK_MODE_BF)
16696 {
16697 induction_dictionaries = scan_directory (induction_directory);
16698
16699 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16700 }
16701
16702 if (benchmark == 0)
16703 {
16704 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16705 {
16706 if (quiet == 0) clear_prompt ();
16707
16708 if (quiet == 0) log_info ("");
16709
16710 if (status == 1)
16711 {
16712 status_display ();
16713 }
16714 else
16715 {
16716 if (quiet == 0) status_display ();
16717 }
16718
16719 if (quiet == 0) log_info ("");
16720 }
16721 }
16722
16723 if (attack_mode == ATTACK_MODE_BF)
16724 {
16725 dictpos++;
16726
16727 rd->dictpos = dictpos;
16728 }
16729 else
16730 {
16731 if (induction_dictionaries_cnt)
16732 {
16733 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16734 }
16735 else
16736 {
16737 dictpos++;
16738
16739 rd->dictpos = dictpos;
16740 }
16741 }
16742
16743 time_t runtime_stop;
16744
16745 time (&runtime_stop);
16746
16747 data.runtime_stop = runtime_stop;
16748
16749 logfile_sub_uint (runtime_start);
16750 logfile_sub_uint (runtime_stop);
16751
16752 logfile_sub_msg ("STOP");
16753
16754 global_free (subid);
16755 }
16756
16757 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16758
16759 if (data.devices_status == STATUS_CRACKED) break;
16760 if (data.devices_status == STATUS_ABORTED) break;
16761 if (data.devices_status == STATUS_QUIT) break;
16762
16763 if (data.devices_status == STATUS_BYPASS)
16764 {
16765 data.devices_status = STATUS_RUNNING;
16766 }
16767 }
16768
16769 // 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
16770
16771 if (attack_mode == ATTACK_MODE_STRAIGHT)
16772 {
16773 if (data.wordlist_mode == WL_MODE_FILE)
16774 {
16775 if (data.dictfile == NULL)
16776 {
16777 if (dictfiles != NULL)
16778 {
16779 data.dictfile = dictfiles[0];
16780
16781 hc_timer_set (&data.timer_running);
16782 }
16783 }
16784 }
16785 }
16786 // NOTE: combi is okay because it is already set beforehand
16787 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16788 {
16789 if (data.dictfile == NULL)
16790 {
16791 if (dictfiles != NULL)
16792 {
16793 hc_timer_set (&data.timer_running);
16794
16795 data.dictfile = dictfiles[0];
16796 }
16797 }
16798 }
16799 else if (attack_mode == ATTACK_MODE_BF)
16800 {
16801 if (data.mask == NULL)
16802 {
16803 hc_timer_set (&data.timer_running);
16804
16805 data.mask = masks[0];
16806 }
16807 }
16808
16809 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16810 {
16811 data.devices_status = STATUS_EXHAUSTED;
16812 }
16813
16814 // if cracked / aborted remove last induction dictionary
16815
16816 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16817 {
16818 struct stat induct_stat;
16819
16820 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16821 {
16822 unlink (induction_dictionaries[file_pos]);
16823 }
16824 }
16825
16826 // wait for non-interactive threads
16827
16828 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16829 {
16830 hc_thread_wait (1, &ni_threads[thread_idx]);
16831 }
16832
16833 local_free (ni_threads);
16834
16835 // wait for interactive threads
16836
16837 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16838 {
16839 hc_thread_wait (1, &i_thread);
16840 }
16841
16842 // we dont need restore file anymore
16843 if (data.restore_disable == 0)
16844 {
16845 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16846 {
16847 unlink (eff_restore_file);
16848 unlink (new_restore_file);
16849 }
16850 else
16851 {
16852 cycle_restore ();
16853 }
16854 }
16855
16856 // finally save left hashes
16857
16858 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16859 {
16860 save_hash ();
16861 }
16862
16863 /**
16864 * Clean up
16865 */
16866
16867 if (benchmark == 1)
16868 {
16869 status_benchmark ();
16870
16871 log_info ("");
16872 }
16873 else
16874 {
16875 if (quiet == 0) clear_prompt ();
16876
16877 if (quiet == 0) log_info ("");
16878
16879 if (status == 1)
16880 {
16881 status_display ();
16882 }
16883 else
16884 {
16885 if (quiet == 0) status_display ();
16886 }
16887
16888 if (quiet == 0) log_info ("");
16889 }
16890
16891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16892 {
16893 hc_device_param_t *device_param = &data.devices_param[device_id];
16894
16895 if (device_param->skipped) continue;
16896
16897 local_free (device_param->result);
16898
16899 local_free (device_param->combs_buf);
16900
16901 local_free (device_param->hooks_buf);
16902
16903 local_free (device_param->device_name);
16904
16905 local_free (device_param->device_name_chksum);
16906
16907 local_free (device_param->device_version);
16908
16909 local_free (device_param->driver_version);
16910
16911 if (device_param->pws_buf) myfree (device_param->pws_buf);
16912 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16913 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16914 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16915 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16916 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16917 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16918 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16919 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16920 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16921 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16922 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16923 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16924 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16925 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16926 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16927 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16928 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16929 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16930 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16931 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16932 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16933 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16934 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16935 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16936 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16937 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16938 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16939 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16940
16941 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16942 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16943 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16944 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16945 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16946 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16947 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16948 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16949 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16950 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16951
16952 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16953 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16954 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16955
16956 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16957 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16958 }
16959
16960 // reset default fan speed
16961
16962 #ifdef HAVE_HWMON
16963 if (gpu_temp_disable == 0)
16964 {
16965 #ifdef HAVE_ADL
16966 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16967 {
16968 hc_thread_mutex_lock (mux_adl);
16969
16970 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16971 {
16972 hc_device_param_t *device_param = &data.devices_param[device_id];
16973
16974 if (device_param->skipped) continue;
16975
16976 if (data.hm_device[device_id].fan_supported == 1)
16977 {
16978 int fanspeed = temp_retain_fanspeed_value[device_id];
16979
16980 if (fanspeed == -1) continue;
16981
16982 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16983
16984 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16985 }
16986 }
16987
16988 hc_thread_mutex_unlock (mux_adl);
16989 }
16990 #endif // HAVE_ADL
16991 }
16992
16993 #ifdef HAVE_ADL
16994 // reset power tuning
16995
16996 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16997 {
16998 hc_thread_mutex_lock (mux_adl);
16999
17000 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17001 {
17002 hc_device_param_t *device_param = &data.devices_param[device_id];
17003
17004 if (device_param->skipped) continue;
17005
17006 if (data.hm_device[device_id].od_version == 6)
17007 {
17008 // check powertune capabilities first, if not available then skip device
17009
17010 int powertune_supported = 0;
17011
17012 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17013 {
17014 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17015
17016 return (-1);
17017 }
17018
17019 if (powertune_supported != 0)
17020 {
17021 // powercontrol settings
17022
17023 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)
17024 {
17025 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17026
17027 return (-1);
17028 }
17029
17030 // clocks
17031
17032 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17033
17034 performance_state->iNumberOfPerformanceLevels = 2;
17035
17036 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17037 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17038 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17039 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17040
17041 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)
17042 {
17043 log_info ("ERROR: Failed to restore ADL performance state");
17044
17045 return (-1);
17046 }
17047
17048 local_free (performance_state);
17049 }
17050 }
17051 }
17052
17053 hc_thread_mutex_unlock (mux_adl);
17054 }
17055 #endif // HAVE_ADL
17056
17057 if (gpu_temp_disable == 0)
17058 {
17059 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17060 if (data.hm_nv)
17061 {
17062 #if defined(LINUX) && defined(HAVE_NVML)
17063
17064 hm_NVML_nvmlShutdown (data.hm_nv);
17065
17066 nvml_close (data.hm_nv);
17067
17068 #elif defined(WIN) && (HAVE_NVAPI)
17069
17070 hm_NvAPI_Unload (data.hm_nv);
17071
17072 nvapi_close (data.hm_nv);
17073
17074 #endif
17075
17076 data.hm_nv = NULL;
17077 }
17078 #endif
17079
17080 #ifdef HAVE_ADL
17081 if (data.hm_amd)
17082 {
17083 hm_ADL_Main_Control_Destroy (data.hm_amd);
17084
17085 adl_close (data.hm_amd);
17086 data.hm_amd = NULL;
17087 }
17088 #endif
17089 }
17090 #endif // HAVE_HWMON
17091
17092 // free memory
17093
17094 local_free (masks);
17095
17096 local_free (dictstat_base);
17097
17098 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17099 {
17100 pot_t *pot_ptr = &pot[pot_pos];
17101
17102 hash_t *hash = &pot_ptr->hash;
17103
17104 local_free (hash->digest);
17105
17106 if (isSalted)
17107 {
17108 local_free (hash->salt);
17109 }
17110 }
17111
17112 local_free (pot);
17113
17114 local_free (all_kernel_rules_cnt);
17115 local_free (all_kernel_rules_buf);
17116
17117 local_free (wl_data->buf);
17118 local_free (wl_data);
17119
17120 local_free (bitmap_s1_a);
17121 local_free (bitmap_s1_b);
17122 local_free (bitmap_s1_c);
17123 local_free (bitmap_s1_d);
17124 local_free (bitmap_s2_a);
17125 local_free (bitmap_s2_b);
17126 local_free (bitmap_s2_c);
17127 local_free (bitmap_s2_d);
17128
17129 #ifdef HAVE_HWMON
17130 local_free (temp_retain_fanspeed_value);
17131 #ifdef HAVE_ADL
17132 local_free (od_clock_mem_status);
17133 local_free (od_power_control_status);
17134 #endif // ADL
17135 #endif
17136
17137 global_free (devices_param);
17138
17139 global_free (kernel_rules_buf);
17140
17141 global_free (root_css_buf);
17142 global_free (markov_css_buf);
17143
17144 global_free (digests_buf);
17145 global_free (digests_shown);
17146 global_free (digests_shown_tmp);
17147
17148 global_free (salts_buf);
17149 global_free (salts_shown);
17150
17151 global_free (esalts_buf);
17152
17153 global_free (words_progress_done);
17154 global_free (words_progress_rejected);
17155 global_free (words_progress_restored);
17156
17157 if (pot_fp) fclose (pot_fp);
17158
17159 if (data.devices_status == STATUS_QUIT) break;
17160 }
17161
17162 // destroy others mutex
17163
17164 hc_thread_mutex_delete (mux_dispatcher);
17165 hc_thread_mutex_delete (mux_counter);
17166 hc_thread_mutex_delete (mux_display);
17167 hc_thread_mutex_delete (mux_adl);
17168
17169 // free memory
17170
17171 local_free (eff_restore_file);
17172 local_free (new_restore_file);
17173
17174 local_free (rd);
17175
17176 // tuning db
17177
17178 tuning_db_destroy (tuning_db);
17179
17180 // loopback
17181
17182 local_free (loopback_file);
17183
17184 if (loopback == 1) unlink (loopback_file);
17185
17186 // induction directory
17187
17188 if (induction_dir == NULL)
17189 {
17190 if (attack_mode != ATTACK_MODE_BF)
17191 {
17192 if (rmdir (induction_directory) == -1)
17193 {
17194 if (errno == ENOENT)
17195 {
17196 // good, we can ignore
17197 }
17198 else if (errno == ENOTEMPTY)
17199 {
17200 // good, we can ignore
17201 }
17202 else
17203 {
17204 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17205
17206 return (-1);
17207 }
17208 }
17209
17210 local_free (induction_directory);
17211 }
17212 }
17213
17214 // outfile-check directory
17215
17216 if (outfile_check_dir == NULL)
17217 {
17218 if (rmdir (outfile_check_directory) == -1)
17219 {
17220 if (errno == ENOENT)
17221 {
17222 // good, we can ignore
17223 }
17224 else if (errno == ENOTEMPTY)
17225 {
17226 // good, we can ignore
17227 }
17228 else
17229 {
17230 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17231
17232 return (-1);
17233 }
17234 }
17235
17236 local_free (outfile_check_directory);
17237 }
17238
17239 time_t proc_stop;
17240
17241 time (&proc_stop);
17242
17243 logfile_top_uint (proc_start);
17244 logfile_top_uint (proc_stop);
17245
17246 logfile_top_msg ("STOP");
17247
17248 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17249 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17250
17251 if (data.ocl) ocl_close (data.ocl);
17252
17253 if (data.devices_status == STATUS_ABORTED) return 2;
17254 if (data.devices_status == STATUS_QUIT) return 2;
17255 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17256 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17257 if (data.devices_status == STATUS_CRACKED) return 0;
17258
17259 return -1;
17260 }
Hashcat additions to support pwdhash