projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix final autotune balancing
[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 2
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 HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000, // broken in osx
224 1000,
225 1100,
226 2100,
227 12800,
228 1500, // broken in osx
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700, // broken in osx
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 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);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 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)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 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)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 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);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 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);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.h.hi1[0][j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.h.hi1[0][j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.h.hi1[0][j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.h.hi1[0][j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 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);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 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);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 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)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 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);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 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);
2747
2748 // do something with data
2749
2750 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);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 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);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2780 }
2781 else if (data.attack_kern == ATTACK_KERN_BF)
2782 {
2783 const u64 off = device_param->words_off;
2784
2785 device_param->kernel_params_mp_l_buf64[3] = off;
2786
2787 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2788 }
2789 }
2790
2791 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2792 {
2793 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2794
2795 device_param->kernel_params_buf32[26] = kernel_loops;
2796 device_param->kernel_params_buf32[27] = kernel_loops;
2797
2798 // init some fake words
2799
2800 if (data.attack_kern == ATTACK_KERN_BF)
2801 {
2802 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2803 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2804 }
2805 else
2806 {
2807 for (u32 i = 0; i < kernel_power; i++)
2808 {
2809 device_param->pws_buf[i].pw_len = i & 7;
2810 }
2811
2812 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);
2813
2814 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2815 {
2816 run_kernel_amp (device_param, kernel_power);
2817 }
2818 }
2819
2820 // caching run
2821
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2829 }
2830
2831 // now user repeats
2832
2833 for (int i = 0; i < repeat; i++)
2834 {
2835 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2836 {
2837 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2838 }
2839 else
2840 {
2841 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2842 }
2843 }
2844
2845 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2846
2847 // reset fake words
2848
2849 run_kernel_bzero (device_param, device_param->d_pws_buf, device_param->size_pws);
2850 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, device_param->size_pws);
2851
2852 return exec_ms_prev;
2853 }
2854
2855 static void autotune (hc_device_param_t *device_param)
2856 {
2857 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2858
2859 u32 kernel_loops_min = device_param->kernel_loops_min;
2860 u32 kernel_loops_max = device_param->kernel_loops_max;
2861
2862 u32 kernel_accel_min = device_param->kernel_accel_min;
2863 u32 kernel_accel_max = device_param->kernel_accel_max;
2864
2865 u32 kernel_loops = kernel_loops_min;
2866 u32 kernel_accel = kernel_accel_min;
2867
2868 // steps for loops
2869
2870 #define STEPS_LOOPS_CNT 15
2871
2872 u32 steps_loops[STEPS_LOOPS_CNT];
2873
2874 steps_loops[ 0] = 1;
2875 steps_loops[ 1] = 2;
2876 steps_loops[ 2] = 4;
2877 steps_loops[ 3] = 8;
2878 steps_loops[ 4] = 16;
2879 steps_loops[ 5] = 32;
2880 steps_loops[ 6] = 64;
2881 steps_loops[ 7] = 100;
2882 steps_loops[ 8] = 128;
2883 steps_loops[ 9] = 200;
2884 steps_loops[10] = 256;
2885 steps_loops[11] = 500;
2886 steps_loops[12] = 512;
2887 steps_loops[13] = 1000;
2888 steps_loops[14] = 1024;
2889
2890 // steps for accel
2891
2892 #define STEPS_ACCEL_CNT 13
2893
2894 u32 steps_accel[STEPS_ACCEL_CNT];
2895
2896 steps_accel[ 0] = 1;
2897 steps_accel[ 1] = 2;
2898 steps_accel[ 2] = 4;
2899 steps_accel[ 3] = 8;
2900 steps_accel[ 4] = 16;
2901 steps_accel[ 5] = 32;
2902 steps_accel[ 6] = 64;
2903 steps_accel[ 7] = 128;
2904 steps_accel[ 8] = 256;
2905 steps_accel[ 9] = 384;
2906 steps_accel[10] = 512;
2907 steps_accel[11] = 768;
2908 steps_accel[12] = 1024;
2909
2910 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2911
2912 u32 kernel_loops_tmp;
2913
2914 for (kernel_loops_tmp = MIN (kernel_loops_max, 200); kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2915 {
2916 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2917
2918 if (exec_ms < target_ms) break;
2919
2920 if (kernel_loops_tmp == kernel_loops_min) break;
2921 }
2922
2923 // kernel-accel
2924
2925 double e_best = 0;
2926
2927 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2928 {
2929 const u32 kernel_accel_try = steps_accel[i];
2930
2931 if (kernel_accel_try < kernel_accel_min) continue;
2932 if (kernel_accel_try > kernel_accel_max) break;
2933
2934 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2935
2936 if (exec_ms > target_ms) break;
2937
2938 const double e = kernel_accel_try / exec_ms;
2939
2940 if (e > e_best)
2941 {
2942 kernel_accel = kernel_accel_try;
2943
2944 e_best = e;
2945 }
2946 }
2947
2948 // kernel-loops final
2949
2950 e_best = 0;
2951
2952 for (int i = 0; i < STEPS_LOOPS_CNT - 1; i++)
2953 {
2954 const u32 kernel_loops_try = steps_loops[i];
2955
2956 if (kernel_loops_try < kernel_loops_min) continue;
2957 if (kernel_loops_try > kernel_loops_max) break;
2958
2959 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2960
2961 if (exec_ms > target_ms) break;
2962
2963 const double e = kernel_loops_try / exec_ms;
2964
2965 if (e > e_best)
2966 {
2967 kernel_loops = kernel_loops_try;
2968
2969 e_best = e;
2970 }
2971 }
2972
2973 // final balance
2974
2975 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2976
2977 u32 kernel_accel_best = kernel_accel;
2978 u32 kernel_loops_best = kernel_loops;
2979
2980 u32 exec_best = exec_ms;
2981
2982 // reset
2983
2984 u32 kernel_accel_try = kernel_accel;
2985 u32 kernel_loops_try = kernel_loops;
2986
2987 for (int i = 0; i < 2; i++)
2988 {
2989 kernel_accel_try >>= 1;
2990 kernel_loops_try <<= 1;
2991
2992 if (kernel_accel_try < kernel_accel_min) break;
2993 if (kernel_loops_try > kernel_loops_max) break;
2994
2995 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2996
2997 if (exec_ms < exec_best)
2998 {
2999 kernel_accel_best = kernel_accel_try;
3000 kernel_loops_best = kernel_loops_try;
3001
3002 exec_best = exec_ms;
3003 }
3004 }
3005
3006 // reset
3007
3008 kernel_accel_try = kernel_accel;
3009 kernel_loops_try = kernel_loops;
3010
3011 for (int i = 0; i < 2; i++)
3012 {
3013 kernel_accel_try <<= 1;
3014 kernel_loops_try >>= 1;
3015
3016 if (kernel_accel_try > kernel_accel_max) break;
3017 if (kernel_loops_try < kernel_loops_min) break;
3018
3019 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3020
3021 if (exec_ms < exec_best)
3022 {
3023 kernel_accel_best = kernel_accel_try;
3024 kernel_loops_best = kernel_loops_try;
3025
3026 exec_best = exec_ms;
3027 }
3028 }
3029
3030 kernel_accel = kernel_accel_best;
3031 kernel_loops = kernel_loops_best;
3032
3033 // reset timer
3034
3035 device_param->exec_pos = 0;
3036
3037 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3038
3039 // store
3040
3041 device_param->kernel_loops = kernel_loops;
3042 device_param->kernel_accel = kernel_accel;
3043
3044 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3045
3046 device_param->kernel_power = kernel_power;
3047
3048 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3049 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3050 log_info ("");
3051 }
3052
3053 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
3054 {
3055 // init speed timer
3056
3057 uint speed_pos = device_param->speed_pos;
3058
3059 #ifdef _POSIX
3060 if (device_param->timer_speed.tv_sec == 0)
3061 {
3062 hc_timer_set (&device_param->timer_speed);
3063 }
3064 #endif
3065
3066 #ifdef _WIN
3067 if (device_param->timer_speed.QuadPart == 0)
3068 {
3069 hc_timer_set (&device_param->timer_speed);
3070 }
3071 #endif
3072
3073 // find higest password length, this is for optimization stuff
3074
3075 uint highest_pw_len = 0;
3076
3077 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3078 {
3079 }
3080 else if (data.attack_kern == ATTACK_KERN_COMBI)
3081 {
3082 }
3083 else if (data.attack_kern == ATTACK_KERN_BF)
3084 {
3085 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3086 + device_param->kernel_params_mp_l_buf32[5];
3087 }
3088
3089 // bitslice optimization stuff
3090
3091 if (data.attack_mode == ATTACK_MODE_BF)
3092 {
3093 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3094 {
3095 run_kernel_tb (device_param, pws_cnt);
3096 }
3097 }
3098
3099 // iteration type
3100
3101 uint innerloop_step = 0;
3102 uint innerloop_cnt = 0;
3103
3104 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3105 else innerloop_step = 1;
3106
3107 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3109 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3110
3111 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3112
3113 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3114 {
3115 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3116
3117 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3118
3119 if (data.devices_status == STATUS_CRACKED) break;
3120 if (data.devices_status == STATUS_ABORTED) break;
3121 if (data.devices_status == STATUS_QUIT) break;
3122 if (data.devices_status == STATUS_BYPASS) break;
3123
3124 if (data.salts_shown[salt_pos] == 1) continue;
3125
3126 salt_t *salt_buf = &data.salts_buf[salt_pos];
3127
3128 device_param->kernel_params_buf32[24] = salt_pos;
3129 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3130 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3131
3132 FILE *combs_fp = device_param->combs_fp;
3133
3134 if (data.attack_mode == ATTACK_MODE_COMBI)
3135 {
3136 rewind (combs_fp);
3137 }
3138
3139 // innerloops
3140
3141 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3142 {
3143 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3144
3145 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3146
3147 if (data.devices_status == STATUS_CRACKED) break;
3148 if (data.devices_status == STATUS_ABORTED) break;
3149 if (data.devices_status == STATUS_QUIT) break;
3150 if (data.devices_status == STATUS_BYPASS) break;
3151
3152 uint innerloop_left = innerloop_cnt - innerloop_pos;
3153
3154 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3155
3156 device_param->innerloop_pos = innerloop_pos;
3157 device_param->innerloop_left = innerloop_left;
3158
3159 device_param->kernel_params_buf32[27] = innerloop_left;
3160
3161 // i think we can get rid of this
3162 if (innerloop_left == 0)
3163 {
3164 puts ("bug, how should this happen????\n");
3165
3166 continue;
3167 }
3168
3169 // initialize amplifiers
3170
3171 if (data.attack_mode == ATTACK_MODE_COMBI)
3172 {
3173 char line_buf[BUFSIZ] = { 0 };
3174
3175 uint i = 0;
3176
3177 while (i < innerloop_left)
3178 {
3179 if (feof (combs_fp)) break;
3180
3181 int line_len = fgetl (combs_fp, line_buf);
3182
3183 if (line_len >= PW_MAX1) continue;
3184
3185 line_len = convert_from_hex (line_buf, line_len);
3186
3187 char *line_buf_new = line_buf;
3188
3189 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3190 {
3191 char rule_buf_out[BLOCK_SIZE] = { 0 };
3192
3193 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3194
3195 if (rule_len_out < 0)
3196 {
3197 data.words_progress_rejected[salt_pos] += pw_cnt;
3198
3199 continue;
3200 }
3201
3202 line_len = rule_len_out;
3203
3204 line_buf_new = rule_buf_out;
3205 }
3206
3207 line_len = MIN (line_len, PW_DICTMAX);
3208
3209 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3210
3211 memcpy (ptr, line_buf_new, line_len);
3212
3213 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3214
3215 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3216 {
3217 uppercase (ptr, line_len);
3218 }
3219
3220 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3221 {
3222 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3223 {
3224 ptr[line_len] = 0x80;
3225 }
3226
3227 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3228 {
3229 ptr[line_len] = 0x01;
3230 }
3231 }
3232
3233 device_param->combs_buf[i].pw_len = line_len;
3234
3235 i++;
3236 }
3237
3238 for (uint j = i; j < innerloop_left; j++)
3239 {
3240 device_param->combs_buf[j].i[0] = 0;
3241 device_param->combs_buf[j].i[1] = 0;
3242 device_param->combs_buf[j].i[2] = 0;
3243 device_param->combs_buf[j].i[3] = 0;
3244 device_param->combs_buf[j].i[4] = 0;
3245 device_param->combs_buf[j].i[5] = 0;
3246 device_param->combs_buf[j].i[6] = 0;
3247 device_param->combs_buf[j].i[7] = 0;
3248
3249 device_param->combs_buf[j].pw_len = 0;
3250 }
3251
3252 innerloop_left = i;
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_BF)
3255 {
3256 u64 off = innerloop_pos;
3257
3258 device_param->kernel_params_mp_r_buf64[3] = off;
3259
3260 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3261 }
3262 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3263 {
3264 u64 off = innerloop_pos;
3265
3266 device_param->kernel_params_mp_buf64[3] = off;
3267
3268 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3269 }
3270 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3271 {
3272 u64 off = innerloop_pos;
3273
3274 device_param->kernel_params_mp_buf64[3] = off;
3275
3276 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3277 }
3278
3279 // copy amplifiers
3280
3281 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3282 {
3283 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);
3284 }
3285 else if (data.attack_mode == ATTACK_MODE_COMBI)
3286 {
3287 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);
3288 }
3289 else if (data.attack_mode == ATTACK_MODE_BF)
3290 {
3291 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);
3292 }
3293 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3294 {
3295 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);
3296 }
3297 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3298 {
3299 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);
3300 }
3301
3302 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3303
3304 if (data.benchmark == 1)
3305 {
3306 for (u32 i = 0; i < data.benchmark_repeats; i++)
3307 {
3308 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3309 }
3310 }
3311
3312 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3313
3314 if (data.devices_status == STATUS_CRACKED) break;
3315 if (data.devices_status == STATUS_ABORTED) break;
3316 if (data.devices_status == STATUS_QUIT) break;
3317
3318 /**
3319 * result
3320 */
3321
3322 hc_thread_mutex_lock (mux_display);
3323
3324 check_cracked (device_param, salt_pos);
3325
3326 hc_thread_mutex_unlock (mux_display);
3327
3328 /**
3329 * progress
3330 */
3331
3332 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3333
3334 if (data.benchmark == 1)
3335 {
3336 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3337 }
3338
3339 hc_thread_mutex_lock (mux_counter);
3340
3341 data.words_progress_done[salt_pos] += perf_sum_all;
3342
3343 hc_thread_mutex_unlock (mux_counter);
3344
3345 /**
3346 * speed
3347 */
3348
3349 float speed_ms;
3350
3351 hc_timer_get (device_param->timer_speed, speed_ms);
3352
3353 hc_timer_set (&device_param->timer_speed);
3354
3355 hc_thread_mutex_lock (mux_display);
3356
3357 device_param->speed_cnt[speed_pos] = perf_sum_all;
3358
3359 device_param->speed_ms[speed_pos] = speed_ms;
3360
3361 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3362
3363 hc_thread_mutex_unlock (mux_display);
3364
3365 speed_pos++;
3366
3367 if (speed_pos == SPEED_CACHE)
3368 {
3369 speed_pos = 0;
3370 }
3371
3372 /**
3373 * benchmark
3374 */
3375
3376 if (data.benchmark == 1) break;
3377 }
3378 }
3379
3380 device_param->speed_pos = speed_pos;
3381 }
3382
3383 static void load_segment (wl_data_t *wl_data, FILE *fd)
3384 {
3385 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3386
3387 wl_data->pos = 0;
3388
3389 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3390
3391 wl_data->buf[wl_data->cnt] = 0;
3392
3393 if (wl_data->cnt == 0) return;
3394
3395 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3396
3397 while (!feof (fd))
3398 {
3399 if (wl_data->cnt == wl_data->avail)
3400 {
3401 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3402
3403 wl_data->avail += wl_data->incr;
3404 }
3405
3406 const int c = fgetc (fd);
3407
3408 if (c == EOF) break;
3409
3410 wl_data->buf[wl_data->cnt] = (char) c;
3411
3412 wl_data->cnt++;
3413
3414 if (c == '\n') break;
3415 }
3416
3417 // ensure stream ends with a newline
3418
3419 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3420 {
3421 wl_data->cnt++;
3422
3423 wl_data->buf[wl_data->cnt - 1] = '\n';
3424 }
3425
3426 return;
3427 }
3428
3429 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3430 {
3431 char *ptr = buf;
3432
3433 for (u32 i = 0; i < sz; i++, ptr++)
3434 {
3435 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3436
3437 if (i == 7)
3438 {
3439 *off = i;
3440 *len = i;
3441
3442 return;
3443 }
3444
3445 if (*ptr != '\n') continue;
3446
3447 *off = i + 1;
3448
3449 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3450
3451 *len = i;
3452
3453 return;
3454 }
3455
3456 *off = sz;
3457 *len = sz;
3458 }
3459
3460 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3461 {
3462 char *ptr = buf;
3463
3464 for (u32 i = 0; i < sz; i++, ptr++)
3465 {
3466 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
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_std (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 != '\n') continue;
3490
3491 *off = i + 1;
3492
3493 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3494
3495 *len = i;
3496
3497 return;
3498 }
3499
3500 *off = sz;
3501 *len = sz;
3502 }
3503
3504 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3505 {
3506 while (wl_data->pos < wl_data->cnt)
3507 {
3508 uint off;
3509 uint len;
3510
3511 char *ptr = wl_data->buf + wl_data->pos;
3512
3513 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3514
3515 wl_data->pos += off;
3516
3517 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3518 {
3519 char rule_buf_out[BLOCK_SIZE] = { 0 };
3520
3521 int rule_len_out = -1;
3522
3523 if (len < BLOCK_SIZE)
3524 {
3525 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3526 }
3527
3528 if (rule_len_out < 0)
3529 {
3530 continue;
3531 }
3532
3533 if (rule_len_out > PW_MAX)
3534 {
3535 continue;
3536 }
3537 }
3538 else
3539 {
3540 if (len > PW_MAX)
3541 {
3542 continue;
3543 }
3544 }
3545
3546 *out_buf = ptr;
3547 *out_len = len;
3548
3549 return;
3550 }
3551
3552 if (feof (fd))
3553 {
3554 fprintf (stderr, "bug!!\n");
3555
3556 return;
3557 }
3558
3559 load_segment (wl_data, fd);
3560
3561 get_next_word (wl_data, fd, out_buf, out_len);
3562 }
3563
3564 #ifdef _POSIX
3565 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3566 #endif
3567
3568 #ifdef _WIN
3569 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3570 #endif
3571 {
3572 hc_signal (NULL);
3573
3574 dictstat_t d;
3575
3576 d.cnt = 0;
3577
3578 #ifdef _POSIX
3579 fstat (fileno (fd), &d.stat);
3580 #endif
3581
3582 #ifdef _WIN
3583 _fstat64 (fileno (fd), &d.stat);
3584 #endif
3585
3586 d.stat.st_mode = 0;
3587 d.stat.st_nlink = 0;
3588 d.stat.st_uid = 0;
3589 d.stat.st_gid = 0;
3590 d.stat.st_rdev = 0;
3591 d.stat.st_atime = 0;
3592
3593 #ifdef _POSIX
3594 d.stat.st_blksize = 0;
3595 d.stat.st_blocks = 0;
3596 #endif
3597
3598 if (d.stat.st_size == 0) return 0;
3599
3600 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3601
3602 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3603 {
3604 if (d_cache)
3605 {
3606 u64 cnt = d_cache->cnt;
3607
3608 u64 keyspace = cnt;
3609
3610 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3611 {
3612 keyspace *= data.kernel_rules_cnt;
3613 }
3614 else if (data.attack_kern == ATTACK_KERN_COMBI)
3615 {
3616 keyspace *= data.combs_cnt;
3617 }
3618
3619 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);
3620 if (data.quiet == 0) log_info ("");
3621
3622 hc_signal (sigHandler_default);
3623
3624 return (keyspace);
3625 }
3626 }
3627
3628 time_t now = 0;
3629 time_t prev = 0;
3630
3631 u64 comp = 0;
3632 u64 cnt = 0;
3633 u64 cnt2 = 0;
3634
3635 while (!feof (fd))
3636 {
3637 load_segment (wl_data, fd);
3638
3639 comp += wl_data->cnt;
3640
3641 u32 i = 0;
3642
3643 while (i < wl_data->cnt)
3644 {
3645 u32 len;
3646 u32 off;
3647
3648 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3649
3650 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3651 {
3652 char rule_buf_out[BLOCK_SIZE] = { 0 };
3653
3654 int rule_len_out = -1;
3655
3656 if (len < BLOCK_SIZE)
3657 {
3658 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3659 }
3660
3661 if (rule_len_out < 0)
3662 {
3663 len = PW_MAX1;
3664 }
3665 else
3666 {
3667 len = rule_len_out;
3668 }
3669 }
3670
3671 if (len < PW_MAX1)
3672 {
3673 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3674 {
3675 cnt += data.kernel_rules_cnt;
3676 }
3677 else if (data.attack_kern == ATTACK_KERN_COMBI)
3678 {
3679 cnt += data.combs_cnt;
3680 }
3681
3682 d.cnt++;
3683 }
3684
3685 i += off;
3686
3687 cnt2++;
3688 }
3689
3690 time (&now);
3691
3692 if ((now - prev) == 0) continue;
3693
3694 float percent = (float) comp / (float) d.stat.st_size;
3695
3696 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);
3697
3698 time (&prev);
3699 }
3700
3701 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);
3702 if (data.quiet == 0) log_info ("");
3703
3704 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3705
3706 hc_signal (sigHandler_default);
3707
3708 return (cnt);
3709 }
3710
3711 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3712 {
3713 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3714 }
3715
3716 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3717 {
3718 if (data.devices_status == STATUS_BYPASS) return 0;
3719
3720 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3721
3722 uint cache_cnt = pw_cache->cnt;
3723
3724 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3725
3726 memcpy (pw_hc1, pw_buf, pw_len);
3727
3728 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3729
3730 uint pws_cnt = device_param->pws_cnt;
3731
3732 cache_cnt++;
3733
3734 pw_t *pw = device_param->pws_buf + pws_cnt;
3735
3736 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3737
3738 pw->pw_len = pw_len;
3739
3740 pws_cnt++;
3741
3742 device_param->pws_cnt = pws_cnt;
3743 device_param->pw_cnt = pws_cnt * 1;
3744
3745 cache_cnt = 0;
3746
3747 pw_cache->cnt = cache_cnt;
3748
3749 return pws_cnt;
3750 }
3751
3752 static void *thread_monitor (void *p)
3753 {
3754 uint runtime_check = 0;
3755 uint remove_check = 0;
3756 uint status_check = 0;
3757 uint restore_check = 0;
3758
3759 uint restore_left = data.restore_timer;
3760 uint remove_left = data.remove_timer;
3761 uint status_left = data.status_timer;
3762
3763 #ifdef HAVE_HWMON
3764 uint hwmon_check = 0;
3765
3766 // these variables are mainly used for fan control (AMD only)
3767
3768 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3769
3770 // temperature controller "loopback" values
3771
3772 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3773 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3774
3775 #ifdef HAVE_ADL
3776 int temp_threshold = 1; // degrees celcius
3777
3778 int fan_speed_min = 15; // in percentage
3779 int fan_speed_max = 100;
3780 #endif // HAVE_ADL
3781
3782 time_t last_temp_check_time;
3783 #endif // HAVE_HWMON
3784
3785 uint sleep_time = 1;
3786
3787 if (data.runtime)
3788 {
3789 runtime_check = 1;
3790 }
3791
3792 if (data.restore_timer)
3793 {
3794 restore_check = 1;
3795 }
3796
3797 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3798 {
3799 remove_check = 1;
3800 }
3801
3802 if (data.status == 1)
3803 {
3804 status_check = 1;
3805 }
3806
3807 #ifdef HAVE_HWMON
3808 if (data.gpu_temp_disable == 0)
3809 {
3810 time (&last_temp_check_time);
3811
3812 hwmon_check = 1;
3813 }
3814 #endif
3815
3816 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3817 {
3818 #ifdef HAVE_HWMON
3819 if (hwmon_check == 0)
3820 #endif
3821 return (p);
3822 }
3823
3824 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3825 {
3826 hc_sleep (sleep_time);
3827
3828 if (data.devices_status != STATUS_RUNNING) continue;
3829
3830 #ifdef HAVE_HWMON
3831 if (hwmon_check == 1)
3832 {
3833 hc_thread_mutex_lock (mux_adl);
3834
3835 time_t temp_check_time;
3836
3837 time (&temp_check_time);
3838
3839 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3840
3841 if (Ta == 0) Ta = 1;
3842
3843 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3844 {
3845 hc_device_param_t *device_param = &data.devices_param[device_id];
3846
3847 if (device_param->skipped) continue;
3848
3849 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3850
3851 const int temperature = hm_get_temperature_with_device_id (device_id);
3852
3853 if (temperature > (int) data.gpu_temp_abort)
3854 {
3855 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3856
3857 if (data.devices_status != STATUS_QUIT) myabort ();
3858
3859 break;
3860 }
3861
3862 #ifdef HAVE_ADL
3863 const int gpu_temp_retain = data.gpu_temp_retain;
3864
3865 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3866 {
3867 if (data.hm_device[device_id].fan_supported == 1)
3868 {
3869 int temp_cur = temperature;
3870
3871 int temp_diff_new = gpu_temp_retain - temp_cur;
3872
3873 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3874
3875 // calculate Ta value (time difference in seconds between the last check and this check)
3876
3877 last_temp_check_time = temp_check_time;
3878
3879 float Kp = 1.8;
3880 float Ki = 0.005;
3881 float Kd = 6;
3882
3883 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3884
3885 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);
3886
3887 if (abs (fan_diff_required) >= temp_threshold)
3888 {
3889 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3890
3891 int fan_speed_level = fan_speed_cur;
3892
3893 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3894
3895 int fan_speed_new = fan_speed_level - fan_diff_required;
3896
3897 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3898 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3899
3900 if (fan_speed_new != fan_speed_cur)
3901 {
3902 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3903 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3904
3905 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3906 {
3907 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3908
3909 fan_speed_chgd[device_id] = 1;
3910 }
3911
3912 temp_diff_old[device_id] = temp_diff_new;
3913 }
3914 }
3915 }
3916 }
3917 #endif // HAVE_ADL
3918 }
3919
3920 hc_thread_mutex_unlock (mux_adl);
3921 }
3922 #endif // HAVE_HWMON
3923
3924 if (restore_check == 1)
3925 {
3926 restore_left--;
3927
3928 if (restore_left == 0)
3929 {
3930 if (data.restore_disable == 0) cycle_restore ();
3931
3932 restore_left = data.restore_timer;
3933 }
3934 }
3935
3936 if ((runtime_check == 1) && (data.runtime_start > 0))
3937 {
3938 time_t runtime_cur;
3939
3940 time (&runtime_cur);
3941
3942 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3943
3944 if (runtime_left <= 0)
3945 {
3946 if (data.benchmark == 0)
3947 {
3948 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3949 }
3950
3951 if (data.devices_status != STATUS_QUIT) myabort ();
3952 }
3953 }
3954
3955 if (remove_check == 1)
3956 {
3957 remove_left--;
3958
3959 if (remove_left == 0)
3960 {
3961 if (data.digests_saved != data.digests_done)
3962 {
3963 data.digests_saved = data.digests_done;
3964
3965 save_hash ();
3966 }
3967
3968 remove_left = data.remove_timer;
3969 }
3970 }
3971
3972 if (status_check == 1)
3973 {
3974 status_left--;
3975
3976 if (status_left == 0)
3977 {
3978 hc_thread_mutex_lock (mux_display);
3979
3980 if (data.quiet == 0) clear_prompt ();
3981
3982 if (data.quiet == 0) log_info ("");
3983
3984 status_display ();
3985
3986 if (data.quiet == 0) log_info ("");
3987
3988 hc_thread_mutex_unlock (mux_display);
3989
3990 status_left = data.status_timer;
3991 }
3992 }
3993 }
3994
3995 #ifdef HAVE_HWMON
3996 myfree (fan_speed_chgd);
3997
3998 myfree (temp_diff_old);
3999 myfree (temp_diff_sum);
4000 #endif
4001
4002 p = NULL;
4003
4004 return (p);
4005 }
4006
4007 static void *thread_outfile_remove (void *p)
4008 {
4009 // some hash-dependent constants
4010 char *outfile_dir = data.outfile_check_directory;
4011 uint dgst_size = data.dgst_size;
4012 uint isSalted = data.isSalted;
4013 uint esalt_size = data.esalt_size;
4014 uint hash_mode = data.hash_mode;
4015
4016 uint outfile_check_timer = data.outfile_check_timer;
4017
4018 char separator = data.separator;
4019
4020 // some hash-dependent functions
4021 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4022 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4023
4024 // buffers
4025 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4026
4027 hash_buf.digest = mymalloc (dgst_size);
4028
4029 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4030
4031 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4032
4033 uint digest_buf[64] = { 0 };
4034
4035 outfile_data_t *out_info = NULL;
4036
4037 char **out_files = NULL;
4038
4039 time_t folder_mtime = 0;
4040
4041 int out_cnt = 0;
4042
4043 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4044
4045 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4046 {
4047 hc_sleep (1);
4048
4049 if (data.devices_status != STATUS_RUNNING) continue;
4050
4051 check_left--;
4052
4053 if (check_left == 0)
4054 {
4055 struct stat outfile_check_stat;
4056
4057 if (stat (outfile_dir, &outfile_check_stat) == 0)
4058 {
4059 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4060
4061 if (is_dir == 1)
4062 {
4063 if (outfile_check_stat.st_mtime > folder_mtime)
4064 {
4065 char **out_files_new = scan_directory (outfile_dir);
4066
4067 int out_cnt_new = count_dictionaries (out_files_new);
4068
4069 outfile_data_t *out_info_new = NULL;
4070
4071 if (out_cnt_new > 0)
4072 {
4073 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4074
4075 for (int i = 0; i < out_cnt_new; i++)
4076 {
4077 out_info_new[i].file_name = out_files_new[i];
4078
4079 // check if there are files that we have seen/checked before (and not changed)
4080
4081 for (int j = 0; j < out_cnt; j++)
4082 {
4083 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4084 {
4085 struct stat outfile_stat;
4086
4087 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4088 {
4089 if (outfile_stat.st_ctime == out_info[j].ctime)
4090 {
4091 out_info_new[i].ctime = out_info[j].ctime;
4092 out_info_new[i].seek = out_info[j].seek;
4093 }
4094 }
4095 }
4096 }
4097 }
4098 }
4099
4100 local_free (out_info);
4101 local_free (out_files);
4102
4103 out_files = out_files_new;
4104 out_cnt = out_cnt_new;
4105 out_info = out_info_new;
4106
4107 folder_mtime = outfile_check_stat.st_mtime;
4108 }
4109
4110 for (int j = 0; j < out_cnt; j++)
4111 {
4112 FILE *fp = fopen (out_info[j].file_name, "rb");
4113
4114 if (fp != NULL)
4115 {
4116 //hc_thread_mutex_lock (mux_display);
4117
4118 #ifdef _POSIX
4119 struct stat outfile_stat;
4120
4121 fstat (fileno (fp), &outfile_stat);
4122 #endif
4123
4124 #ifdef _WIN
4125 struct stat64 outfile_stat;
4126
4127 _fstat64 (fileno (fp), &outfile_stat);
4128 #endif
4129
4130 if (outfile_stat.st_ctime > out_info[j].ctime)
4131 {
4132 out_info[j].ctime = outfile_stat.st_ctime;
4133 out_info[j].seek = 0;
4134 }
4135
4136 fseek (fp, out_info[j].seek, SEEK_SET);
4137
4138 while (!feof (fp))
4139 {
4140 char line_buf[BUFSIZ] = { 0 };
4141
4142 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4143
4144 if (ptr == NULL) break;
4145
4146 int line_len = strlen (line_buf);
4147
4148 if (line_len <= 0) continue;
4149
4150 int iter = MAX_CUT_TRIES;
4151
4152 for (uint i = line_len - 1; i && iter; i--, line_len--)
4153 {
4154 if (line_buf[i] != separator) continue;
4155
4156 int parser_status = PARSER_OK;
4157
4158 if ((hash_mode != 2500) && (hash_mode != 6800))
4159 {
4160 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4161 }
4162
4163 uint found = 0;
4164
4165 if (parser_status == PARSER_OK)
4166 {
4167 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4168 {
4169 if (data.salts_shown[salt_pos] == 1) continue;
4170
4171 salt_t *salt_buf = &data.salts_buf[salt_pos];
4172
4173 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4174 {
4175 uint idx = salt_buf->digests_offset + digest_pos;
4176
4177 if (data.digests_shown[idx] == 1) continue;
4178
4179 uint cracked = 0;
4180
4181 if (hash_mode == 6800)
4182 {
4183 if (i == salt_buf->salt_len)
4184 {
4185 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4186 }
4187 }
4188 else if (hash_mode == 2500)
4189 {
4190 // BSSID : MAC1 : MAC2 (:plain)
4191 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4192 {
4193 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4194
4195 if (!cracked) continue;
4196
4197 // now compare MAC1 and MAC2 too, since we have this additional info
4198 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4199 char *mac2_pos = mac1_pos + 12 + 1;
4200
4201 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4202 wpa_t *wpa = &wpas[salt_pos];
4203
4204 uint pke[25] = { 0 };
4205
4206 char *pke_ptr = (char *) pke;
4207
4208 for (uint i = 0; i < 25; i++)
4209 {
4210 pke[i] = byte_swap_32 (wpa->pke[i]);
4211 }
4212
4213 u8 mac1[6] = { 0 };
4214 u8 mac2[6] = { 0 };
4215
4216 memcpy (mac1, pke_ptr + 23, 6);
4217 memcpy (mac2, pke_ptr + 29, 6);
4218
4219 // compare hex string(s) vs binary MAC address(es)
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4224 {
4225 cracked = 0;
4226 break;
4227 }
4228 }
4229
4230 // early skip ;)
4231 if (!cracked) continue;
4232
4233 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4234 {
4235 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4236 {
4237 cracked = 0;
4238 break;
4239 }
4240 }
4241 }
4242 }
4243 else
4244 {
4245 char *digests_buf_ptr = (char *) data.digests_buf;
4246
4247 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4248
4249 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4250 }
4251
4252 if (cracked == 1)
4253 {
4254 found = 1;
4255
4256 data.digests_shown[idx] = 1;
4257
4258 data.digests_done++;
4259
4260 salt_buf->digests_done++;
4261
4262 if (salt_buf->digests_done == salt_buf->digests_cnt)
4263 {
4264 data.salts_shown[salt_pos] = 1;
4265
4266 data.salts_done++;
4267
4268 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4269 }
4270 }
4271 }
4272
4273 if (data.devices_status == STATUS_CRACKED) break;
4274 }
4275 }
4276
4277 if (found) break;
4278
4279 if (data.devices_status == STATUS_CRACKED) break;
4280
4281 iter--;
4282 }
4283
4284 if (data.devices_status == STATUS_CRACKED) break;
4285 }
4286
4287 out_info[j].seek = ftell (fp);
4288
4289 //hc_thread_mutex_unlock (mux_display);
4290
4291 fclose (fp);
4292 }
4293 }
4294 }
4295 }
4296
4297 check_left = outfile_check_timer;
4298 }
4299 }
4300
4301 if (esalt_size) local_free (hash_buf.esalt);
4302
4303 if (isSalted) local_free (hash_buf.salt);
4304
4305 local_free (hash_buf.digest);
4306
4307 local_free (out_info);
4308
4309 local_free (out_files);
4310
4311 p = NULL;
4312
4313 return (p);
4314 }
4315
4316 static uint get_work (hc_device_param_t *device_param, const u64 max)
4317 {
4318 hc_thread_mutex_lock (mux_dispatcher);
4319
4320 const u64 words_cur = data.words_cur;
4321 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4322
4323 device_param->words_off = words_cur;
4324
4325 const u64 words_left = words_base - words_cur;
4326
4327 if (data.kernel_power_all > words_left)
4328 {
4329 if (data.kernel_power_div == 0)
4330 {
4331 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4332 }
4333 }
4334
4335 if (data.kernel_power_div)
4336 {
4337 if (device_param->kernel_power == device_param->kernel_power_user)
4338 {
4339 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4340
4341 if (kernel_power_new < device_param->kernel_power)
4342 {
4343 device_param->kernel_power = kernel_power_new;
4344 }
4345 }
4346 }
4347
4348 const uint kernel_power = device_param->kernel_power;
4349
4350 uint work = MIN (words_left, kernel_power);
4351
4352 work = MIN (work, max);
4353
4354 data.words_cur += work;
4355
4356 hc_thread_mutex_unlock (mux_dispatcher);
4357
4358 return work;
4359 }
4360
4361 static void *thread_calc_stdin (void *p)
4362 {
4363 hc_device_param_t *device_param = (hc_device_param_t *) p;
4364
4365 if (device_param->skipped) return NULL;
4366
4367 const bool run_autotune = ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0));
4368
4369 if (run_autotune)
4370 {
4371 autotune (device_param);
4372 }
4373
4374 const uint attack_kern = data.attack_kern;
4375
4376 const uint kernel_power = device_param->kernel_power;
4377
4378 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4379 {
4380 hc_thread_mutex_lock (mux_dispatcher);
4381
4382 if (feof (stdin) != 0)
4383 {
4384 hc_thread_mutex_unlock (mux_dispatcher);
4385
4386 break;
4387 }
4388
4389 uint words_cur = 0;
4390
4391 while (words_cur < kernel_power)
4392 {
4393 char buf[BUFSIZ] = { 0 };
4394
4395 char *line_buf = fgets (buf, sizeof (buf), stdin);
4396
4397 if (line_buf == NULL) break;
4398
4399 uint line_len = in_superchop (line_buf);
4400
4401 line_len = convert_from_hex (line_buf, line_len);
4402
4403 // post-process rule engine
4404
4405 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4406 {
4407 char rule_buf_out[BLOCK_SIZE] = { 0 };
4408
4409 int rule_len_out = -1;
4410
4411 if (line_len < BLOCK_SIZE)
4412 {
4413 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4414 }
4415
4416 if (rule_len_out < 0) continue;
4417
4418 line_buf = rule_buf_out;
4419 line_len = rule_len_out;
4420 }
4421
4422 if (line_len > PW_MAX)
4423 {
4424 continue;
4425 }
4426
4427 if (attack_kern == ATTACK_KERN_STRAIGHT)
4428 {
4429 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4430 {
4431 hc_thread_mutex_lock (mux_counter);
4432
4433 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4434 {
4435 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4436 }
4437
4438 hc_thread_mutex_unlock (mux_counter);
4439
4440 continue;
4441 }
4442 }
4443 else if (attack_kern == ATTACK_KERN_COMBI)
4444 {
4445 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4446 // since we still need to combine the plains
4447
4448 if (line_len > data.pw_max)
4449 {
4450 hc_thread_mutex_lock (mux_counter);
4451
4452 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4453 {
4454 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4455 }
4456
4457 hc_thread_mutex_unlock (mux_counter);
4458
4459 continue;
4460 }
4461 }
4462
4463 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4464
4465 words_cur++;
4466
4467 if (data.devices_status == STATUS_CRACKED) break;
4468 if (data.devices_status == STATUS_ABORTED) break;
4469 if (data.devices_status == STATUS_QUIT) break;
4470 if (data.devices_status == STATUS_BYPASS) break;
4471 }
4472
4473 hc_thread_mutex_unlock (mux_dispatcher);
4474
4475 if (data.devices_status == STATUS_CRACKED) break;
4476 if (data.devices_status == STATUS_ABORTED) break;
4477 if (data.devices_status == STATUS_QUIT) break;
4478 if (data.devices_status == STATUS_BYPASS) break;
4479
4480 // we need 2 flushing because we have two independant caches and it can occur
4481 // that one buffer is already at threshold plus for that length also exists
4482 // more data in the 2nd buffer so it would overflow
4483
4484 // flush session 1
4485
4486 {
4487 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4488 {
4489 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4490
4491 const uint pw_cache_cnt = pw_cache->cnt;
4492
4493 if (pw_cache_cnt == 0) continue;
4494
4495 pw_cache->cnt = 0;
4496
4497 uint pws_cnt = device_param->pws_cnt;
4498
4499 pw_t *pw = device_param->pws_buf + pws_cnt;
4500
4501 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4502
4503 pw->pw_len = pw_len;
4504
4505 uint pw_cnt = device_param->pw_cnt;
4506
4507 pw_cnt += pw_cache_cnt;
4508
4509 device_param->pw_cnt = pw_cnt;
4510
4511 pws_cnt++;
4512
4513 device_param->pws_cnt = pws_cnt;
4514
4515 if (pws_cnt == device_param->kernel_power_user) break;
4516 }
4517
4518 const uint pw_cnt = device_param->pw_cnt;
4519 const uint pws_cnt = device_param->pws_cnt;
4520
4521 if (pws_cnt)
4522 {
4523 run_copy (device_param, pws_cnt);
4524
4525 run_cracker (device_param, pw_cnt, pws_cnt);
4526
4527 device_param->pw_cnt = 0;
4528 device_param->pws_cnt = 0;
4529 }
4530 }
4531
4532 // flush session 2
4533
4534 {
4535 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4536 {
4537 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4538
4539 const uint pw_cache_cnt = pw_cache->cnt;
4540
4541 if (pw_cache_cnt == 0) continue;
4542
4543 pw_cache->cnt = 0;
4544
4545 uint pws_cnt = device_param->pws_cnt;
4546
4547 pw_t *pw = device_param->pws_buf + pws_cnt;
4548
4549 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4550
4551 pw->pw_len = pw_len;
4552
4553 uint pw_cnt = device_param->pw_cnt;
4554
4555 pw_cnt += pw_cache_cnt;
4556
4557 device_param->pw_cnt = pw_cnt;
4558
4559 pws_cnt++;
4560
4561 device_param->pws_cnt = pws_cnt;
4562 }
4563
4564 const uint pw_cnt = device_param->pw_cnt;
4565 const uint pws_cnt = device_param->pws_cnt;
4566
4567 if (pws_cnt)
4568 {
4569 run_copy (device_param, pws_cnt);
4570
4571 run_cracker (device_param, pw_cnt, pws_cnt);
4572
4573 device_param->pw_cnt = 0;
4574 device_param->pws_cnt = 0;
4575 }
4576 }
4577 }
4578
4579 if (run_autotune)
4580 {
4581 device_param->kernel_accel = 0;
4582 device_param->kernel_loops = 0;
4583 }
4584
4585 return NULL;
4586 }
4587
4588 static void *thread_calc (void *p)
4589 {
4590 hc_device_param_t *device_param = (hc_device_param_t *) p;
4591
4592 if (device_param->skipped) return NULL;
4593
4594 const bool run_autotune = ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0));
4595
4596 if (run_autotune)
4597 {
4598 autotune (device_param);
4599 }
4600
4601 const uint attack_mode = data.attack_mode;
4602 const uint attack_kern = data.attack_kern;
4603
4604 if (attack_mode == ATTACK_MODE_BF)
4605 {
4606 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4607 {
4608 const uint work = get_work (device_param, -1);
4609
4610 if (work == 0) break;
4611
4612 const u64 words_off = device_param->words_off;
4613 const u64 words_fin = words_off + work;
4614
4615 const uint pw_cnt = work;
4616 const uint pws_cnt = work;
4617
4618 device_param->pw_cnt = pw_cnt;
4619 device_param->pws_cnt = pws_cnt;
4620
4621 if (pws_cnt)
4622 {
4623 run_copy (device_param, pws_cnt);
4624
4625 run_cracker (device_param, pw_cnt, pws_cnt);
4626
4627 device_param->pw_cnt = 0;
4628 device_param->pws_cnt = 0;
4629 }
4630
4631 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4632
4633 if (data.devices_status == STATUS_CRACKED) break;
4634 if (data.devices_status == STATUS_ABORTED) break;
4635 if (data.devices_status == STATUS_QUIT) break;
4636 if (data.devices_status == STATUS_BYPASS) break;
4637
4638 if (data.benchmark == 1) break;
4639
4640 device_param->words_done = words_fin;
4641 }
4642 }
4643 else
4644 {
4645 const uint segment_size = data.segment_size;
4646
4647 char *dictfile = data.dictfile;
4648
4649 if (attack_mode == ATTACK_MODE_COMBI)
4650 {
4651 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4652 {
4653 dictfile = data.dictfile2;
4654 }
4655 }
4656
4657 FILE *fd = fopen (dictfile, "rb");
4658
4659 if (fd == NULL)
4660 {
4661 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4662
4663 return NULL;
4664 }
4665
4666 if (attack_mode == ATTACK_MODE_COMBI)
4667 {
4668 const uint combs_mode = data.combs_mode;
4669
4670 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4671 {
4672 const char *dictfilec = data.dictfile2;
4673
4674 FILE *combs_fp = fopen (dictfilec, "rb");
4675
4676 if (combs_fp == NULL)
4677 {
4678 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4679
4680 fclose (fd);
4681
4682 return NULL;
4683 }
4684
4685 device_param->combs_fp = combs_fp;
4686 }
4687 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4688 {
4689 const char *dictfilec = data.dictfile;
4690
4691 FILE *combs_fp = fopen (dictfilec, "rb");
4692
4693 if (combs_fp == NULL)
4694 {
4695 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4696
4697 fclose (fd);
4698
4699 return NULL;
4700 }
4701
4702 device_param->combs_fp = combs_fp;
4703 }
4704 }
4705
4706 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4707
4708 wl_data->buf = (char *) mymalloc (segment_size);
4709 wl_data->avail = segment_size;
4710 wl_data->incr = segment_size;
4711 wl_data->cnt = 0;
4712 wl_data->pos = 0;
4713
4714 u64 words_cur = 0;
4715
4716 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4717 {
4718 u64 words_off = 0;
4719 u64 words_fin = 0;
4720
4721 u64 max = -1;
4722
4723 while (max)
4724 {
4725 const uint work = get_work (device_param, max);
4726
4727 if (work == 0) break;
4728
4729 words_off = device_param->words_off;
4730 words_fin = words_off + work;
4731
4732 char *line_buf;
4733 uint line_len;
4734
4735 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4736
4737 max = 0;
4738
4739 for ( ; words_cur < words_fin; words_cur++)
4740 {
4741 get_next_word (wl_data, fd, &line_buf, &line_len);
4742
4743 line_len = convert_from_hex (line_buf, line_len);
4744
4745 // post-process rule engine
4746
4747 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4748 {
4749 char rule_buf_out[BLOCK_SIZE] = { 0 };
4750
4751 int rule_len_out = -1;
4752
4753 if (line_len < BLOCK_SIZE)
4754 {
4755 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4756 }
4757
4758 if (rule_len_out < 0) continue;
4759
4760 line_buf = rule_buf_out;
4761 line_len = rule_len_out;
4762 }
4763
4764 if (attack_kern == ATTACK_KERN_STRAIGHT)
4765 {
4766 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4767 {
4768 max++;
4769
4770 hc_thread_mutex_lock (mux_counter);
4771
4772 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4773 {
4774 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4775 }
4776
4777 hc_thread_mutex_unlock (mux_counter);
4778
4779 continue;
4780 }
4781 }
4782 else if (attack_kern == ATTACK_KERN_COMBI)
4783 {
4784 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4785 // since we still need to combine the plains
4786
4787 if (line_len > data.pw_max)
4788 {
4789 max++;
4790
4791 hc_thread_mutex_lock (mux_counter);
4792
4793 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4794 {
4795 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4796 }
4797
4798 hc_thread_mutex_unlock (mux_counter);
4799
4800 continue;
4801 }
4802 }
4803
4804 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4805
4806 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4807
4808 if (data.devices_status == STATUS_CRACKED) break;
4809 if (data.devices_status == STATUS_ABORTED) break;
4810 if (data.devices_status == STATUS_QUIT) break;
4811 if (data.devices_status == STATUS_BYPASS) break;
4812 }
4813
4814 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4815
4816 if (data.devices_status == STATUS_CRACKED) break;
4817 if (data.devices_status == STATUS_ABORTED) break;
4818 if (data.devices_status == STATUS_QUIT) break;
4819 if (data.devices_status == STATUS_BYPASS) break;
4820 }
4821
4822 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4823
4824 if (data.devices_status == STATUS_CRACKED) break;
4825 if (data.devices_status == STATUS_ABORTED) break;
4826 if (data.devices_status == STATUS_QUIT) break;
4827 if (data.devices_status == STATUS_BYPASS) break;
4828
4829 // we need 2 flushing because we have two independant caches and it can occur
4830 // that one buffer is already at threshold plus for that length also exists
4831 // more data in the 2nd buffer so it would overflow
4832
4833 //
4834 // flush session 1
4835 //
4836
4837 {
4838 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4839 {
4840 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4841
4842 const uint pw_cache_cnt = pw_cache->cnt;
4843
4844 if (pw_cache_cnt == 0) continue;
4845
4846 pw_cache->cnt = 0;
4847
4848 uint pws_cnt = device_param->pws_cnt;
4849
4850 pw_t *pw = device_param->pws_buf + pws_cnt;
4851
4852 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4853
4854 pw->pw_len = pw_len;
4855
4856 uint pw_cnt = device_param->pw_cnt;
4857
4858 pw_cnt += pw_cache_cnt;
4859
4860 device_param->pw_cnt = pw_cnt;
4861
4862 pws_cnt++;
4863
4864 device_param->pws_cnt = pws_cnt;
4865
4866 if (pws_cnt == device_param->kernel_power_user) break;
4867 }
4868
4869 const uint pw_cnt = device_param->pw_cnt;
4870 const uint pws_cnt = device_param->pws_cnt;
4871
4872 if (pws_cnt)
4873 {
4874 run_copy (device_param, pws_cnt);
4875
4876 run_cracker (device_param, pw_cnt, pws_cnt);
4877
4878 device_param->pw_cnt = 0;
4879 device_param->pws_cnt = 0;
4880 }
4881
4882 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4883
4884 if (data.devices_status == STATUS_CRACKED) break;
4885 if (data.devices_status == STATUS_ABORTED) break;
4886 if (data.devices_status == STATUS_QUIT) break;
4887 if (data.devices_status == STATUS_BYPASS) break;
4888 }
4889
4890 //
4891 // flush session 2
4892 //
4893
4894 {
4895 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4896 {
4897 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4898
4899 const uint pw_cache_cnt = pw_cache->cnt;
4900
4901 if (pw_cache_cnt == 0) continue;
4902
4903 pw_cache->cnt = 0;
4904
4905 uint pws_cnt = device_param->pws_cnt;
4906
4907 pw_t *pw = device_param->pws_buf + pws_cnt;
4908
4909 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4910
4911 pw->pw_len = pw_len;
4912
4913 uint pw_cnt = device_param->pw_cnt;
4914
4915 pw_cnt += pw_cache_cnt;
4916
4917 device_param->pw_cnt = pw_cnt;
4918
4919 pws_cnt++;
4920
4921 device_param->pws_cnt = pws_cnt;
4922 }
4923
4924 const uint pw_cnt = device_param->pw_cnt;
4925 const uint pws_cnt = device_param->pws_cnt;
4926
4927 if (pws_cnt)
4928 {
4929 run_copy (device_param, pws_cnt);
4930
4931 run_cracker (device_param, pw_cnt, pws_cnt);
4932
4933 device_param->pw_cnt = 0;
4934 device_param->pws_cnt = 0;
4935 }
4936
4937 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4938
4939 if (data.devices_status == STATUS_CRACKED) break;
4940 if (data.devices_status == STATUS_ABORTED) break;
4941 if (data.devices_status == STATUS_QUIT) break;
4942 if (data.devices_status == STATUS_BYPASS) break;
4943 }
4944
4945 if (words_fin == 0) break;
4946
4947 device_param->words_done = words_fin;
4948 }
4949
4950 if (attack_mode == ATTACK_MODE_COMBI)
4951 {
4952 fclose (device_param->combs_fp);
4953 }
4954
4955 free (wl_data->buf);
4956 free (wl_data);
4957
4958 fclose (fd);
4959 }
4960
4961 if (run_autotune)
4962 {
4963 device_param->kernel_accel = 0;
4964 device_param->kernel_loops = 0;
4965 }
4966
4967 return NULL;
4968 }
4969
4970 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4971 {
4972 if (!device_param)
4973 {
4974 log_error ("ERROR: %s : Invalid argument", __func__);
4975
4976 exit (-1);
4977 }
4978
4979 salt_t *salt_buf = &data.salts_buf[salt_pos];
4980
4981 device_param->kernel_params_buf32[24] = salt_pos;
4982 device_param->kernel_params_buf32[27] = 1;
4983 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4984 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4985 device_param->kernel_params_buf32[30] = 0;
4986 device_param->kernel_params_buf32[31] = 1;
4987
4988 char *dictfile_old = data.dictfile;
4989
4990 const char *weak_hash_check = "weak-hash-check";
4991
4992 data.dictfile = (char *) weak_hash_check;
4993
4994 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4995
4996 data.kernel_rules_buf[0].cmds[0] = 0;
4997
4998 /**
4999 * run the kernel
5000 */
5001
5002 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5003 {
5004 run_kernel (KERN_RUN_1, device_param, 1, false);
5005 }
5006 else
5007 {
5008 run_kernel (KERN_RUN_1, device_param, 1, false);
5009
5010 uint loop_step = 16;
5011
5012 const uint iter = salt_buf->salt_iter;
5013
5014 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5015 {
5016 uint loop_left = iter - loop_pos;
5017
5018 loop_left = MIN (loop_left, loop_step);
5019
5020 device_param->kernel_params_buf32[25] = loop_pos;
5021 device_param->kernel_params_buf32[26] = loop_left;
5022
5023 run_kernel (KERN_RUN_2, device_param, 1, false);
5024 }
5025
5026 run_kernel (KERN_RUN_3, device_param, 1, false);
5027 }
5028
5029 /**
5030 * result
5031 */
5032
5033 check_cracked (device_param, salt_pos);
5034
5035 /**
5036 * cleanup
5037 */
5038
5039 device_param->kernel_params_buf32[24] = 0;
5040 device_param->kernel_params_buf32[25] = 0;
5041 device_param->kernel_params_buf32[26] = 0;
5042 device_param->kernel_params_buf32[27] = 0;
5043 device_param->kernel_params_buf32[28] = 0;
5044 device_param->kernel_params_buf32[29] = 0;
5045 device_param->kernel_params_buf32[30] = 0;
5046 device_param->kernel_params_buf32[31] = 0;
5047
5048 data.dictfile = dictfile_old;
5049
5050 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5051 }
5052
5053 // hlfmt hashcat
5054
5055 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5056 {
5057 if (data.username == 0)
5058 {
5059 *hashbuf_pos = line_buf;
5060 *hashbuf_len = line_len;
5061 }
5062 else
5063 {
5064 char *pos = line_buf;
5065 int len = line_len;
5066
5067 for (int i = 0; i < line_len; i++, pos++, len--)
5068 {
5069 if (line_buf[i] == data.separator)
5070 {
5071 pos++;
5072
5073 len--;
5074
5075 break;
5076 }
5077 }
5078
5079 *hashbuf_pos = pos;
5080 *hashbuf_len = len;
5081 }
5082 }
5083
5084 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5085 {
5086 char *pos = NULL;
5087 int len = 0;
5088
5089 int sep_cnt = 0;
5090
5091 for (int i = 0; i < line_len; i++)
5092 {
5093 if (line_buf[i] == data.separator)
5094 {
5095 sep_cnt++;
5096
5097 continue;
5098 }
5099
5100 if (sep_cnt == 0)
5101 {
5102 if (pos == NULL) pos = line_buf + i;
5103
5104 len++;
5105 }
5106 }
5107
5108 *userbuf_pos = pos;
5109 *userbuf_len = len;
5110 }
5111
5112 // hlfmt pwdump
5113
5114 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5115 {
5116 int sep_cnt = 0;
5117
5118 int sep2_len = 0;
5119 int sep3_len = 0;
5120
5121 for (int i = 0; i < line_len; i++)
5122 {
5123 if (line_buf[i] == ':')
5124 {
5125 sep_cnt++;
5126
5127 continue;
5128 }
5129
5130 if (sep_cnt == 2) sep2_len++;
5131 if (sep_cnt == 3) sep3_len++;
5132 }
5133
5134 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5135
5136 return 0;
5137 }
5138
5139 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5140 {
5141 char *pos = NULL;
5142 int len = 0;
5143
5144 int sep_cnt = 0;
5145
5146 for (int i = 0; i < line_len; i++)
5147 {
5148 if (line_buf[i] == ':')
5149 {
5150 sep_cnt++;
5151
5152 continue;
5153 }
5154
5155 if (data.hash_mode == 1000)
5156 {
5157 if (sep_cnt == 3)
5158 {
5159 if (pos == NULL) pos = line_buf + i;
5160
5161 len++;
5162 }
5163 }
5164 else if (data.hash_mode == 3000)
5165 {
5166 if (sep_cnt == 2)
5167 {
5168 if (pos == NULL) pos = line_buf + i;
5169
5170 len++;
5171 }
5172 }
5173 }
5174
5175 *hashbuf_pos = pos;
5176 *hashbuf_len = len;
5177 }
5178
5179 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5180 {
5181 char *pos = NULL;
5182 int len = 0;
5183
5184 int sep_cnt = 0;
5185
5186 for (int i = 0; i < line_len; i++)
5187 {
5188 if (line_buf[i] == ':')
5189 {
5190 sep_cnt++;
5191
5192 continue;
5193 }
5194
5195 if (sep_cnt == 0)
5196 {
5197 if (pos == NULL) pos = line_buf + i;
5198
5199 len++;
5200 }
5201 }
5202
5203 *userbuf_pos = pos;
5204 *userbuf_len = len;
5205 }
5206
5207 // hlfmt passwd
5208
5209 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5210 {
5211 int sep_cnt = 0;
5212
5213 char sep5_first = 0;
5214 char sep6_first = 0;
5215
5216 for (int i = 0; i < line_len; i++)
5217 {
5218 if (line_buf[i] == ':')
5219 {
5220 sep_cnt++;
5221
5222 continue;
5223 }
5224
5225 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5226 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5227 }
5228
5229 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5230
5231 return 0;
5232 }
5233
5234 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5235 {
5236 char *pos = NULL;
5237 int len = 0;
5238
5239 int sep_cnt = 0;
5240
5241 for (int i = 0; i < line_len; i++)
5242 {
5243 if (line_buf[i] == ':')
5244 {
5245 sep_cnt++;
5246
5247 continue;
5248 }
5249
5250 if (sep_cnt == 1)
5251 {
5252 if (pos == NULL) pos = line_buf + i;
5253
5254 len++;
5255 }
5256 }
5257
5258 *hashbuf_pos = pos;
5259 *hashbuf_len = len;
5260 }
5261
5262 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5263 {
5264 char *pos = NULL;
5265 int len = 0;
5266
5267 int sep_cnt = 0;
5268
5269 for (int i = 0; i < line_len; i++)
5270 {
5271 if (line_buf[i] == ':')
5272 {
5273 sep_cnt++;
5274
5275 continue;
5276 }
5277
5278 if (sep_cnt == 0)
5279 {
5280 if (pos == NULL) pos = line_buf + i;
5281
5282 len++;
5283 }
5284 }
5285
5286 *userbuf_pos = pos;
5287 *userbuf_len = len;
5288 }
5289
5290 // hlfmt shadow
5291
5292 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5293 {
5294 int sep_cnt = 0;
5295
5296 for (int i = 0; i < line_len; i++)
5297 {
5298 if (line_buf[i] == ':') sep_cnt++;
5299 }
5300
5301 if (sep_cnt == 8) return 1;
5302
5303 return 0;
5304 }
5305
5306 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5307 {
5308 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5309 }
5310
5311 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5312 {
5313 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5314 }
5315
5316 // hlfmt main
5317
5318 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5319 {
5320 switch (hashfile_format)
5321 {
5322 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5323 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5324 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5325 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5326 }
5327 }
5328
5329 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5330 {
5331 switch (hashfile_format)
5332 {
5333 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5334 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5335 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5336 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5337 }
5338 }
5339
5340 static uint hlfmt_detect (FILE *fp, uint max_check)
5341 {
5342 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5343
5344 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5345 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5346
5347 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5348
5349 uint num_check = 0;
5350
5351 while (!feof (fp))
5352 {
5353 char line_buf[BUFSIZ] = { 0 };
5354
5355 int line_len = fgetl (fp, line_buf);
5356
5357 if (line_len == 0) continue;
5358
5359 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5360 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5361 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5362
5363 if (num_check == max_check) break;
5364
5365 num_check++;
5366 }
5367
5368 uint hashlist_format = HLFMT_HASHCAT;
5369
5370 for (int i = 1; i < HLFMTS_CNT; i++)
5371 {
5372 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5373
5374 hashlist_format = i;
5375 }
5376
5377 free (formats_cnt);
5378
5379 return hashlist_format;
5380 }
5381
5382 /**
5383 * some further helper function
5384 */
5385
5386 // wrapper around mymalloc for ADL
5387
5388 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5389 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5390 {
5391 return mymalloc (iSize);
5392 }
5393 #endif
5394
5395 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)
5396 {
5397 u64 collisions = 0;
5398
5399 const uint dgst_pos0 = data.dgst_pos0;
5400 const uint dgst_pos1 = data.dgst_pos1;
5401 const uint dgst_pos2 = data.dgst_pos2;
5402 const uint dgst_pos3 = data.dgst_pos3;
5403
5404 memset (bitmap_a, 0, bitmap_size);
5405 memset (bitmap_b, 0, bitmap_size);
5406 memset (bitmap_c, 0, bitmap_size);
5407 memset (bitmap_d, 0, bitmap_size);
5408
5409 for (uint i = 0; i < digests_cnt; i++)
5410 {
5411 uint *digest_ptr = (uint *) digests_buf_ptr;
5412
5413 digests_buf_ptr += dgst_size;
5414
5415 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5416 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5417 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5418 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5419
5420 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5421 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5422 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5423 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5424
5425 if (bitmap_a[idx0] & val0) collisions++;
5426 if (bitmap_b[idx1] & val1) collisions++;
5427 if (bitmap_c[idx2] & val2) collisions++;
5428 if (bitmap_d[idx3] & val3) collisions++;
5429
5430 bitmap_a[idx0] |= val0;
5431 bitmap_b[idx1] |= val1;
5432 bitmap_c[idx2] |= val2;
5433 bitmap_d[idx3] |= val3;
5434
5435 if (collisions >= collisions_max) return 0x7fffffff;
5436 }
5437
5438 return collisions;
5439 }
5440
5441 /**
5442 * main
5443 */
5444
5445 int main (int argc, char **argv)
5446 {
5447 /**
5448 * To help users a bit
5449 */
5450
5451 char *compute = getenv ("COMPUTE");
5452
5453 if (compute)
5454 {
5455 static char display[100];
5456
5457 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5458
5459 putenv (display);
5460 }
5461 else
5462 {
5463 if (getenv ("DISPLAY") == NULL)
5464 putenv ((char *) "DISPLAY=:0");
5465 }
5466
5467 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5468 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5469
5470 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5471 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5472
5473 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5474 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5475
5476 /**
5477 * Real init
5478 */
5479
5480 memset (&data, 0, sizeof (hc_global_data_t));
5481
5482 time_t proc_start;
5483
5484 time (&proc_start);
5485
5486 data.proc_start = proc_start;
5487
5488 int myargc = argc;
5489 char **myargv = argv;
5490
5491 hc_thread_mutex_init (mux_dispatcher);
5492 hc_thread_mutex_init (mux_counter);
5493 hc_thread_mutex_init (mux_display);
5494 hc_thread_mutex_init (mux_adl);
5495
5496 /**
5497 * commandline parameters
5498 */
5499
5500 uint usage = USAGE;
5501 uint version = VERSION;
5502 uint quiet = QUIET;
5503 uint benchmark = BENCHMARK;
5504 uint benchmark_repeats = BENCHMARK_REPEATS;
5505 uint show = SHOW;
5506 uint left = LEFT;
5507 uint username = USERNAME;
5508 uint remove = REMOVE;
5509 uint remove_timer = REMOVE_TIMER;
5510 u64 skip = SKIP;
5511 u64 limit = LIMIT;
5512 uint keyspace = KEYSPACE;
5513 uint potfile_disable = POTFILE_DISABLE;
5514 uint debug_mode = DEBUG_MODE;
5515 char *debug_file = NULL;
5516 char *induction_dir = NULL;
5517 char *outfile_check_dir = NULL;
5518 uint force = FORCE;
5519 uint runtime = RUNTIME;
5520 uint hash_mode = HASH_MODE;
5521 uint attack_mode = ATTACK_MODE;
5522 uint markov_disable = MARKOV_DISABLE;
5523 uint markov_classic = MARKOV_CLASSIC;
5524 uint markov_threshold = MARKOV_THRESHOLD;
5525 char *markov_hcstat = NULL;
5526 char *outfile = NULL;
5527 uint outfile_format = OUTFILE_FORMAT;
5528 uint outfile_autohex = OUTFILE_AUTOHEX;
5529 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5530 uint restore = RESTORE;
5531 uint restore_timer = RESTORE_TIMER;
5532 uint restore_disable = RESTORE_DISABLE;
5533 uint status = STATUS;
5534 uint status_timer = STATUS_TIMER;
5535 uint status_automat = STATUS_AUTOMAT;
5536 uint loopback = LOOPBACK;
5537 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5538 char *session = NULL;
5539 uint hex_charset = HEX_CHARSET;
5540 uint hex_salt = HEX_SALT;
5541 uint hex_wordlist = HEX_WORDLIST;
5542 uint rp_gen = RP_GEN;
5543 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5544 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5545 uint rp_gen_seed = RP_GEN_SEED;
5546 char *rule_buf_l = (char *) RULE_BUF_L;
5547 char *rule_buf_r = (char *) RULE_BUF_R;
5548 uint increment = INCREMENT;
5549 uint increment_min = INCREMENT_MIN;
5550 uint increment_max = INCREMENT_MAX;
5551 char *cpu_affinity = NULL;
5552 OCL_PTR *ocl = NULL;
5553 char *opencl_devices = NULL;
5554 char *opencl_platforms = NULL;
5555 char *opencl_device_types = NULL;
5556 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5557 char *truecrypt_keyfiles = NULL;
5558 uint workload_profile = WORKLOAD_PROFILE;
5559 uint kernel_accel = KERNEL_ACCEL;
5560 uint kernel_loops = KERNEL_LOOPS;
5561 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5562 #ifdef HAVE_HWMON
5563 uint gpu_temp_abort = GPU_TEMP_ABORT;
5564 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5565 #ifdef HAVE_ADL
5566 uint powertune_enable = POWERTUNE_ENABLE;
5567 #endif
5568 #endif
5569 uint logfile_disable = LOGFILE_DISABLE;
5570 uint segment_size = SEGMENT_SIZE;
5571 uint scrypt_tmto = SCRYPT_TMTO;
5572 char separator = SEPARATOR;
5573 uint bitmap_min = BITMAP_MIN;
5574 uint bitmap_max = BITMAP_MAX;
5575 char *custom_charset_1 = NULL;
5576 char *custom_charset_2 = NULL;
5577 char *custom_charset_3 = NULL;
5578 char *custom_charset_4 = NULL;
5579
5580 #define IDX_HELP 'h'
5581 #define IDX_VERSION 'V'
5582 #define IDX_VERSION_LOWER 'v'
5583 #define IDX_QUIET 0xff02
5584 #define IDX_SHOW 0xff03
5585 #define IDX_LEFT 0xff04
5586 #define IDX_REMOVE 0xff05
5587 #define IDX_REMOVE_TIMER 0xff37
5588 #define IDX_SKIP 's'
5589 #define IDX_LIMIT 'l'
5590 #define IDX_KEYSPACE 0xff35
5591 #define IDX_POTFILE_DISABLE 0xff06
5592 #define IDX_DEBUG_MODE 0xff43
5593 #define IDX_DEBUG_FILE 0xff44
5594 #define IDX_INDUCTION_DIR 0xff46
5595 #define IDX_OUTFILE_CHECK_DIR 0xff47
5596 #define IDX_USERNAME 0xff07
5597 #define IDX_FORCE 0xff08
5598 #define IDX_RUNTIME 0xff09
5599 #define IDX_BENCHMARK 'b'
5600 #define IDX_BENCHMARK_REPEATS 0xff78
5601 #define IDX_HASH_MODE 'm'
5602 #define IDX_ATTACK_MODE 'a'
5603 #define IDX_RP_FILE 'r'
5604 #define IDX_RP_GEN 'g'
5605 #define IDX_RP_GEN_FUNC_MIN 0xff10
5606 #define IDX_RP_GEN_FUNC_MAX 0xff11
5607 #define IDX_RP_GEN_SEED 0xff34
5608 #define IDX_RULE_BUF_L 'j'
5609 #define IDX_RULE_BUF_R 'k'
5610 #define IDX_INCREMENT 'i'
5611 #define IDX_INCREMENT_MIN 0xff12
5612 #define IDX_INCREMENT_MAX 0xff13
5613 #define IDX_OUTFILE 'o'
5614 #define IDX_OUTFILE_FORMAT 0xff14
5615 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5616 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5617 #define IDX_RESTORE 0xff15
5618 #define IDX_RESTORE_DISABLE 0xff27
5619 #define IDX_STATUS 0xff17
5620 #define IDX_STATUS_TIMER 0xff18
5621 #define IDX_STATUS_AUTOMAT 0xff50
5622 #define IDX_LOOPBACK 0xff38
5623 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5624 #define IDX_SESSION 0xff19
5625 #define IDX_HEX_CHARSET 0xff20
5626 #define IDX_HEX_SALT 0xff21
5627 #define IDX_HEX_WORDLIST 0xff40
5628 #define IDX_MARKOV_DISABLE 0xff22
5629 #define IDX_MARKOV_CLASSIC 0xff23
5630 #define IDX_MARKOV_THRESHOLD 't'
5631 #define IDX_MARKOV_HCSTAT 0xff24
5632 #define IDX_CPU_AFFINITY 0xff25
5633 #define IDX_OPENCL_DEVICES 'd'
5634 #define IDX_OPENCL_PLATFORMS 0xff72
5635 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5636 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5637 #define IDX_WORKLOAD_PROFILE 'w'
5638 #define IDX_KERNEL_ACCEL 'n'
5639 #define IDX_KERNEL_LOOPS 'u'
5640 #define IDX_GPU_TEMP_DISABLE 0xff29
5641 #define IDX_GPU_TEMP_ABORT 0xff30
5642 #define IDX_GPU_TEMP_RETAIN 0xff31
5643 #define IDX_POWERTUNE_ENABLE 0xff41
5644 #define IDX_LOGFILE_DISABLE 0xff51
5645 #define IDX_TRUECRYPT_KEYFILES 0xff52
5646 #define IDX_SCRYPT_TMTO 0xff61
5647 #define IDX_SEGMENT_SIZE 'c'
5648 #define IDX_SEPARATOR 'p'
5649 #define IDX_BITMAP_MIN 0xff70
5650 #define IDX_BITMAP_MAX 0xff71
5651 #define IDX_CUSTOM_CHARSET_1 '1'
5652 #define IDX_CUSTOM_CHARSET_2 '2'
5653 #define IDX_CUSTOM_CHARSET_3 '3'
5654 #define IDX_CUSTOM_CHARSET_4 '4'
5655
5656 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5657
5658 struct option long_options[] =
5659 {
5660 {"help", no_argument, 0, IDX_HELP},
5661 {"version", no_argument, 0, IDX_VERSION},
5662 {"quiet", no_argument, 0, IDX_QUIET},
5663 {"show", no_argument, 0, IDX_SHOW},
5664 {"left", no_argument, 0, IDX_LEFT},
5665 {"username", no_argument, 0, IDX_USERNAME},
5666 {"remove", no_argument, 0, IDX_REMOVE},
5667 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5668 {"skip", required_argument, 0, IDX_SKIP},
5669 {"limit", required_argument, 0, IDX_LIMIT},
5670 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5671 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5672 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5673 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5674 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5675 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5676 {"force", no_argument, 0, IDX_FORCE},
5677 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5678 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5679 {"restore", no_argument, 0, IDX_RESTORE},
5680 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5681 {"status", no_argument, 0, IDX_STATUS},
5682 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5683 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5684 {"loopback", no_argument, 0, IDX_LOOPBACK},
5685 {"weak-hash-threshold",
5686 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5687 {"session", required_argument, 0, IDX_SESSION},
5688 {"runtime", required_argument, 0, IDX_RUNTIME},
5689 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5690 {"generate-rules-func-min",
5691 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5692 {"generate-rules-func-max",
5693 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5694 {"generate-rules-seed",
5695 required_argument, 0, IDX_RP_GEN_SEED},
5696 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5697 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5698 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5699 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5700 {"rules-file", required_argument, 0, IDX_RP_FILE},
5701 {"outfile", required_argument, 0, IDX_OUTFILE},
5702 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5703 {"outfile-autohex-disable",
5704 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5705 {"outfile-check-timer",
5706 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5707 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5708 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5709 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5710 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5711 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5712 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5713 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5714 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5715 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5716 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5717 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5718 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5719 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5720 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5721 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5722 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5723 #ifdef HAVE_HWMON
5724 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5725 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5726 #ifdef HAVE_ADL
5727 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5728 #endif
5729 #endif // HAVE_HWMON
5730 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5731 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5732 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5733 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5734 // deprecated
5735 {"seperator", required_argument, 0, IDX_SEPARATOR},
5736 {"separator", required_argument, 0, IDX_SEPARATOR},
5737 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5738 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5739 {"increment", no_argument, 0, IDX_INCREMENT},
5740 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5741 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5742 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5743 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5744 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5745 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5746
5747 {0, 0, 0, 0}
5748 };
5749
5750 uint rp_files_cnt = 0;
5751
5752 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5753
5754 int option_index = 0;
5755 int c = -1;
5756
5757 optind = 1;
5758 optopt = 0;
5759
5760 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5761 {
5762 switch (c)
5763 {
5764 case IDX_HELP: usage = 1; break;
5765 case IDX_VERSION:
5766 case IDX_VERSION_LOWER: version = 1; break;
5767 case IDX_RESTORE: restore = 1; break;
5768 case IDX_SESSION: session = optarg; break;
5769 case IDX_SHOW: show = 1; break;
5770 case IDX_LEFT: left = 1; break;
5771 case '?': return (-1);
5772 }
5773 }
5774
5775 if (optopt != 0)
5776 {
5777 log_error ("ERROR: Invalid argument specified");
5778
5779 return (-1);
5780 }
5781
5782 /**
5783 * exit functions
5784 */
5785
5786 if (version)
5787 {
5788 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5789
5790 return (0);
5791 }
5792
5793 if (usage)
5794 {
5795 usage_big_print (PROGNAME);
5796
5797 return (0);
5798 }
5799
5800 /**
5801 * session needs to be set, always!
5802 */
5803
5804 if (session == NULL) session = (char *) PROGNAME;
5805
5806 /**
5807 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5808 */
5809
5810 char *exec_path = get_exec_path ();
5811
5812 #ifdef LINUX
5813
5814 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5815 char *resolved_exec_path = realpath (exec_path, NULL);
5816
5817 char *install_dir = get_install_dir (resolved_exec_path);
5818 char *profile_dir = NULL;
5819 char *session_dir = NULL;
5820 char *shared_dir = NULL;
5821
5822 if (strcmp (install_dir, resolved_install_folder) == 0)
5823 {
5824 struct passwd *pw = getpwuid (getuid ());
5825
5826 const char *homedir = pw->pw_dir;
5827
5828 profile_dir = get_profile_dir (homedir);
5829 session_dir = get_session_dir (profile_dir);
5830 shared_dir = strdup (SHARED_FOLDER);
5831
5832 mkdir (profile_dir, 0700);
5833 mkdir (session_dir, 0700);
5834 }
5835 else
5836 {
5837 profile_dir = install_dir;
5838 session_dir = install_dir;
5839 shared_dir = install_dir;
5840 }
5841
5842 myfree (resolved_install_folder);
5843 myfree (resolved_exec_path);
5844
5845 #else
5846
5847 char *install_dir = get_install_dir (exec_path);
5848 char *profile_dir = install_dir;
5849 char *session_dir = install_dir;
5850 char *shared_dir = install_dir;
5851
5852 #endif
5853
5854 data.install_dir = install_dir;
5855 data.profile_dir = profile_dir;
5856 data.session_dir = session_dir;
5857 data.shared_dir = shared_dir;
5858
5859 myfree (exec_path);
5860
5861 /**
5862 * kernel cache, we need to make sure folder exist
5863 */
5864
5865 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5866
5867 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5868
5869 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5870
5871 mkdir (kernels_folder, 0700);
5872
5873 myfree (kernels_folder);
5874
5875 /**
5876 * session
5877 */
5878
5879 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5880
5881 data.session = session;
5882
5883 char *eff_restore_file = (char *) mymalloc (session_size);
5884 char *new_restore_file = (char *) mymalloc (session_size);
5885
5886 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5887 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5888
5889 data.eff_restore_file = eff_restore_file;
5890 data.new_restore_file = new_restore_file;
5891
5892 if (((show == 1) || (left == 1)) && (restore == 1))
5893 {
5894 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5895 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5896
5897 return (-1);
5898 }
5899
5900 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5901 if ((show == 1) || (left == 1))
5902 {
5903 restore_disable = 1;
5904
5905 restore = 0;
5906 }
5907
5908 data.restore_disable = restore_disable;
5909
5910 restore_data_t *rd = init_restore (argc, argv);
5911
5912 data.rd = rd;
5913
5914 /**
5915 * restore file
5916 */
5917
5918 if (restore == 1)
5919 {
5920 read_restore (eff_restore_file, rd);
5921
5922 if (rd->version_bin < RESTORE_MIN)
5923 {
5924 log_error ("ERROR: Incompatible restore-file version");
5925
5926 return (-1);
5927 }
5928
5929 myargc = rd->argc;
5930 myargv = rd->argv;
5931
5932 #ifdef _POSIX
5933 rd->pid = getpid ();
5934 #elif _WIN
5935 rd->pid = GetCurrentProcessId ();
5936 #endif
5937 }
5938
5939 uint hash_mode_chgd = 0;
5940 uint runtime_chgd = 0;
5941 uint kernel_loops_chgd = 0;
5942 uint kernel_accel_chgd = 0;
5943 uint attack_mode_chgd = 0;
5944 uint outfile_format_chgd = 0;
5945 uint rp_gen_seed_chgd = 0;
5946 uint remove_timer_chgd = 0;
5947 uint increment_min_chgd = 0;
5948 uint increment_max_chgd = 0;
5949 uint workload_profile_chgd = 0;
5950 uint opencl_vector_width_chgd = 0;
5951
5952 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5953 uint gpu_temp_retain_chgd = 0;
5954 uint gpu_temp_abort_chgd = 0;
5955 #endif
5956
5957 optind = 1;
5958 optopt = 0;
5959 option_index = 0;
5960
5961 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5962 {
5963 switch (c)
5964 {
5965 //case IDX_HELP: usage = 1; break;
5966 //case IDX_VERSION: version = 1; break;
5967 //case IDX_RESTORE: restore = 1; break;
5968 case IDX_QUIET: quiet = 1; break;
5969 //case IDX_SHOW: show = 1; break;
5970 case IDX_SHOW: break;
5971 //case IDX_LEFT: left = 1; break;
5972 case IDX_LEFT: break;
5973 case IDX_USERNAME: username = 1; break;
5974 case IDX_REMOVE: remove = 1; break;
5975 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5976 remove_timer_chgd = 1; break;
5977 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5978 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5979 case IDX_DEBUG_FILE: debug_file = optarg; break;
5980 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5981 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5982 case IDX_FORCE: force = 1; break;
5983 case IDX_SKIP: skip = atoll (optarg); break;
5984 case IDX_LIMIT: limit = atoll (optarg); break;
5985 case IDX_KEYSPACE: keyspace = 1; break;
5986 case IDX_BENCHMARK: benchmark = 1; break;
5987 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5988 case IDX_RESTORE: break;
5989 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5990 case IDX_STATUS: status = 1; break;
5991 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5992 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5993 case IDX_LOOPBACK: loopback = 1; break;
5994 case IDX_WEAK_HASH_THRESHOLD:
5995 weak_hash_threshold = atoi (optarg); break;
5996 //case IDX_SESSION: session = optarg; break;
5997 case IDX_SESSION: break;
5998 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5999 hash_mode_chgd = 1; break;
6000 case IDX_RUNTIME: runtime = atoi (optarg);
6001 runtime_chgd = 1; break;
6002 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6003 attack_mode_chgd = 1; break;
6004 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6005 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6006 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6007 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6008 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6009 rp_gen_seed_chgd = 1; break;
6010 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6011 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6012 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6013 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6014 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6015 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6016 case IDX_OUTFILE: outfile = optarg; break;
6017 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6018 outfile_format_chgd = 1; break;
6019 case IDX_OUTFILE_AUTOHEX_DISABLE:
6020 outfile_autohex = 0; break;
6021 case IDX_OUTFILE_CHECK_TIMER:
6022 outfile_check_timer = atoi (optarg); break;
6023 case IDX_HEX_CHARSET: hex_charset = 1; break;
6024 case IDX_HEX_SALT: hex_salt = 1; break;
6025 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6026 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6027 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6028 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6029 case IDX_OPENCL_DEVICE_TYPES:
6030 opencl_device_types = optarg; break;
6031 case IDX_OPENCL_VECTOR_WIDTH:
6032 opencl_vector_width = atoi (optarg);
6033 opencl_vector_width_chgd = 1; break;
6034 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6035 workload_profile_chgd = 1; break;
6036 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6037 kernel_accel_chgd = 1; break;
6038 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6039 kernel_loops_chgd = 1; break;
6040 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6041 #ifdef HAVE_HWMON
6042 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6043 #ifdef HAVE_ADL
6044 gpu_temp_abort_chgd = 1;
6045 #endif
6046 break;
6047 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6048 #ifdef HAVE_ADL
6049 gpu_temp_retain_chgd = 1;
6050 #endif
6051 break;
6052 #ifdef HAVE_ADL
6053 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6054 #endif
6055 #endif // HAVE_HWMON
6056 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6057 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6058 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6059 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6060 case IDX_SEPARATOR: separator = optarg[0]; break;
6061 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6062 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6063 case IDX_INCREMENT: increment = 1; break;
6064 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6065 increment_min_chgd = 1; break;
6066 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6067 increment_max_chgd = 1; break;
6068 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6069 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6070 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6071 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6072
6073 default:
6074 log_error ("ERROR: Invalid argument specified");
6075 return (-1);
6076 }
6077 }
6078
6079 if (optopt != 0)
6080 {
6081 log_error ("ERROR: Invalid argument specified");
6082
6083 return (-1);
6084 }
6085
6086 /**
6087 * Inform user things getting started,
6088 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6089 * - we do not need to check algorithm_pos
6090 */
6091
6092 if (quiet == 0)
6093 {
6094 if (benchmark == 1)
6095 {
6096 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6097
6098 log_info ("");
6099 }
6100 else if (restore == 1)
6101 {
6102 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6103
6104 log_info ("");
6105 }
6106 else
6107 {
6108 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6109
6110 log_info ("");
6111 }
6112 }
6113
6114 /**
6115 * sanity check
6116 */
6117
6118 if (attack_mode > 7)
6119 {
6120 log_error ("ERROR: Invalid attack-mode specified");
6121
6122 return (-1);
6123 }
6124
6125 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6126 {
6127 log_error ("ERROR: Invalid runtime specified");
6128
6129 return (-1);
6130 }
6131
6132 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
6133 {
6134 log_error ("ERROR: Invalid hash-type specified");
6135
6136 return (-1);
6137 }
6138
6139 // renamed hash modes
6140
6141 if (hash_mode_chgd)
6142 {
6143 int n = -1;
6144
6145 switch (hash_mode)
6146 {
6147 case 123: n = 124;
6148 break;
6149 }
6150
6151 if (n >= 0)
6152 {
6153 log_error ("Old -m specified, use -m %d instead", n);
6154
6155 return (-1);
6156 }
6157 }
6158
6159 if (username == 1)
6160 {
6161 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6162 {
6163 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6164
6165 return (-1);
6166 }
6167 }
6168
6169 if (outfile_format > 16)
6170 {
6171 log_error ("ERROR: Invalid outfile-format specified");
6172
6173 return (-1);
6174 }
6175
6176 if (left == 1)
6177 {
6178 if (outfile_format_chgd == 1)
6179 {
6180 if (outfile_format > 1)
6181 {
6182 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6183
6184 return (-1);
6185 }
6186 }
6187 else
6188 {
6189 outfile_format = OUTFILE_FMT_HASH;
6190 }
6191 }
6192
6193 if (show == 1)
6194 {
6195 if (outfile_format_chgd == 1)
6196 {
6197 if ((outfile_format > 7) && (outfile_format < 16))
6198 {
6199 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6200
6201 return (-1);
6202 }
6203 }
6204 }
6205
6206 if (increment_min < INCREMENT_MIN)
6207 {
6208 log_error ("ERROR: Invalid increment-min specified");
6209
6210 return (-1);
6211 }
6212
6213 if (increment_max > INCREMENT_MAX)
6214 {
6215 log_error ("ERROR: Invalid increment-max specified");
6216
6217 return (-1);
6218 }
6219
6220 if (increment_min > increment_max)
6221 {
6222 log_error ("ERROR: Invalid increment-min specified");
6223
6224 return (-1);
6225 }
6226
6227 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6228 {
6229 log_error ("ERROR: increment is not allowed in attack-mode 0");
6230
6231 return (-1);
6232 }
6233
6234 if ((increment == 0) && (increment_min_chgd == 1))
6235 {
6236 log_error ("ERROR: increment-min is only supported together with increment switch");
6237
6238 return (-1);
6239 }
6240
6241 if ((increment == 0) && (increment_max_chgd == 1))
6242 {
6243 log_error ("ERROR: increment-max is only supported together with increment switch");
6244
6245 return (-1);
6246 }
6247
6248 if (rp_files_cnt && rp_gen)
6249 {
6250 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6251
6252 return (-1);
6253 }
6254
6255 if (rp_files_cnt || rp_gen)
6256 {
6257 if (attack_mode != ATTACK_MODE_STRAIGHT)
6258 {
6259 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6260
6261 return (-1);
6262 }
6263 }
6264
6265 if (rp_gen_func_min > rp_gen_func_max)
6266 {
6267 log_error ("ERROR: Invalid rp-gen-func-min specified");
6268
6269 return (-1);
6270 }
6271
6272 if (kernel_accel_chgd == 1 && kernel_loops_chgd == 0)
6273 {
6274 log_error ("ERROR: If kernel-accel is specified, kernel-loops need to be specified as well");
6275
6276 return (-1);
6277 }
6278
6279 if (kernel_loops_chgd == 1 && kernel_accel_chgd == 0)
6280 {
6281 log_error ("ERROR: If kernel-loops is specified, kernel-accel need to be specified as well");
6282
6283 return (-1);
6284 }
6285
6286 if (kernel_accel_chgd == 1)
6287 {
6288 if (kernel_accel < 1)
6289 {
6290 log_error ("ERROR: Invalid kernel-accel specified");
6291
6292 return (-1);
6293 }
6294
6295 if (kernel_accel > 1024)
6296 {
6297 log_error ("ERROR: Invalid kernel-accel specified");
6298
6299 return (-1);
6300 }
6301 }
6302
6303 if (kernel_loops_chgd == 1)
6304 {
6305 if (kernel_loops < 1)
6306 {
6307 log_error ("ERROR: Invalid kernel-loops specified");
6308
6309 return (-1);
6310 }
6311
6312 if (kernel_loops > 1024)
6313 {
6314 log_error ("ERROR: Invalid kernel-loops specified");
6315
6316 return (-1);
6317 }
6318 }
6319
6320 if ((workload_profile < 1) || (workload_profile > 3))
6321 {
6322 log_error ("ERROR: workload-profile %i not available", workload_profile);
6323
6324 return (-1);
6325 }
6326
6327 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6328 {
6329 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6330
6331 return (-1);
6332 }
6333
6334 if (show == 1 || left == 1)
6335 {
6336 attack_mode = ATTACK_MODE_NONE;
6337
6338 if (remove == 1)
6339 {
6340 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6341
6342 return (-1);
6343 }
6344
6345 if (potfile_disable == 1)
6346 {
6347 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 uint attack_kern = ATTACK_KERN_NONE;
6354
6355 switch (attack_mode)
6356 {
6357 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6358 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6359 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6360 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6361 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6362 }
6363
6364 if (benchmark == 0)
6365 {
6366 if (keyspace == 1)
6367 {
6368 int num_additional_params = 1;
6369
6370 if (attack_kern == ATTACK_KERN_COMBI)
6371 {
6372 num_additional_params = 2;
6373 }
6374
6375 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6376
6377 if (keyspace_wordlist_specified == 0) optind--;
6378 }
6379
6380 if (attack_kern == ATTACK_KERN_NONE)
6381 {
6382 if ((optind + 1) != myargc)
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6390 {
6391 if ((optind + 1) > myargc)
6392 {
6393 usage_mini_print (myargv[0]);
6394
6395 return (-1);
6396 }
6397 }
6398 else if (attack_kern == ATTACK_KERN_COMBI)
6399 {
6400 if ((optind + 3) != myargc)
6401 {
6402 usage_mini_print (myargv[0]);
6403
6404 return (-1);
6405 }
6406 }
6407 else if (attack_kern == ATTACK_KERN_BF)
6408 {
6409 if ((optind + 1) > myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else
6417 {
6418 usage_mini_print (myargv[0]);
6419
6420 return (-1);
6421 }
6422 }
6423 else
6424 {
6425 if (myargv[optind] != 0)
6426 {
6427 log_error ("ERROR: Invalid argument for benchmark mode specified");
6428
6429 return (-1);
6430 }
6431
6432 if (attack_mode_chgd == 1)
6433 {
6434 if (attack_mode != ATTACK_MODE_BF)
6435 {
6436 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6437
6438 return (-1);
6439 }
6440 }
6441 }
6442
6443 if (skip != 0 && limit != 0)
6444 {
6445 limit += skip;
6446 }
6447
6448 if (keyspace == 1)
6449 {
6450 if (show == 1)
6451 {
6452 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6453
6454 return (-1);
6455 }
6456 else if (left == 1)
6457 {
6458 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6459
6460 return (-1);
6461 }
6462
6463 potfile_disable = 1;
6464
6465 restore_disable = 1;
6466
6467 restore = 0;
6468
6469 weak_hash_threshold = 0;
6470
6471 quiet = 1;
6472 }
6473
6474 if (remove_timer_chgd == 1)
6475 {
6476 if (remove == 0)
6477 {
6478 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6479
6480 return (-1);
6481 }
6482
6483 if (remove_timer < 1)
6484 {
6485 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6486
6487 return (-1);
6488 }
6489 }
6490
6491 if (loopback == 1)
6492 {
6493 if (attack_mode == ATTACK_MODE_BF)
6494 {
6495 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6496
6497 return (-1);
6498 }
6499 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6500 {
6501 if ((rp_files_cnt == 0) && (rp_gen == 0))
6502 {
6503 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6504
6505 return (-1);
6506 }
6507 }
6508 }
6509
6510 if (debug_mode > 0)
6511 {
6512 if (attack_mode != ATTACK_MODE_STRAIGHT)
6513 {
6514 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6515
6516 return (-1);
6517 }
6518
6519 if ((rp_files_cnt == 0) && (rp_gen == 0))
6520 {
6521 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6522
6523 return (-1);
6524 }
6525 }
6526
6527 if (debug_mode > 4)
6528 {
6529 log_error ("ERROR: Invalid debug-mode specified");
6530
6531 return (-1);
6532 }
6533
6534 if (debug_file != NULL)
6535 {
6536 if (debug_mode < 1)
6537 {
6538 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (induction_dir != NULL)
6545 {
6546 if (attack_mode == ATTACK_MODE_BF)
6547 {
6548 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (attack_mode != ATTACK_MODE_STRAIGHT)
6555 {
6556 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6557 {
6558 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6559
6560 return (-1);
6561 }
6562
6563 weak_hash_threshold = 0;
6564 }
6565
6566 /**
6567 * induction directory
6568 */
6569
6570 char *induction_directory = NULL;
6571
6572 if (attack_mode != ATTACK_MODE_BF)
6573 {
6574 if (induction_dir == NULL)
6575 {
6576 induction_directory = (char *) mymalloc (session_size);
6577
6578 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6579
6580 // create induction folder if it does not already exist
6581
6582 if (keyspace == 0)
6583 {
6584 if (rmdir (induction_directory) == -1)
6585 {
6586 if (errno == ENOENT)
6587 {
6588 // good, we can ignore
6589 }
6590 else if (errno == ENOTEMPTY)
6591 {
6592 char *induction_directory_mv = (char *) mymalloc (session_size);
6593
6594 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6595
6596 if (rename (induction_directory, induction_directory_mv) != 0)
6597 {
6598 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6599
6600 return (-1);
6601 }
6602 }
6603 else
6604 {
6605 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6606
6607 return (-1);
6608 }
6609 }
6610
6611 if (mkdir (induction_directory, 0700) == -1)
6612 {
6613 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6614
6615 return (-1);
6616 }
6617 }
6618 }
6619 else
6620 {
6621 induction_directory = induction_dir;
6622 }
6623 }
6624
6625 data.induction_directory = induction_directory;
6626
6627 /**
6628 * loopback
6629 */
6630
6631 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6632
6633 char *loopback_file = (char *) mymalloc (loopback_size);
6634
6635 /**
6636 * tuning db
6637 */
6638
6639 char tuning_db_file[256] = { 0 };
6640
6641 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6642
6643 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6644
6645 /**
6646 * outfile-check directory
6647 */
6648
6649 char *outfile_check_directory = NULL;
6650
6651 if (outfile_check_dir == NULL)
6652 {
6653 outfile_check_directory = (char *) mymalloc (session_size);
6654
6655 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6656 }
6657 else
6658 {
6659 outfile_check_directory = outfile_check_dir;
6660 }
6661
6662 data.outfile_check_directory = outfile_check_directory;
6663
6664 if (keyspace == 0)
6665 {
6666 struct stat outfile_check_stat;
6667
6668 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6669 {
6670 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6671
6672 if (is_dir == 0)
6673 {
6674 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6675
6676 return (-1);
6677 }
6678 }
6679 else if (outfile_check_dir == NULL)
6680 {
6681 if (mkdir (outfile_check_directory, 0700) == -1)
6682 {
6683 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6684
6685 return (-1);
6686 }
6687 }
6688 }
6689
6690 /**
6691 * special other stuff
6692 */
6693
6694 if (hash_mode == 9710)
6695 {
6696 outfile_format = 5;
6697 outfile_format_chgd = 1;
6698 }
6699
6700 if (hash_mode == 9810)
6701 {
6702 outfile_format = 5;
6703 outfile_format_chgd = 1;
6704 }
6705
6706 if (hash_mode == 10410)
6707 {
6708 outfile_format = 5;
6709 outfile_format_chgd = 1;
6710 }
6711
6712 /**
6713 * store stuff
6714 */
6715
6716 data.hash_mode = hash_mode;
6717 data.restore = restore;
6718 data.restore_timer = restore_timer;
6719 data.restore_disable = restore_disable;
6720 data.status = status;
6721 data.status_timer = status_timer;
6722 data.status_automat = status_automat;
6723 data.loopback = loopback;
6724 data.runtime = runtime;
6725 data.remove = remove;
6726 data.remove_timer = remove_timer;
6727 data.debug_mode = debug_mode;
6728 data.debug_file = debug_file;
6729 data.username = username;
6730 data.quiet = quiet;
6731 data.outfile = outfile;
6732 data.outfile_format = outfile_format;
6733 data.outfile_autohex = outfile_autohex;
6734 data.hex_charset = hex_charset;
6735 data.hex_salt = hex_salt;
6736 data.hex_wordlist = hex_wordlist;
6737 data.separator = separator;
6738 data.rp_files = rp_files;
6739 data.rp_files_cnt = rp_files_cnt;
6740 data.rp_gen = rp_gen;
6741 data.rp_gen_seed = rp_gen_seed;
6742 data.force = force;
6743 data.benchmark = benchmark;
6744 data.benchmark_repeats = benchmark_repeats;
6745 data.skip = skip;
6746 data.limit = limit;
6747 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6748 data.powertune_enable = powertune_enable;
6749 #endif
6750 data.logfile_disable = logfile_disable;
6751 data.truecrypt_keyfiles = truecrypt_keyfiles;
6752 data.scrypt_tmto = scrypt_tmto;
6753 data.workload_profile = workload_profile;
6754
6755 /**
6756 * cpu affinity
6757 */
6758
6759 if (cpu_affinity)
6760 {
6761 set_cpu_affinity (cpu_affinity);
6762 }
6763
6764 if (rp_gen_seed_chgd == 0)
6765 {
6766 srand (proc_start);
6767 }
6768 else
6769 {
6770 srand (rp_gen_seed);
6771 }
6772
6773 /**
6774 * logfile init
6775 */
6776
6777 if (logfile_disable == 0)
6778 {
6779 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6780
6781 char *logfile = (char *) mymalloc (logfile_size);
6782
6783 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6784
6785 data.logfile = logfile;
6786
6787 char *topid = logfile_generate_topid ();
6788
6789 data.topid = topid;
6790 }
6791
6792 // logfile_append() checks for logfile_disable internally to make it easier from here
6793
6794 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6795 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6796 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6797 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6798 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6799 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6800 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6801 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6802 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6803 #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));
6804
6805 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6806 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6807 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6808 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6809 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6810 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6811 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6812 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6813
6814 logfile_top_msg ("START");
6815
6816 logfile_top_uint (attack_mode);
6817 logfile_top_uint (attack_kern);
6818 logfile_top_uint (benchmark);
6819 logfile_top_uint (benchmark_repeats);
6820 logfile_top_uint (bitmap_min);
6821 logfile_top_uint (bitmap_max);
6822 logfile_top_uint (debug_mode);
6823 logfile_top_uint (force);
6824 logfile_top_uint (kernel_accel);
6825 logfile_top_uint (kernel_loops);
6826 logfile_top_uint (gpu_temp_disable);
6827 #ifdef HAVE_HWMON
6828 logfile_top_uint (gpu_temp_abort);
6829 logfile_top_uint (gpu_temp_retain);
6830 #endif
6831 logfile_top_uint (hash_mode);
6832 logfile_top_uint (hex_charset);
6833 logfile_top_uint (hex_salt);
6834 logfile_top_uint (hex_wordlist);
6835 logfile_top_uint (increment);
6836 logfile_top_uint (increment_max);
6837 logfile_top_uint (increment_min);
6838 logfile_top_uint (keyspace);
6839 logfile_top_uint (left);
6840 logfile_top_uint (logfile_disable);
6841 logfile_top_uint (loopback);
6842 logfile_top_uint (markov_classic);
6843 logfile_top_uint (markov_disable);
6844 logfile_top_uint (markov_threshold);
6845 logfile_top_uint (outfile_autohex);
6846 logfile_top_uint (outfile_check_timer);
6847 logfile_top_uint (outfile_format);
6848 logfile_top_uint (potfile_disable);
6849 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6850 logfile_top_uint (powertune_enable);
6851 #endif
6852 logfile_top_uint (scrypt_tmto);
6853 logfile_top_uint (quiet);
6854 logfile_top_uint (remove);
6855 logfile_top_uint (remove_timer);
6856 logfile_top_uint (restore);
6857 logfile_top_uint (restore_disable);
6858 logfile_top_uint (restore_timer);
6859 logfile_top_uint (rp_gen);
6860 logfile_top_uint (rp_gen_func_max);
6861 logfile_top_uint (rp_gen_func_min);
6862 logfile_top_uint (rp_gen_seed);
6863 logfile_top_uint (runtime);
6864 logfile_top_uint (segment_size);
6865 logfile_top_uint (show);
6866 logfile_top_uint (status);
6867 logfile_top_uint (status_automat);
6868 logfile_top_uint (status_timer);
6869 logfile_top_uint (usage);
6870 logfile_top_uint (username);
6871 logfile_top_uint (version);
6872 logfile_top_uint (weak_hash_threshold);
6873 logfile_top_uint (workload_profile);
6874 logfile_top_uint64 (limit);
6875 logfile_top_uint64 (skip);
6876 logfile_top_char (separator);
6877 logfile_top_string (cpu_affinity);
6878 logfile_top_string (custom_charset_1);
6879 logfile_top_string (custom_charset_2);
6880 logfile_top_string (custom_charset_3);
6881 logfile_top_string (custom_charset_4);
6882 logfile_top_string (debug_file);
6883 logfile_top_string (opencl_devices);
6884 logfile_top_string (opencl_platforms);
6885 logfile_top_string (opencl_device_types);
6886 logfile_top_uint (opencl_vector_width);
6887 logfile_top_string (induction_dir);
6888 logfile_top_string (markov_hcstat);
6889 logfile_top_string (outfile);
6890 logfile_top_string (outfile_check_dir);
6891 logfile_top_string (rule_buf_l);
6892 logfile_top_string (rule_buf_r);
6893 logfile_top_string (session);
6894 logfile_top_string (truecrypt_keyfiles);
6895
6896 /**
6897 * Init OpenCL library loader
6898 */
6899
6900 if (keyspace == 0)
6901 {
6902 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6903
6904 ocl_init (ocl);
6905
6906 data.ocl = ocl;
6907 }
6908
6909 /**
6910 * OpenCL platform selection
6911 */
6912
6913 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6914
6915 /**
6916 * OpenCL device selection
6917 */
6918
6919 u32 devices_filter = setup_devices_filter (opencl_devices);
6920
6921 /**
6922 * OpenCL device type selection
6923 */
6924
6925 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6926
6927 /**
6928 * benchmark
6929 */
6930
6931 if (benchmark == 1)
6932 {
6933 /**
6934 * disable useless stuff for benchmark
6935 */
6936
6937 status_timer = 0;
6938 restore_timer = 0;
6939 restore_disable = 1;
6940 potfile_disable = 1;
6941 weak_hash_threshold = 0;
6942 gpu_temp_disable = 1;
6943
6944 data.status_timer = status_timer;
6945 data.restore_timer = restore_timer;
6946 data.restore_disable = restore_disable;
6947
6948 /**
6949 * force attack mode to be bruteforce
6950 */
6951
6952 attack_mode = ATTACK_MODE_BF;
6953 attack_kern = ATTACK_KERN_BF;
6954
6955 if (workload_profile_chgd == 0)
6956 {
6957 workload_profile = 3;
6958
6959 data.workload_profile = workload_profile;
6960 }
6961 }
6962
6963 /**
6964 * config
6965 */
6966
6967 uint hash_type = 0;
6968 uint salt_type = 0;
6969 uint attack_exec = 0;
6970 uint opts_type = 0;
6971 uint kern_type = 0;
6972 uint dgst_size = 0;
6973 uint esalt_size = 0;
6974 uint opti_type = 0;
6975 uint dgst_pos0 = -1;
6976 uint dgst_pos1 = -1;
6977 uint dgst_pos2 = -1;
6978 uint dgst_pos3 = -1;
6979
6980 int (*parse_func) (char *, uint, hash_t *);
6981 int (*sort_by_digest) (const void *, const void *);
6982
6983 uint algorithm_pos = 0;
6984 uint algorithm_max = 1;
6985
6986 uint *algorithms = default_benchmark_algorithms;
6987
6988 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6989
6990 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6991 {
6992 /*
6993 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6994 * the following algos are skipped entirely
6995 */
6996
6997 if (algorithm_pos > 0)
6998 {
6999 local_free (rd);
7000
7001 rd = init_restore (argc, argv);
7002
7003 data.rd = rd;
7004 }
7005
7006 /**
7007 * update hash_mode in case of multihash benchmark
7008 */
7009
7010 if (benchmark == 1)
7011 {
7012 if (hash_mode_chgd == 0)
7013 {
7014 hash_mode = algorithms[algorithm_pos];
7015
7016 data.hash_mode = hash_mode;
7017 }
7018
7019 quiet = 1;
7020
7021 data.quiet = quiet;
7022 }
7023
7024 switch (hash_mode)
7025 {
7026 case 0: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_NONE;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_LE
7030 | OPTS_TYPE_PT_ADD80
7031 | OPTS_TYPE_PT_ADDBITS14;
7032 kern_type = KERN_TYPE_MD5;
7033 dgst_size = DGST_SIZE_4_4;
7034 parse_func = md5_parse_hash;
7035 sort_by_digest = sort_by_digest_4_4;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_PRECOMPUTE_INIT
7038 | OPTI_TYPE_PRECOMPUTE_MERKLE
7039 | OPTI_TYPE_MEET_IN_MIDDLE
7040 | OPTI_TYPE_EARLY_SKIP
7041 | OPTI_TYPE_NOT_ITERATED
7042 | OPTI_TYPE_NOT_SALTED
7043 | OPTI_TYPE_RAW_HASH;
7044 dgst_pos0 = 0;
7045 dgst_pos1 = 3;
7046 dgst_pos2 = 2;
7047 dgst_pos3 = 1;
7048 break;
7049
7050 case 10: hash_type = HASH_TYPE_MD5;
7051 salt_type = SALT_TYPE_INTERN;
7052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7053 opts_type = OPTS_TYPE_PT_GENERATE_LE
7054 | OPTS_TYPE_ST_ADD80
7055 | OPTS_TYPE_ST_ADDBITS14;
7056 kern_type = KERN_TYPE_MD5_PWSLT;
7057 dgst_size = DGST_SIZE_4_4;
7058 parse_func = md5s_parse_hash;
7059 sort_by_digest = sort_by_digest_4_4;
7060 opti_type = OPTI_TYPE_ZERO_BYTE
7061 | OPTI_TYPE_PRECOMPUTE_INIT
7062 | OPTI_TYPE_PRECOMPUTE_MERKLE
7063 | OPTI_TYPE_MEET_IN_MIDDLE
7064 | OPTI_TYPE_EARLY_SKIP
7065 | OPTI_TYPE_NOT_ITERATED
7066 | OPTI_TYPE_APPENDED_SALT
7067 | OPTI_TYPE_RAW_HASH;
7068 dgst_pos0 = 0;
7069 dgst_pos1 = 3;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 11: hash_type = HASH_TYPE_MD5;
7075 salt_type = SALT_TYPE_INTERN;
7076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7077 opts_type = OPTS_TYPE_PT_GENERATE_LE
7078 | OPTS_TYPE_ST_ADD80
7079 | OPTS_TYPE_ST_ADDBITS14;
7080 kern_type = KERN_TYPE_MD5_PWSLT;
7081 dgst_size = DGST_SIZE_4_4;
7082 parse_func = joomla_parse_hash;
7083 sort_by_digest = sort_by_digest_4_4;
7084 opti_type = OPTI_TYPE_ZERO_BYTE
7085 | OPTI_TYPE_PRECOMPUTE_INIT
7086 | OPTI_TYPE_PRECOMPUTE_MERKLE
7087 | OPTI_TYPE_MEET_IN_MIDDLE
7088 | OPTI_TYPE_EARLY_SKIP
7089 | OPTI_TYPE_NOT_ITERATED
7090 | OPTI_TYPE_APPENDED_SALT
7091 | OPTI_TYPE_RAW_HASH;
7092 dgst_pos0 = 0;
7093 dgst_pos1 = 3;
7094 dgst_pos2 = 2;
7095 dgst_pos3 = 1;
7096 break;
7097
7098 case 12: hash_type = HASH_TYPE_MD5;
7099 salt_type = SALT_TYPE_INTERN;
7100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7101 opts_type = OPTS_TYPE_PT_GENERATE_LE
7102 | OPTS_TYPE_ST_ADD80
7103 | OPTS_TYPE_ST_ADDBITS14;
7104 kern_type = KERN_TYPE_MD5_PWSLT;
7105 dgst_size = DGST_SIZE_4_4;
7106 parse_func = postgresql_parse_hash;
7107 sort_by_digest = sort_by_digest_4_4;
7108 opti_type = OPTI_TYPE_ZERO_BYTE
7109 | OPTI_TYPE_PRECOMPUTE_INIT
7110 | OPTI_TYPE_PRECOMPUTE_MERKLE
7111 | OPTI_TYPE_MEET_IN_MIDDLE
7112 | OPTI_TYPE_EARLY_SKIP
7113 | OPTI_TYPE_NOT_ITERATED
7114 | OPTI_TYPE_APPENDED_SALT
7115 | OPTI_TYPE_RAW_HASH;
7116 dgst_pos0 = 0;
7117 dgst_pos1 = 3;
7118 dgst_pos2 = 2;
7119 dgst_pos3 = 1;
7120 break;
7121
7122 case 20: hash_type = HASH_TYPE_MD5;
7123 salt_type = SALT_TYPE_INTERN;
7124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7125 opts_type = OPTS_TYPE_PT_GENERATE_LE
7126 | OPTS_TYPE_PT_ADD80
7127 | OPTS_TYPE_PT_ADDBITS14;
7128 kern_type = KERN_TYPE_MD5_SLTPW;
7129 dgst_size = DGST_SIZE_4_4;
7130 parse_func = md5s_parse_hash;
7131 sort_by_digest = sort_by_digest_4_4;
7132 opti_type = OPTI_TYPE_ZERO_BYTE
7133 | OPTI_TYPE_PRECOMPUTE_INIT
7134 | OPTI_TYPE_PRECOMPUTE_MERKLE
7135 | OPTI_TYPE_EARLY_SKIP
7136 | OPTI_TYPE_NOT_ITERATED
7137 | OPTI_TYPE_PREPENDED_SALT
7138 | OPTI_TYPE_RAW_HASH;
7139 dgst_pos0 = 0;
7140 dgst_pos1 = 3;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 21: hash_type = HASH_TYPE_MD5;
7146 salt_type = SALT_TYPE_INTERN;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_LE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS14;
7151 kern_type = KERN_TYPE_MD5_SLTPW;
7152 dgst_size = DGST_SIZE_4_4;
7153 parse_func = osc_parse_hash;
7154 sort_by_digest = sort_by_digest_4_4;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_PREPENDED_SALT
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 0;
7163 dgst_pos1 = 3;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 22: hash_type = HASH_TYPE_MD5;
7169 salt_type = SALT_TYPE_EMBEDDED;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_LE
7172 | OPTS_TYPE_PT_ADD80
7173 | OPTS_TYPE_PT_ADDBITS14;
7174 kern_type = KERN_TYPE_MD5_SLTPW;
7175 dgst_size = DGST_SIZE_4_4;
7176 parse_func = netscreen_parse_hash;
7177 sort_by_digest = sort_by_digest_4_4;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_PREPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 0;
7186 dgst_pos1 = 3;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 23: hash_type = HASH_TYPE_MD5;
7192 salt_type = SALT_TYPE_EMBEDDED;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_LE
7195 | OPTS_TYPE_PT_ADD80
7196 | OPTS_TYPE_PT_ADDBITS14;
7197 kern_type = KERN_TYPE_MD5_SLTPW;
7198 dgst_size = DGST_SIZE_4_4;
7199 parse_func = skype_parse_hash;
7200 sort_by_digest = sort_by_digest_4_4;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_PREPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 0;
7209 dgst_pos1 = 3;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 30: hash_type = HASH_TYPE_MD5;
7215 salt_type = SALT_TYPE_INTERN;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_LE
7218 | OPTS_TYPE_PT_UNICODE
7219 | OPTS_TYPE_ST_ADD80
7220 | OPTS_TYPE_ST_ADDBITS14;
7221 kern_type = KERN_TYPE_MD5_PWUSLT;
7222 dgst_size = DGST_SIZE_4_4;
7223 parse_func = md5s_parse_hash;
7224 sort_by_digest = sort_by_digest_4_4;
7225 opti_type = OPTI_TYPE_ZERO_BYTE
7226 | OPTI_TYPE_PRECOMPUTE_INIT
7227 | OPTI_TYPE_PRECOMPUTE_MERKLE
7228 | OPTI_TYPE_MEET_IN_MIDDLE
7229 | OPTI_TYPE_EARLY_SKIP
7230 | OPTI_TYPE_NOT_ITERATED
7231 | OPTI_TYPE_APPENDED_SALT
7232 | OPTI_TYPE_RAW_HASH;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 3;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 1;
7237 break;
7238
7239 case 40: hash_type = HASH_TYPE_MD5;
7240 salt_type = SALT_TYPE_INTERN;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = OPTS_TYPE_PT_GENERATE_LE
7243 | OPTS_TYPE_PT_ADD80
7244 | OPTS_TYPE_PT_ADDBITS14
7245 | OPTS_TYPE_PT_UNICODE;
7246 kern_type = KERN_TYPE_MD5_SLTPWU;
7247 dgst_size = DGST_SIZE_4_4;
7248 parse_func = md5s_parse_hash;
7249 sort_by_digest = sort_by_digest_4_4;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_PRECOMPUTE_INIT
7252 | OPTI_TYPE_PRECOMPUTE_MERKLE
7253 | OPTI_TYPE_EARLY_SKIP
7254 | OPTI_TYPE_NOT_ITERATED
7255 | OPTI_TYPE_PREPENDED_SALT
7256 | OPTI_TYPE_RAW_HASH;
7257 dgst_pos0 = 0;
7258 dgst_pos1 = 3;
7259 dgst_pos2 = 2;
7260 dgst_pos3 = 1;
7261 break;
7262
7263 case 50: hash_type = HASH_TYPE_MD5;
7264 salt_type = SALT_TYPE_INTERN;
7265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7266 opts_type = OPTS_TYPE_PT_GENERATE_LE
7267 | OPTS_TYPE_ST_ADD80
7268 | OPTS_TYPE_ST_ADDBITS14;
7269 kern_type = KERN_TYPE_HMACMD5_PW;
7270 dgst_size = DGST_SIZE_4_4;
7271 parse_func = hmacmd5_parse_hash;
7272 sort_by_digest = sort_by_digest_4_4;
7273 opti_type = OPTI_TYPE_ZERO_BYTE
7274 | OPTI_TYPE_NOT_ITERATED;
7275 dgst_pos0 = 0;
7276 dgst_pos1 = 3;
7277 dgst_pos2 = 2;
7278 dgst_pos3 = 1;
7279 break;
7280
7281 case 60: hash_type = HASH_TYPE_MD5;
7282 salt_type = SALT_TYPE_INTERN;
7283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7284 opts_type = OPTS_TYPE_PT_GENERATE_LE
7285 | OPTS_TYPE_PT_ADD80
7286 | OPTS_TYPE_PT_ADDBITS14;
7287 kern_type = KERN_TYPE_HMACMD5_SLT;
7288 dgst_size = DGST_SIZE_4_4;
7289 parse_func = hmacmd5_parse_hash;
7290 sort_by_digest = sort_by_digest_4_4;
7291 opti_type = OPTI_TYPE_ZERO_BYTE
7292 | OPTI_TYPE_NOT_ITERATED;
7293 dgst_pos0 = 0;
7294 dgst_pos1 = 3;
7295 dgst_pos2 = 2;
7296 dgst_pos3 = 1;
7297 break;
7298
7299 case 100: hash_type = HASH_TYPE_SHA1;
7300 salt_type = SALT_TYPE_NONE;
7301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7302 opts_type = OPTS_TYPE_PT_GENERATE_BE
7303 | OPTS_TYPE_PT_ADD80
7304 | OPTS_TYPE_PT_ADDBITS15;
7305 kern_type = KERN_TYPE_SHA1;
7306 dgst_size = DGST_SIZE_4_5;
7307 parse_func = sha1_parse_hash;
7308 sort_by_digest = sort_by_digest_4_5;
7309 opti_type = OPTI_TYPE_ZERO_BYTE
7310 | OPTI_TYPE_PRECOMPUTE_INIT
7311 | OPTI_TYPE_PRECOMPUTE_MERKLE
7312 | OPTI_TYPE_EARLY_SKIP
7313 | OPTI_TYPE_NOT_ITERATED
7314 | OPTI_TYPE_NOT_SALTED
7315 | OPTI_TYPE_RAW_HASH;
7316 dgst_pos0 = 3;
7317 dgst_pos1 = 4;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 1;
7320 break;
7321
7322 case 101: hash_type = HASH_TYPE_SHA1;
7323 salt_type = SALT_TYPE_NONE;
7324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7325 opts_type = OPTS_TYPE_PT_GENERATE_BE
7326 | OPTS_TYPE_PT_ADD80
7327 | OPTS_TYPE_PT_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA1;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = sha1b64_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_NOT_SALTED
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 110: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_INTERN;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA1_PWSLT;
7352 dgst_size = DGST_SIZE_4_5;
7353 parse_func = sha1s_parse_hash;
7354 sort_by_digest = sort_by_digest_4_5;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_APPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 4;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 1;
7366 break;
7367
7368 case 111: hash_type = HASH_TYPE_SHA1;
7369 salt_type = SALT_TYPE_EMBEDDED;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA1_PWSLT;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = sha1b64s_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 112: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_ST_ADD80
7396 | OPTS_TYPE_ST_ADDBITS15
7397 | OPTS_TYPE_ST_HEX;
7398 kern_type = KERN_TYPE_SHA1_PWSLT;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = oracles_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_APPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 4;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 1;
7413 break;
7414
7415 case 120: hash_type = HASH_TYPE_SHA1;
7416 salt_type = SALT_TYPE_INTERN;
7417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_ADD80
7420 | OPTS_TYPE_PT_ADDBITS15;
7421 kern_type = KERN_TYPE_SHA1_SLTPW;
7422 dgst_size = DGST_SIZE_4_5;
7423 parse_func = sha1s_parse_hash;
7424 sort_by_digest = sort_by_digest_4_5;
7425 opti_type = OPTI_TYPE_ZERO_BYTE
7426 | OPTI_TYPE_PRECOMPUTE_INIT
7427 | OPTI_TYPE_PRECOMPUTE_MERKLE
7428 | OPTI_TYPE_EARLY_SKIP
7429 | OPTI_TYPE_NOT_ITERATED
7430 | OPTI_TYPE_PREPENDED_SALT
7431 | OPTI_TYPE_RAW_HASH;
7432 dgst_pos0 = 3;
7433 dgst_pos1 = 4;
7434 dgst_pos2 = 2;
7435 dgst_pos3 = 1;
7436 break;
7437
7438 case 121: hash_type = HASH_TYPE_SHA1;
7439 salt_type = SALT_TYPE_INTERN;
7440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7441 opts_type = OPTS_TYPE_PT_GENERATE_BE
7442 | OPTS_TYPE_PT_ADD80
7443 | OPTS_TYPE_PT_ADDBITS15
7444 | OPTS_TYPE_ST_LOWER;
7445 kern_type = KERN_TYPE_SHA1_SLTPW;
7446 dgst_size = DGST_SIZE_4_5;
7447 parse_func = smf_parse_hash;
7448 sort_by_digest = sort_by_digest_4_5;
7449 opti_type = OPTI_TYPE_ZERO_BYTE
7450 | OPTI_TYPE_PRECOMPUTE_INIT
7451 | OPTI_TYPE_PRECOMPUTE_MERKLE
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_PREPENDED_SALT
7455 | OPTI_TYPE_RAW_HASH;
7456 dgst_pos0 = 3;
7457 dgst_pos1 = 4;
7458 dgst_pos2 = 2;
7459 dgst_pos3 = 1;
7460 break;
7461
7462 case 122: hash_type = HASH_TYPE_SHA1;
7463 salt_type = SALT_TYPE_EMBEDDED;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = OPTS_TYPE_PT_GENERATE_BE
7466 | OPTS_TYPE_PT_ADD80
7467 | OPTS_TYPE_PT_ADDBITS15
7468 | OPTS_TYPE_ST_HEX;
7469 kern_type = KERN_TYPE_SHA1_SLTPW;
7470 dgst_size = DGST_SIZE_4_5;
7471 parse_func = osx1_parse_hash;
7472 sort_by_digest = sort_by_digest_4_5;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_PREPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 3;
7481 dgst_pos1 = 4;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 124: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_EMBEDDED;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS15;
7492 kern_type = KERN_TYPE_SHA1_SLTPW;
7493 dgst_size = DGST_SIZE_4_5;
7494 parse_func = djangosha1_parse_hash;
7495 sort_by_digest = sort_by_digest_4_5;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_PREPENDED_SALT
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 3;
7504 dgst_pos1 = 4;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 1;
7507 break;
7508
7509 case 130: hash_type = HASH_TYPE_SHA1;
7510 salt_type = SALT_TYPE_INTERN;
7511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7512 opts_type = OPTS_TYPE_PT_GENERATE_BE
7513 | OPTS_TYPE_PT_UNICODE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS15;
7516 kern_type = KERN_TYPE_SHA1_PWUSLT;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = sha1s_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_PRECOMPUTE_INIT
7522 | OPTI_TYPE_PRECOMPUTE_MERKLE
7523 | OPTI_TYPE_EARLY_SKIP
7524 | OPTI_TYPE_NOT_ITERATED
7525 | OPTI_TYPE_APPENDED_SALT
7526 | OPTI_TYPE_RAW_HASH;
7527 dgst_pos0 = 3;
7528 dgst_pos1 = 4;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 1;
7531 break;
7532
7533 case 131: hash_type = HASH_TYPE_SHA1;
7534 salt_type = SALT_TYPE_EMBEDDED;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_BE
7537 | OPTS_TYPE_PT_UNICODE
7538 | OPTS_TYPE_PT_UPPER
7539 | OPTS_TYPE_ST_ADD80
7540 | OPTS_TYPE_ST_ADDBITS15
7541 | OPTS_TYPE_ST_HEX;
7542 kern_type = KERN_TYPE_SHA1_PWUSLT;
7543 dgst_size = DGST_SIZE_4_5;
7544 parse_func = mssql2000_parse_hash;
7545 sort_by_digest = sort_by_digest_4_5;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_PRECOMPUTE_INIT
7548 | OPTI_TYPE_PRECOMPUTE_MERKLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_APPENDED_SALT
7552 | OPTI_TYPE_RAW_HASH;
7553 dgst_pos0 = 3;
7554 dgst_pos1 = 4;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 132: hash_type = HASH_TYPE_SHA1;
7560 salt_type = SALT_TYPE_EMBEDDED;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_PT_UNICODE
7564 | OPTS_TYPE_ST_ADD80
7565 | OPTS_TYPE_ST_ADDBITS15
7566 | OPTS_TYPE_ST_HEX;
7567 kern_type = KERN_TYPE_SHA1_PWUSLT;
7568 dgst_size = DGST_SIZE_4_5;
7569 parse_func = mssql2005_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_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_APPENDED_SALT
7577 | OPTI_TYPE_RAW_HASH;
7578 dgst_pos0 = 3;
7579 dgst_pos1 = 4;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 1;
7582 break;
7583
7584 case 133: hash_type = HASH_TYPE_SHA1;
7585 salt_type = SALT_TYPE_EMBEDDED;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_BE
7588 | OPTS_TYPE_PT_UNICODE
7589 | OPTS_TYPE_ST_ADD80
7590 | OPTS_TYPE_ST_ADDBITS15;
7591 kern_type = KERN_TYPE_SHA1_PWUSLT;
7592 dgst_size = DGST_SIZE_4_5;
7593 parse_func = peoplesoft_parse_hash;
7594 sort_by_digest = sort_by_digest_4_5;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_PRECOMPUTE_INIT
7597 | OPTI_TYPE_PRECOMPUTE_MERKLE
7598 | OPTI_TYPE_EARLY_SKIP
7599 | OPTI_TYPE_NOT_ITERATED
7600 | OPTI_TYPE_APPENDED_SALT
7601 | OPTI_TYPE_RAW_HASH;
7602 dgst_pos0 = 3;
7603 dgst_pos1 = 4;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 1;
7606 break;
7607
7608 case 140: hash_type = HASH_TYPE_SHA1;
7609 salt_type = SALT_TYPE_INTERN;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_BE
7612 | OPTS_TYPE_PT_ADD80
7613 | OPTS_TYPE_PT_ADDBITS15
7614 | OPTS_TYPE_PT_UNICODE;
7615 kern_type = KERN_TYPE_SHA1_SLTPWU;
7616 dgst_size = DGST_SIZE_4_5;
7617 parse_func = sha1s_parse_hash;
7618 sort_by_digest = sort_by_digest_4_5;
7619 opti_type = OPTI_TYPE_ZERO_BYTE
7620 | OPTI_TYPE_PRECOMPUTE_INIT
7621 | OPTI_TYPE_PRECOMPUTE_MERKLE
7622 | OPTI_TYPE_EARLY_SKIP
7623 | OPTI_TYPE_NOT_ITERATED
7624 | OPTI_TYPE_PREPENDED_SALT
7625 | OPTI_TYPE_RAW_HASH;
7626 dgst_pos0 = 3;
7627 dgst_pos1 = 4;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 1;
7630 break;
7631
7632 case 141: hash_type = HASH_TYPE_SHA1;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_BE
7636 | OPTS_TYPE_PT_ADD80
7637 | OPTS_TYPE_PT_ADDBITS15
7638 | OPTS_TYPE_PT_UNICODE
7639 | OPTS_TYPE_ST_BASE64;
7640 kern_type = KERN_TYPE_SHA1_SLTPWU;
7641 dgst_size = DGST_SIZE_4_5;
7642 parse_func = episerver_parse_hash;
7643 sort_by_digest = sort_by_digest_4_5;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_PREPENDED_SALT
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 3;
7652 dgst_pos1 = 4;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 1;
7655 break;
7656
7657 case 150: hash_type = HASH_TYPE_SHA1;
7658 salt_type = SALT_TYPE_INTERN;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_ST_ADD80
7662 | OPTS_TYPE_ST_ADDBITS15;
7663 kern_type = KERN_TYPE_HMACSHA1_PW;
7664 dgst_size = DGST_SIZE_4_5;
7665 parse_func = hmacsha1_parse_hash;
7666 sort_by_digest = sort_by_digest_4_5;
7667 opti_type = OPTI_TYPE_ZERO_BYTE
7668 | OPTI_TYPE_NOT_ITERATED;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 4;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 1;
7673 break;
7674
7675 case 160: hash_type = HASH_TYPE_SHA1;
7676 salt_type = SALT_TYPE_INTERN;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_ADD80
7680 | OPTS_TYPE_PT_ADDBITS15;
7681 kern_type = KERN_TYPE_HMACSHA1_SLT;
7682 dgst_size = DGST_SIZE_4_5;
7683 parse_func = hmacsha1_parse_hash;
7684 sort_by_digest = sort_by_digest_4_5;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_NOT_ITERATED;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 4;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 190: hash_type = HASH_TYPE_SHA1;
7694 salt_type = SALT_TYPE_NONE;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS15;
7699 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = sha1linkedin_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_EARLY_SKIP
7706 | OPTI_TYPE_NOT_ITERATED
7707 | OPTI_TYPE_NOT_SALTED;
7708 dgst_pos0 = 0;
7709 dgst_pos1 = 4;
7710 dgst_pos2 = 3;
7711 dgst_pos3 = 2;
7712 break;
7713
7714 case 200: hash_type = HASH_TYPE_MYSQL;
7715 salt_type = SALT_TYPE_NONE;
7716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7717 opts_type = 0;
7718 kern_type = KERN_TYPE_MYSQL;
7719 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7720 parse_func = mysql323_parse_hash;
7721 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7722 opti_type = OPTI_TYPE_ZERO_BYTE;
7723 dgst_pos0 = 0;
7724 dgst_pos1 = 1;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 3;
7727 break;
7728
7729 case 300: hash_type = HASH_TYPE_SHA1;
7730 salt_type = SALT_TYPE_NONE;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_PT_ADD80
7734 | OPTS_TYPE_PT_ADDBITS15;
7735 kern_type = KERN_TYPE_MYSQL41;
7736 dgst_size = DGST_SIZE_4_5;
7737 parse_func = sha1_parse_hash;
7738 sort_by_digest = sort_by_digest_4_5;
7739 opti_type = OPTI_TYPE_ZERO_BYTE
7740 | OPTI_TYPE_PRECOMPUTE_INIT
7741 | OPTI_TYPE_PRECOMPUTE_MERKLE
7742 | OPTI_TYPE_EARLY_SKIP
7743 | OPTI_TYPE_NOT_ITERATED
7744 | OPTI_TYPE_NOT_SALTED;
7745 dgst_pos0 = 3;
7746 dgst_pos1 = 4;
7747 dgst_pos2 = 2;
7748 dgst_pos3 = 1;
7749 break;
7750
7751 case 400: hash_type = HASH_TYPE_MD5;
7752 salt_type = SALT_TYPE_EMBEDDED;
7753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7755 kern_type = KERN_TYPE_PHPASS;
7756 dgst_size = DGST_SIZE_4_4;
7757 parse_func = phpass_parse_hash;
7758 sort_by_digest = sort_by_digest_4_4;
7759 opti_type = OPTI_TYPE_ZERO_BYTE;
7760 dgst_pos0 = 0;
7761 dgst_pos1 = 1;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 3;
7764 break;
7765
7766 case 500: hash_type = HASH_TYPE_MD5;
7767 salt_type = SALT_TYPE_EMBEDDED;
7768 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7770 kern_type = KERN_TYPE_MD5CRYPT;
7771 dgst_size = DGST_SIZE_4_4;
7772 parse_func = md5crypt_parse_hash;
7773 sort_by_digest = sort_by_digest_4_4;
7774 opti_type = OPTI_TYPE_ZERO_BYTE;
7775 dgst_pos0 = 0;
7776 dgst_pos1 = 1;
7777 dgst_pos2 = 2;
7778 dgst_pos3 = 3;
7779 break;
7780
7781 case 501: hash_type = HASH_TYPE_MD5;
7782 salt_type = SALT_TYPE_EMBEDDED;
7783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_LE
7785 | OPTS_TYPE_HASH_COPY;
7786 kern_type = KERN_TYPE_MD5CRYPT;
7787 dgst_size = DGST_SIZE_4_4;
7788 parse_func = juniper_parse_hash;
7789 sort_by_digest = sort_by_digest_4_4;
7790 opti_type = OPTI_TYPE_ZERO_BYTE;
7791 dgst_pos0 = 0;
7792 dgst_pos1 = 1;
7793 dgst_pos2 = 2;
7794 dgst_pos3 = 3;
7795 break;
7796
7797 case 900: hash_type = HASH_TYPE_MD4;
7798 salt_type = SALT_TYPE_NONE;
7799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7800 opts_type = OPTS_TYPE_PT_GENERATE_LE
7801 | OPTS_TYPE_PT_ADD80
7802 | OPTS_TYPE_PT_ADDBITS14;
7803 kern_type = KERN_TYPE_MD4;
7804 dgst_size = DGST_SIZE_4_4;
7805 parse_func = md4_parse_hash;
7806 sort_by_digest = sort_by_digest_4_4;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_MEET_IN_MIDDLE
7811 | OPTI_TYPE_EARLY_SKIP
7812 | OPTI_TYPE_NOT_ITERATED
7813 | OPTI_TYPE_NOT_SALTED
7814 | OPTI_TYPE_RAW_HASH;
7815 dgst_pos0 = 0;
7816 dgst_pos1 = 3;
7817 dgst_pos2 = 2;
7818 dgst_pos3 = 1;
7819 break;
7820
7821 case 1000: hash_type = HASH_TYPE_MD4;
7822 salt_type = SALT_TYPE_NONE;
7823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_LE
7825 | OPTS_TYPE_PT_ADD80
7826 | OPTS_TYPE_PT_ADDBITS14
7827 | OPTS_TYPE_PT_UNICODE;
7828 kern_type = KERN_TYPE_MD4_PWU;
7829 dgst_size = DGST_SIZE_4_4;
7830 parse_func = md4_parse_hash;
7831 sort_by_digest = sort_by_digest_4_4;
7832 opti_type = OPTI_TYPE_ZERO_BYTE
7833 | OPTI_TYPE_PRECOMPUTE_INIT
7834 | OPTI_TYPE_PRECOMPUTE_MERKLE
7835 | OPTI_TYPE_MEET_IN_MIDDLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED
7838 | OPTI_TYPE_NOT_SALTED
7839 | OPTI_TYPE_RAW_HASH;
7840 dgst_pos0 = 0;
7841 dgst_pos1 = 3;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 1;
7844 break;
7845
7846 case 1100: hash_type = HASH_TYPE_MD4;
7847 salt_type = SALT_TYPE_INTERN;
7848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_LE
7850 | OPTS_TYPE_PT_ADD80
7851 | OPTS_TYPE_PT_ADDBITS14
7852 | OPTS_TYPE_PT_UNICODE
7853 | OPTS_TYPE_ST_ADD80
7854 | OPTS_TYPE_ST_UNICODE
7855 | OPTS_TYPE_ST_LOWER;
7856 kern_type = KERN_TYPE_MD44_PWUSLT;
7857 dgst_size = DGST_SIZE_4_4;
7858 parse_func = dcc_parse_hash;
7859 sort_by_digest = sort_by_digest_4_4;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_PRECOMPUTE_INIT
7862 | OPTI_TYPE_PRECOMPUTE_MERKLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED;
7865 dgst_pos0 = 0;
7866 dgst_pos1 = 3;
7867 dgst_pos2 = 2;
7868 dgst_pos3 = 1;
7869 break;
7870
7871 case 1400: hash_type = HASH_TYPE_SHA256;
7872 salt_type = SALT_TYPE_NONE;
7873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7874 opts_type = OPTS_TYPE_PT_GENERATE_BE
7875 | OPTS_TYPE_PT_ADD80
7876 | OPTS_TYPE_PT_ADDBITS15;
7877 kern_type = KERN_TYPE_SHA256;
7878 dgst_size = DGST_SIZE_4_8;
7879 parse_func = sha256_parse_hash;
7880 sort_by_digest = sort_by_digest_4_8;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_NOT_SALTED
7887 | OPTI_TYPE_RAW_HASH;
7888 dgst_pos0 = 3;
7889 dgst_pos1 = 7;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 6;
7892 break;
7893
7894 case 1410: hash_type = HASH_TYPE_SHA256;
7895 salt_type = SALT_TYPE_INTERN;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_BE
7898 | OPTS_TYPE_ST_ADD80
7899 | OPTS_TYPE_ST_ADDBITS15;
7900 kern_type = KERN_TYPE_SHA256_PWSLT;
7901 dgst_size = DGST_SIZE_4_8;
7902 parse_func = sha256s_parse_hash;
7903 sort_by_digest = sort_by_digest_4_8;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED
7909 | OPTI_TYPE_APPENDED_SALT
7910 | OPTI_TYPE_RAW_HASH;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 7;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 6;
7915 break;
7916
7917 case 1420: hash_type = HASH_TYPE_SHA256;
7918 salt_type = SALT_TYPE_INTERN;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS15;
7923 kern_type = KERN_TYPE_SHA256_SLTPW;
7924 dgst_size = DGST_SIZE_4_8;
7925 parse_func = sha256s_parse_hash;
7926 sort_by_digest = sort_by_digest_4_8;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_PRECOMPUTE_INIT
7929 | OPTI_TYPE_PRECOMPUTE_MERKLE
7930 | OPTI_TYPE_EARLY_SKIP
7931 | OPTI_TYPE_NOT_ITERATED
7932 | OPTI_TYPE_PREPENDED_SALT
7933 | OPTI_TYPE_RAW_HASH;
7934 dgst_pos0 = 3;
7935 dgst_pos1 = 7;
7936 dgst_pos2 = 2;
7937 dgst_pos3 = 6;
7938 break;
7939
7940 case 1421: hash_type = HASH_TYPE_SHA256;
7941 salt_type = SALT_TYPE_EMBEDDED;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_PT_ADD80
7945 | OPTS_TYPE_PT_ADDBITS15;
7946 kern_type = KERN_TYPE_SHA256_SLTPW;
7947 dgst_size = DGST_SIZE_4_8;
7948 parse_func = hmailserver_parse_hash;
7949 sort_by_digest = sort_by_digest_4_8;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_PREPENDED_SALT
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 3;
7958 dgst_pos1 = 7;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 6;
7961 break;
7962
7963 case 1430: hash_type = HASH_TYPE_SHA256;
7964 salt_type = SALT_TYPE_INTERN;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_UNICODE
7968 | OPTS_TYPE_ST_ADD80
7969 | OPTS_TYPE_ST_ADDBITS15;
7970 kern_type = KERN_TYPE_SHA256_PWUSLT;
7971 dgst_size = DGST_SIZE_4_8;
7972 parse_func = sha256s_parse_hash;
7973 sort_by_digest = sort_by_digest_4_8;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_PRECOMPUTE_INIT
7976 | OPTI_TYPE_PRECOMPUTE_MERKLE
7977 | OPTI_TYPE_EARLY_SKIP
7978 | OPTI_TYPE_NOT_ITERATED
7979 | OPTI_TYPE_APPENDED_SALT
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 3;
7982 dgst_pos1 = 7;
7983 dgst_pos2 = 2;
7984 dgst_pos3 = 6;
7985 break;
7986
7987 case 1440: hash_type = HASH_TYPE_SHA256;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_ADD80
7992 | OPTS_TYPE_PT_ADDBITS15
7993 | OPTS_TYPE_PT_UNICODE;
7994 kern_type = KERN_TYPE_SHA256_SLTPWU;
7995 dgst_size = DGST_SIZE_4_8;
7996 parse_func = sha256s_parse_hash;
7997 sort_by_digest = sort_by_digest_4_8;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_PREPENDED_SALT
8004 | OPTI_TYPE_RAW_HASH;
8005 dgst_pos0 = 3;
8006 dgst_pos1 = 7;
8007 dgst_pos2 = 2;
8008 dgst_pos3 = 6;
8009 break;
8010
8011 case 1441: hash_type = HASH_TYPE_SHA256;
8012 salt_type = SALT_TYPE_EMBEDDED;
8013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8014 opts_type = OPTS_TYPE_PT_GENERATE_BE
8015 | OPTS_TYPE_PT_ADD80
8016 | OPTS_TYPE_PT_ADDBITS15
8017 | OPTS_TYPE_PT_UNICODE
8018 | OPTS_TYPE_ST_BASE64;
8019 kern_type = KERN_TYPE_SHA256_SLTPWU;
8020 dgst_size = DGST_SIZE_4_8;
8021 parse_func = episerver4_parse_hash;
8022 sort_by_digest = sort_by_digest_4_8;
8023 opti_type = OPTI_TYPE_ZERO_BYTE
8024 | OPTI_TYPE_PRECOMPUTE_INIT
8025 | OPTI_TYPE_PRECOMPUTE_MERKLE
8026 | OPTI_TYPE_EARLY_SKIP
8027 | OPTI_TYPE_NOT_ITERATED
8028 | OPTI_TYPE_PREPENDED_SALT
8029 | OPTI_TYPE_RAW_HASH;
8030 dgst_pos0 = 3;
8031 dgst_pos1 = 7;
8032 dgst_pos2 = 2;
8033 dgst_pos3 = 6;
8034 break;
8035
8036 case 1450: hash_type = HASH_TYPE_SHA256;
8037 salt_type = SALT_TYPE_INTERN;
8038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8039 opts_type = OPTS_TYPE_PT_GENERATE_BE
8040 | OPTS_TYPE_ST_ADD80;
8041 kern_type = KERN_TYPE_HMACSHA256_PW;
8042 dgst_size = DGST_SIZE_4_8;
8043 parse_func = hmacsha256_parse_hash;
8044 sort_by_digest = sort_by_digest_4_8;
8045 opti_type = OPTI_TYPE_ZERO_BYTE
8046 | OPTI_TYPE_NOT_ITERATED;
8047 dgst_pos0 = 3;
8048 dgst_pos1 = 7;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 6;
8051 break;
8052
8053 case 1460: hash_type = HASH_TYPE_SHA256;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_PT_ADD80
8058 | OPTS_TYPE_PT_ADDBITS15;
8059 kern_type = KERN_TYPE_HMACSHA256_SLT;
8060 dgst_size = DGST_SIZE_4_8;
8061 parse_func = hmacsha256_parse_hash;
8062 sort_by_digest = sort_by_digest_4_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_NOT_ITERATED;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 7;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 6;
8069 break;
8070
8071 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8072 salt_type = SALT_TYPE_EMBEDDED;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_LE
8075 | OPTS_TYPE_PT_BITSLICE;
8076 kern_type = KERN_TYPE_DESCRYPT;
8077 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8078 parse_func = descrypt_parse_hash;
8079 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8082 dgst_pos0 = 0;
8083 dgst_pos1 = 1;
8084 dgst_pos2 = 2;
8085 dgst_pos3 = 3;
8086 break;
8087
8088 case 1600: hash_type = HASH_TYPE_MD5;
8089 salt_type = SALT_TYPE_EMBEDDED;
8090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8092 kern_type = KERN_TYPE_APR1CRYPT;
8093 dgst_size = DGST_SIZE_4_4;
8094 parse_func = md5apr1_parse_hash;
8095 sort_by_digest = sort_by_digest_4_4;
8096 opti_type = OPTI_TYPE_ZERO_BYTE;
8097 dgst_pos0 = 0;
8098 dgst_pos1 = 1;
8099 dgst_pos2 = 2;
8100 dgst_pos3 = 3;
8101 break;
8102
8103 case 1700: hash_type = HASH_TYPE_SHA512;
8104 salt_type = SALT_TYPE_NONE;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_PT_ADD80
8108 | OPTS_TYPE_PT_ADDBITS15;
8109 kern_type = KERN_TYPE_SHA512;
8110 dgst_size = DGST_SIZE_8_8;
8111 parse_func = sha512_parse_hash;
8112 sort_by_digest = sort_by_digest_8_8;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP
8117 | OPTI_TYPE_NOT_ITERATED
8118 | OPTI_TYPE_NOT_SALTED
8119 | OPTI_TYPE_USES_BITS_64
8120 | OPTI_TYPE_RAW_HASH;
8121 dgst_pos0 = 14;
8122 dgst_pos1 = 15;
8123 dgst_pos2 = 6;
8124 dgst_pos3 = 7;
8125 break;
8126
8127 case 1710: hash_type = HASH_TYPE_SHA512;
8128 salt_type = SALT_TYPE_INTERN;
8129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8130 opts_type = OPTS_TYPE_PT_GENERATE_BE
8131 | OPTS_TYPE_ST_ADD80
8132 | OPTS_TYPE_ST_ADDBITS15;
8133 kern_type = KERN_TYPE_SHA512_PWSLT;
8134 dgst_size = DGST_SIZE_8_8;
8135 parse_func = sha512s_parse_hash;
8136 sort_by_digest = sort_by_digest_8_8;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_INIT
8139 | OPTI_TYPE_PRECOMPUTE_MERKLE
8140 | OPTI_TYPE_EARLY_SKIP
8141 | OPTI_TYPE_NOT_ITERATED
8142 | OPTI_TYPE_APPENDED_SALT
8143 | OPTI_TYPE_USES_BITS_64
8144 | OPTI_TYPE_RAW_HASH;
8145 dgst_pos0 = 14;
8146 dgst_pos1 = 15;
8147 dgst_pos2 = 6;
8148 dgst_pos3 = 7;
8149 break;
8150
8151 case 1711: hash_type = HASH_TYPE_SHA512;
8152 salt_type = SALT_TYPE_EMBEDDED;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_BE
8155 | OPTS_TYPE_ST_ADD80
8156 | OPTS_TYPE_ST_ADDBITS15;
8157 kern_type = KERN_TYPE_SHA512_PWSLT;
8158 dgst_size = DGST_SIZE_8_8;
8159 parse_func = sha512b64s_parse_hash;
8160 sort_by_digest = sort_by_digest_8_8;
8161 opti_type = OPTI_TYPE_ZERO_BYTE
8162 | OPTI_TYPE_PRECOMPUTE_INIT
8163 | OPTI_TYPE_PRECOMPUTE_MERKLE
8164 | OPTI_TYPE_EARLY_SKIP
8165 | OPTI_TYPE_NOT_ITERATED
8166 | OPTI_TYPE_APPENDED_SALT
8167 | OPTI_TYPE_USES_BITS_64
8168 | OPTI_TYPE_RAW_HASH;
8169 dgst_pos0 = 14;
8170 dgst_pos1 = 15;
8171 dgst_pos2 = 6;
8172 dgst_pos3 = 7;
8173 break;
8174
8175 case 1720: hash_type = HASH_TYPE_SHA512;
8176 salt_type = SALT_TYPE_INTERN;
8177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_BE
8179 | OPTS_TYPE_PT_ADD80
8180 | OPTS_TYPE_PT_ADDBITS15;
8181 kern_type = KERN_TYPE_SHA512_SLTPW;
8182 dgst_size = DGST_SIZE_8_8;
8183 parse_func = sha512s_parse_hash;
8184 sort_by_digest = sort_by_digest_8_8;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_PRECOMPUTE_INIT
8187 | OPTI_TYPE_PRECOMPUTE_MERKLE
8188 | OPTI_TYPE_EARLY_SKIP
8189 | OPTI_TYPE_NOT_ITERATED
8190 | OPTI_TYPE_PREPENDED_SALT
8191 | OPTI_TYPE_USES_BITS_64
8192 | OPTI_TYPE_RAW_HASH;
8193 dgst_pos0 = 14;
8194 dgst_pos1 = 15;
8195 dgst_pos2 = 6;
8196 dgst_pos3 = 7;
8197 break;
8198
8199 case 1722: hash_type = HASH_TYPE_SHA512;
8200 salt_type = SALT_TYPE_EMBEDDED;
8201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_PT_ADD80
8204 | OPTS_TYPE_PT_ADDBITS15
8205 | OPTS_TYPE_ST_HEX;
8206 kern_type = KERN_TYPE_SHA512_SLTPW;
8207 dgst_size = DGST_SIZE_8_8;
8208 parse_func = osx512_parse_hash;
8209 sort_by_digest = sort_by_digest_8_8;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_PRECOMPUTE_INIT
8212 | OPTI_TYPE_PRECOMPUTE_MERKLE
8213 | OPTI_TYPE_EARLY_SKIP
8214 | OPTI_TYPE_NOT_ITERATED
8215 | OPTI_TYPE_PREPENDED_SALT
8216 | OPTI_TYPE_USES_BITS_64
8217 | OPTI_TYPE_RAW_HASH;
8218 dgst_pos0 = 14;
8219 dgst_pos1 = 15;
8220 dgst_pos2 = 6;
8221 dgst_pos3 = 7;
8222 break;
8223
8224 case 1730: hash_type = HASH_TYPE_SHA512;
8225 salt_type = SALT_TYPE_INTERN;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_BE
8228 | OPTS_TYPE_PT_UNICODE
8229 | OPTS_TYPE_ST_ADD80
8230 | OPTS_TYPE_ST_ADDBITS15;
8231 kern_type = KERN_TYPE_SHA512_PWSLTU;
8232 dgst_size = DGST_SIZE_8_8;
8233 parse_func = sha512s_parse_hash;
8234 sort_by_digest = sort_by_digest_8_8;
8235 opti_type = OPTI_TYPE_ZERO_BYTE
8236 | OPTI_TYPE_PRECOMPUTE_INIT
8237 | OPTI_TYPE_PRECOMPUTE_MERKLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_APPENDED_SALT
8241 | OPTI_TYPE_USES_BITS_64
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 14;
8244 dgst_pos1 = 15;
8245 dgst_pos2 = 6;
8246 dgst_pos3 = 7;
8247 break;
8248
8249 case 1731: hash_type = HASH_TYPE_SHA512;
8250 salt_type = SALT_TYPE_EMBEDDED;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_BE
8253 | OPTS_TYPE_PT_UNICODE
8254 | OPTS_TYPE_ST_ADD80
8255 | OPTS_TYPE_ST_ADDBITS15
8256 | OPTS_TYPE_ST_HEX;
8257 kern_type = KERN_TYPE_SHA512_PWSLTU;
8258 dgst_size = DGST_SIZE_8_8;
8259 parse_func = mssql2012_parse_hash;
8260 sort_by_digest = sort_by_digest_8_8;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED
8266 | OPTI_TYPE_APPENDED_SALT
8267 | OPTI_TYPE_USES_BITS_64
8268 | OPTI_TYPE_RAW_HASH;
8269 dgst_pos0 = 14;
8270 dgst_pos1 = 15;
8271 dgst_pos2 = 6;
8272 dgst_pos3 = 7;
8273 break;
8274
8275 case 1740: hash_type = HASH_TYPE_SHA512;
8276 salt_type = SALT_TYPE_INTERN;
8277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_BE
8279 | OPTS_TYPE_PT_ADD80
8280 | OPTS_TYPE_PT_ADDBITS15
8281 | OPTS_TYPE_PT_UNICODE;
8282 kern_type = KERN_TYPE_SHA512_SLTPWU;
8283 dgst_size = DGST_SIZE_8_8;
8284 parse_func = sha512s_parse_hash;
8285 sort_by_digest = sort_by_digest_8_8;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_PRECOMPUTE_MERKLE
8289 | OPTI_TYPE_EARLY_SKIP
8290 | OPTI_TYPE_NOT_ITERATED
8291 | OPTI_TYPE_PREPENDED_SALT
8292 | OPTI_TYPE_USES_BITS_64
8293 | OPTI_TYPE_RAW_HASH;
8294 dgst_pos0 = 14;
8295 dgst_pos1 = 15;
8296 dgst_pos2 = 6;
8297 dgst_pos3 = 7;
8298 break;
8299
8300 case 1750: hash_type = HASH_TYPE_SHA512;
8301 salt_type = SALT_TYPE_INTERN;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_BE
8304 | OPTS_TYPE_ST_ADD80;
8305 kern_type = KERN_TYPE_HMACSHA512_PW;
8306 dgst_size = DGST_SIZE_8_8;
8307 parse_func = hmacsha512_parse_hash;
8308 sort_by_digest = sort_by_digest_8_8;
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_USES_BITS_64
8311 | OPTI_TYPE_NOT_ITERATED;
8312 dgst_pos0 = 14;
8313 dgst_pos1 = 15;
8314 dgst_pos2 = 6;
8315 dgst_pos3 = 7;
8316 break;
8317
8318 case 1760: hash_type = HASH_TYPE_SHA512;
8319 salt_type = SALT_TYPE_INTERN;
8320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8321 opts_type = OPTS_TYPE_PT_GENERATE_BE
8322 | OPTS_TYPE_PT_ADD80
8323 | OPTS_TYPE_PT_ADDBITS15;
8324 kern_type = KERN_TYPE_HMACSHA512_SLT;
8325 dgst_size = DGST_SIZE_8_8;
8326 parse_func = hmacsha512_parse_hash;
8327 sort_by_digest = sort_by_digest_8_8;
8328 opti_type = OPTI_TYPE_ZERO_BYTE
8329 | OPTI_TYPE_USES_BITS_64
8330 | OPTI_TYPE_NOT_ITERATED;
8331 dgst_pos0 = 14;
8332 dgst_pos1 = 15;
8333 dgst_pos2 = 6;
8334 dgst_pos3 = 7;
8335 break;
8336
8337 case 1800: hash_type = HASH_TYPE_SHA512;
8338 salt_type = SALT_TYPE_EMBEDDED;
8339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8341 kern_type = KERN_TYPE_SHA512CRYPT;
8342 dgst_size = DGST_SIZE_8_8;
8343 parse_func = sha512crypt_parse_hash;
8344 sort_by_digest = sort_by_digest_8_8;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_USES_BITS_64;
8347 dgst_pos0 = 0;
8348 dgst_pos1 = 1;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 3;
8351 break;
8352
8353 case 2100: hash_type = HASH_TYPE_DCC2;
8354 salt_type = SALT_TYPE_EMBEDDED;
8355 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8357 | OPTS_TYPE_ST_LOWER
8358 | OPTS_TYPE_ST_UNICODE;
8359 kern_type = KERN_TYPE_DCC2;
8360 dgst_size = DGST_SIZE_4_4;
8361 parse_func = dcc2_parse_hash;
8362 sort_by_digest = sort_by_digest_4_4;
8363 opti_type = OPTI_TYPE_ZERO_BYTE;
8364 dgst_pos0 = 0;
8365 dgst_pos1 = 1;
8366 dgst_pos2 = 2;
8367 dgst_pos3 = 3;
8368 break;
8369
8370 case 2400: hash_type = HASH_TYPE_MD5;
8371 salt_type = SALT_TYPE_NONE;
8372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8373 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8374 kern_type = KERN_TYPE_MD5PIX;
8375 dgst_size = DGST_SIZE_4_4;
8376 parse_func = md5pix_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4;
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_PRECOMPUTE_INIT
8380 | OPTI_TYPE_PRECOMPUTE_MERKLE
8381 | OPTI_TYPE_EARLY_SKIP
8382 | OPTI_TYPE_NOT_ITERATED
8383 | OPTI_TYPE_NOT_SALTED;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 3;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 1;
8388 break;
8389
8390 case 2410: hash_type = HASH_TYPE_MD5;
8391 salt_type = SALT_TYPE_INTERN;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8394 kern_type = KERN_TYPE_MD5ASA;
8395 dgst_size = DGST_SIZE_4_4;
8396 parse_func = md5asa_parse_hash;
8397 sort_by_digest = sort_by_digest_4_4;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_PRECOMPUTE_INIT
8400 | OPTI_TYPE_PRECOMPUTE_MERKLE
8401 | OPTI_TYPE_EARLY_SKIP
8402 | OPTI_TYPE_NOT_ITERATED;
8403 dgst_pos0 = 0;
8404 dgst_pos1 = 3;
8405 dgst_pos2 = 2;
8406 dgst_pos3 = 1;
8407 break;
8408
8409 case 2500: hash_type = HASH_TYPE_WPA;
8410 salt_type = SALT_TYPE_EMBEDDED;
8411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8412 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8413 kern_type = KERN_TYPE_WPA;
8414 dgst_size = DGST_SIZE_4_4;
8415 parse_func = wpa_parse_hash;
8416 sort_by_digest = sort_by_digest_4_4;
8417 opti_type = OPTI_TYPE_ZERO_BYTE;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 1;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 3;
8422 break;
8423
8424 case 2600: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_VIRTUAL;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS14
8430 | OPTS_TYPE_ST_ADD80;
8431 kern_type = KERN_TYPE_MD55_PWSLT1;
8432 dgst_size = DGST_SIZE_4_4;
8433 parse_func = md5md5_parse_hash;
8434 sort_by_digest = sort_by_digest_4_4;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP;
8439 dgst_pos0 = 0;
8440 dgst_pos1 = 3;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 2611: hash_type = HASH_TYPE_MD5;
8446 salt_type = SALT_TYPE_INTERN;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE
8449 | OPTS_TYPE_PT_ADD80
8450 | OPTS_TYPE_PT_ADDBITS14
8451 | OPTS_TYPE_ST_ADD80;
8452 kern_type = KERN_TYPE_MD55_PWSLT1;
8453 dgst_size = DGST_SIZE_4_4;
8454 parse_func = vb3_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 3;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 1;
8464 break;
8465
8466 case 2612: hash_type = HASH_TYPE_MD5;
8467 salt_type = SALT_TYPE_EMBEDDED;
8468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8469 opts_type = OPTS_TYPE_PT_GENERATE_LE
8470 | OPTS_TYPE_PT_ADD80
8471 | OPTS_TYPE_PT_ADDBITS14
8472 | OPTS_TYPE_ST_ADD80
8473 | OPTS_TYPE_ST_HEX;
8474 kern_type = KERN_TYPE_MD55_PWSLT1;
8475 dgst_size = DGST_SIZE_4_4;
8476 parse_func = phps_parse_hash;
8477 sort_by_digest = sort_by_digest_4_4;
8478 opti_type = OPTI_TYPE_ZERO_BYTE
8479 | OPTI_TYPE_PRECOMPUTE_INIT
8480 | OPTI_TYPE_PRECOMPUTE_MERKLE
8481 | OPTI_TYPE_EARLY_SKIP;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 3;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 1;
8486 break;
8487
8488 case 2711: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_INTERN;
8490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE
8492 | OPTS_TYPE_PT_ADD80
8493 | OPTS_TYPE_PT_ADDBITS14
8494 | OPTS_TYPE_ST_ADD80;
8495 kern_type = KERN_TYPE_MD55_PWSLT2;
8496 dgst_size = DGST_SIZE_4_4;
8497 parse_func = vb30_parse_hash;
8498 sort_by_digest = sort_by_digest_4_4;
8499 opti_type = OPTI_TYPE_ZERO_BYTE
8500 | OPTI_TYPE_PRECOMPUTE_INIT
8501 | OPTI_TYPE_EARLY_SKIP;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 2811: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_MD55_SLTPW;
8515 dgst_size = DGST_SIZE_4_4;
8516 parse_func = ipb2_parse_hash;
8517 sort_by_digest = sort_by_digest_4_4;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_EARLY_SKIP;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 3;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 1;
8525 break;
8526
8527 case 3000: hash_type = HASH_TYPE_LM;
8528 salt_type = SALT_TYPE_NONE;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_UPPER
8532 | OPTS_TYPE_PT_BITSLICE;
8533 kern_type = KERN_TYPE_LM;
8534 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8535 parse_func = lm_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8539 dgst_pos0 = 0;
8540 dgst_pos1 = 1;
8541 dgst_pos2 = 2;
8542 dgst_pos3 = 3;
8543 break;
8544
8545 case 3100: hash_type = HASH_TYPE_ORACLEH;
8546 salt_type = SALT_TYPE_INTERN;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_LE
8549 | OPTS_TYPE_PT_UPPER
8550 | OPTS_TYPE_ST_UPPER;
8551 kern_type = KERN_TYPE_ORACLEH;
8552 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8553 parse_func = oracleh_parse_hash;
8554 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8555 opti_type = OPTI_TYPE_ZERO_BYTE;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 1;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 3;
8560 break;
8561
8562 case 3200: hash_type = HASH_TYPE_BCRYPT;
8563 salt_type = SALT_TYPE_EMBEDDED;
8564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE
8566 | OPTS_TYPE_ST_GENERATE_LE;
8567 kern_type = KERN_TYPE_BCRYPT;
8568 dgst_size = DGST_SIZE_4_6;
8569 parse_func = bcrypt_parse_hash;
8570 sort_by_digest = sort_by_digest_4_6;
8571 opti_type = OPTI_TYPE_ZERO_BYTE;
8572 dgst_pos0 = 0;
8573 dgst_pos1 = 1;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 3;
8576 break;
8577
8578 case 3710: hash_type = HASH_TYPE_MD5;
8579 salt_type = SALT_TYPE_INTERN;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE
8582 | OPTS_TYPE_PT_ADD80
8583 | OPTS_TYPE_PT_ADDBITS14;
8584 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8585 dgst_size = DGST_SIZE_4_4;
8586 parse_func = md5s_parse_hash;
8587 sort_by_digest = sort_by_digest_4_4;
8588 opti_type = OPTI_TYPE_ZERO_BYTE
8589 | OPTI_TYPE_PRECOMPUTE_INIT
8590 | OPTI_TYPE_PRECOMPUTE_MERKLE
8591 | OPTI_TYPE_EARLY_SKIP;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 3;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 1;
8596 break;
8597
8598 case 3711: hash_type = HASH_TYPE_MD5;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_PT_ADD80
8603 | OPTS_TYPE_PT_ADDBITS14;
8604 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8605 dgst_size = DGST_SIZE_4_4;
8606 parse_func = mediawiki_b_parse_hash;
8607 sort_by_digest = sort_by_digest_4_4;
8608 opti_type = OPTI_TYPE_ZERO_BYTE
8609 | OPTI_TYPE_PRECOMPUTE_INIT
8610 | OPTI_TYPE_PRECOMPUTE_MERKLE
8611 | OPTI_TYPE_EARLY_SKIP;
8612 dgst_pos0 = 0;
8613 dgst_pos1 = 3;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 1;
8616 break;
8617
8618 case 3800: hash_type = HASH_TYPE_MD5;
8619 salt_type = SALT_TYPE_INTERN;
8620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_LE
8622 | OPTS_TYPE_ST_ADDBITS14;
8623 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8624 dgst_size = DGST_SIZE_4_4;
8625 parse_func = md5s_parse_hash;
8626 sort_by_digest = sort_by_digest_4_4;
8627 opti_type = OPTI_TYPE_ZERO_BYTE
8628 | OPTI_TYPE_PRECOMPUTE_INIT
8629 | OPTI_TYPE_PRECOMPUTE_MERKLE
8630 | OPTI_TYPE_EARLY_SKIP
8631 | OPTI_TYPE_NOT_ITERATED
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 0;
8634 dgst_pos1 = 3;
8635 dgst_pos2 = 2;
8636 dgst_pos3 = 1;
8637 break;
8638
8639 case 4300: hash_type = HASH_TYPE_MD5;
8640 salt_type = SALT_TYPE_VIRTUAL;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE
8643 | OPTS_TYPE_PT_ADD80
8644 | OPTS_TYPE_PT_ADDBITS14
8645 | OPTS_TYPE_ST_ADD80;
8646 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8647 dgst_size = DGST_SIZE_4_4;
8648 parse_func = md5md5_parse_hash;
8649 sort_by_digest = sort_by_digest_4_4;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_PRECOMPUTE_INIT
8652 | OPTI_TYPE_PRECOMPUTE_MERKLE
8653 | OPTI_TYPE_EARLY_SKIP;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 3;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 1;
8658 break;
8659
8660
8661 case 4400: hash_type = HASH_TYPE_MD5;
8662 salt_type = SALT_TYPE_NONE;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_BE
8665 | OPTS_TYPE_PT_ADD80
8666 | OPTS_TYPE_PT_ADDBITS15;
8667 kern_type = KERN_TYPE_MD5_SHA1;
8668 dgst_size = DGST_SIZE_4_4;
8669 parse_func = md5_parse_hash;
8670 sort_by_digest = sort_by_digest_4_4;
8671 opti_type = OPTI_TYPE_ZERO_BYTE
8672 | OPTI_TYPE_PRECOMPUTE_INIT
8673 | OPTI_TYPE_PRECOMPUTE_MERKLE
8674 | OPTI_TYPE_EARLY_SKIP
8675 | OPTI_TYPE_NOT_ITERATED
8676 | OPTI_TYPE_NOT_SALTED
8677 | OPTI_TYPE_RAW_HASH;
8678 dgst_pos0 = 0;
8679 dgst_pos1 = 3;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 1;
8682 break;
8683
8684 case 4500: hash_type = HASH_TYPE_SHA1;
8685 salt_type = SALT_TYPE_NONE;
8686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8687 opts_type = OPTS_TYPE_PT_GENERATE_BE
8688 | OPTS_TYPE_PT_ADD80
8689 | OPTS_TYPE_PT_ADDBITS15;
8690 kern_type = KERN_TYPE_SHA11;
8691 dgst_size = DGST_SIZE_4_5;
8692 parse_func = sha1_parse_hash;
8693 sort_by_digest = sort_by_digest_4_5;
8694 opti_type = OPTI_TYPE_ZERO_BYTE
8695 | OPTI_TYPE_PRECOMPUTE_INIT
8696 | OPTI_TYPE_PRECOMPUTE_MERKLE
8697 | OPTI_TYPE_EARLY_SKIP
8698 | OPTI_TYPE_NOT_SALTED;
8699 dgst_pos0 = 3;
8700 dgst_pos1 = 4;
8701 dgst_pos2 = 2;
8702 dgst_pos3 = 1;
8703 break;
8704
8705 case 4700: hash_type = HASH_TYPE_SHA1;
8706 salt_type = SALT_TYPE_NONE;
8707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8708 opts_type = OPTS_TYPE_PT_GENERATE_LE
8709 | OPTS_TYPE_PT_ADD80
8710 | OPTS_TYPE_PT_ADDBITS14;
8711 kern_type = KERN_TYPE_SHA1_MD5;
8712 dgst_size = DGST_SIZE_4_5;
8713 parse_func = sha1_parse_hash;
8714 sort_by_digest = sort_by_digest_4_5;
8715 opti_type = OPTI_TYPE_ZERO_BYTE
8716 | OPTI_TYPE_PRECOMPUTE_INIT
8717 | OPTI_TYPE_PRECOMPUTE_MERKLE
8718 | OPTI_TYPE_EARLY_SKIP
8719 | OPTI_TYPE_NOT_ITERATED
8720 | OPTI_TYPE_NOT_SALTED
8721 | OPTI_TYPE_RAW_HASH;
8722 dgst_pos0 = 3;
8723 dgst_pos1 = 4;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 1;
8726 break;
8727
8728 case 4800: hash_type = HASH_TYPE_MD5;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE
8732 | OPTS_TYPE_PT_ADDBITS14;
8733 kern_type = KERN_TYPE_MD5_CHAP;
8734 dgst_size = DGST_SIZE_4_4;
8735 parse_func = chap_parse_hash;
8736 sort_by_digest = sort_by_digest_4_4;
8737 opti_type = OPTI_TYPE_ZERO_BYTE
8738 | OPTI_TYPE_PRECOMPUTE_INIT
8739 | OPTI_TYPE_PRECOMPUTE_MERKLE
8740 | OPTI_TYPE_MEET_IN_MIDDLE
8741 | OPTI_TYPE_EARLY_SKIP
8742 | OPTI_TYPE_NOT_ITERATED
8743 | OPTI_TYPE_RAW_HASH;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 3;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 1;
8748 break;
8749
8750 case 4900: hash_type = HASH_TYPE_SHA1;
8751 salt_type = SALT_TYPE_INTERN;
8752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8754 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8755 dgst_size = DGST_SIZE_4_5;
8756 parse_func = sha1s_parse_hash;
8757 sort_by_digest = sort_by_digest_4_5;
8758 opti_type = OPTI_TYPE_ZERO_BYTE
8759 | OPTI_TYPE_PRECOMPUTE_INIT
8760 | OPTI_TYPE_PRECOMPUTE_MERKLE
8761 | OPTI_TYPE_EARLY_SKIP;
8762 dgst_pos0 = 3;
8763 dgst_pos1 = 4;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 1;
8766 break;
8767
8768 case 5000: hash_type = HASH_TYPE_KECCAK;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE
8772 | OPTS_TYPE_PT_ADD01;
8773 kern_type = KERN_TYPE_KECCAK;
8774 dgst_size = DGST_SIZE_8_25;
8775 parse_func = keccak_parse_hash;
8776 sort_by_digest = sort_by_digest_8_25;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_USES_BITS_64
8779 | OPTI_TYPE_RAW_HASH;
8780 dgst_pos0 = 2;
8781 dgst_pos1 = 3;
8782 dgst_pos2 = 4;
8783 dgst_pos3 = 5;
8784 break;
8785
8786 case 5100: hash_type = HASH_TYPE_MD5H;
8787 salt_type = SALT_TYPE_NONE;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE
8790 | OPTS_TYPE_PT_ADD80
8791 | OPTS_TYPE_PT_ADDBITS14;
8792 kern_type = KERN_TYPE_MD5H;
8793 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8794 parse_func = md5half_parse_hash;
8795 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_RAW_HASH;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 5200: hash_type = HASH_TYPE_SHA256;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8808 kern_type = KERN_TYPE_PSAFE3;
8809 dgst_size = DGST_SIZE_4_8;
8810 parse_func = psafe3_parse_hash;
8811 sort_by_digest = sort_by_digest_4_8;
8812 opti_type = OPTI_TYPE_ZERO_BYTE;
8813 dgst_pos0 = 0;
8814 dgst_pos1 = 1;
8815 dgst_pos2 = 2;
8816 dgst_pos3 = 3;
8817 break;
8818
8819 case 5300: hash_type = HASH_TYPE_MD5;
8820 salt_type = SALT_TYPE_EMBEDDED;
8821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8822 opts_type = OPTS_TYPE_PT_GENERATE_LE
8823 | OPTS_TYPE_ST_ADD80;
8824 kern_type = KERN_TYPE_IKEPSK_MD5;
8825 dgst_size = DGST_SIZE_4_4;
8826 parse_func = ikepsk_md5_parse_hash;
8827 sort_by_digest = sort_by_digest_4_4;
8828 opti_type = OPTI_TYPE_ZERO_BYTE;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 3;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 1;
8833 break;
8834
8835 case 5400: hash_type = HASH_TYPE_SHA1;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_BE
8839 | OPTS_TYPE_ST_ADD80;
8840 kern_type = KERN_TYPE_IKEPSK_SHA1;
8841 dgst_size = DGST_SIZE_4_5;
8842 parse_func = ikepsk_sha1_parse_hash;
8843 sort_by_digest = sort_by_digest_4_5;
8844 opti_type = OPTI_TYPE_ZERO_BYTE;
8845 dgst_pos0 = 3;
8846 dgst_pos1 = 4;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 1;
8849 break;
8850
8851 case 5500: hash_type = HASH_TYPE_NETNTLM;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE
8855 | OPTS_TYPE_PT_ADD80
8856 | OPTS_TYPE_PT_ADDBITS14
8857 | OPTS_TYPE_PT_UNICODE
8858 | OPTS_TYPE_ST_HEX;
8859 kern_type = KERN_TYPE_NETNTLMv1;
8860 dgst_size = DGST_SIZE_4_4;
8861 parse_func = netntlmv1_parse_hash;
8862 sort_by_digest = sort_by_digest_4_4;
8863 opti_type = OPTI_TYPE_ZERO_BYTE
8864 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 5600: hash_type = HASH_TYPE_MD5;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE
8875 | OPTS_TYPE_PT_ADD80
8876 | OPTS_TYPE_PT_ADDBITS14
8877 | OPTS_TYPE_PT_UNICODE;
8878 kern_type = KERN_TYPE_NETNTLMv2;
8879 dgst_size = DGST_SIZE_4_4;
8880 parse_func = netntlmv2_parse_hash;
8881 sort_by_digest = sort_by_digest_4_4;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 3;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 1;
8887 break;
8888
8889 case 5700: hash_type = HASH_TYPE_SHA256;
8890 salt_type = SALT_TYPE_NONE;
8891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_BE
8893 | OPTS_TYPE_PT_ADD80
8894 | OPTS_TYPE_PT_ADDBITS15;
8895 kern_type = KERN_TYPE_SHA256;
8896 dgst_size = DGST_SIZE_4_8;
8897 parse_func = cisco4_parse_hash;
8898 sort_by_digest = sort_by_digest_4_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE
8900 | OPTI_TYPE_PRECOMPUTE_INIT
8901 | OPTI_TYPE_PRECOMPUTE_MERKLE
8902 | OPTI_TYPE_EARLY_SKIP
8903 | OPTI_TYPE_NOT_ITERATED
8904 | OPTI_TYPE_NOT_SALTED
8905 | OPTI_TYPE_RAW_HASH;
8906 dgst_pos0 = 3;
8907 dgst_pos1 = 7;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 6;
8910 break;
8911
8912 case 5800: hash_type = HASH_TYPE_SHA1;
8913 salt_type = SALT_TYPE_INTERN;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8916 | OPTS_TYPE_ST_ADD80;
8917 kern_type = KERN_TYPE_ANDROIDPIN;
8918 dgst_size = DGST_SIZE_4_5;
8919 parse_func = androidpin_parse_hash;
8920 sort_by_digest = sort_by_digest_4_5;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8929 salt_type = SALT_TYPE_NONE;
8930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE
8932 | OPTS_TYPE_PT_ADD80;
8933 kern_type = KERN_TYPE_RIPEMD160;
8934 dgst_size = DGST_SIZE_4_5;
8935 parse_func = ripemd160_parse_hash;
8936 sort_by_digest = sort_by_digest_4_5;
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8945 salt_type = SALT_TYPE_NONE;
8946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_BE
8948 | OPTS_TYPE_PT_ADD80;
8949 kern_type = KERN_TYPE_WHIRLPOOL;
8950 dgst_size = DGST_SIZE_4_16;
8951 parse_func = whirlpool_parse_hash;
8952 sort_by_digest = sort_by_digest_4_16;
8953 opti_type = OPTI_TYPE_ZERO_BYTE;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 1;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 3;
8958 break;
8959
8960 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8964 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8965 dgst_size = DGST_SIZE_4_5;
8966 parse_func = truecrypt_parse_hash_2k;
8967 sort_by_digest = sort_by_digest_4_5;
8968 opti_type = OPTI_TYPE_ZERO_BYTE;
8969 dgst_pos0 = 0;
8970 dgst_pos1 = 1;
8971 dgst_pos2 = 2;
8972 dgst_pos3 = 3;
8973 break;
8974
8975 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8976 salt_type = SALT_TYPE_EMBEDDED;
8977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8979 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8980 dgst_size = DGST_SIZE_4_5;
8981 parse_func = truecrypt_parse_hash_2k;
8982 sort_by_digest = sort_by_digest_4_5;
8983 opti_type = OPTI_TYPE_ZERO_BYTE;
8984 dgst_pos0 = 0;
8985 dgst_pos1 = 1;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 3;
8988 break;
8989
8990 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8991 salt_type = SALT_TYPE_EMBEDDED;
8992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8994 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8995 dgst_size = DGST_SIZE_4_5;
8996 parse_func = truecrypt_parse_hash_2k;
8997 sort_by_digest = sort_by_digest_4_5;
8998 opti_type = OPTI_TYPE_ZERO_BYTE;
8999 dgst_pos0 = 0;
9000 dgst_pos1 = 1;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 3;
9003 break;
9004
9005 case 6221: hash_type = HASH_TYPE_SHA512;
9006 salt_type = SALT_TYPE_EMBEDDED;
9007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9009 kern_type = KERN_TYPE_TCSHA512_XTS512;
9010 dgst_size = DGST_SIZE_8_8;
9011 parse_func = truecrypt_parse_hash_1k;
9012 sort_by_digest = sort_by_digest_8_8;
9013 opti_type = OPTI_TYPE_ZERO_BYTE
9014 | OPTI_TYPE_USES_BITS_64;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 6222: hash_type = HASH_TYPE_SHA512;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9025 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9026 dgst_size = DGST_SIZE_8_8;
9027 parse_func = truecrypt_parse_hash_1k;
9028 sort_by_digest = sort_by_digest_8_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE
9030 | OPTI_TYPE_USES_BITS_64;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 6223: hash_type = HASH_TYPE_SHA512;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9041 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9042 dgst_size = DGST_SIZE_8_8;
9043 parse_func = truecrypt_parse_hash_1k;
9044 sort_by_digest = sort_by_digest_8_8;
9045 opti_type = OPTI_TYPE_ZERO_BYTE
9046 | OPTI_TYPE_USES_BITS_64;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9057 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9058 dgst_size = DGST_SIZE_4_8;
9059 parse_func = truecrypt_parse_hash_1k;
9060 sort_by_digest = sort_by_digest_4_8;
9061 opti_type = OPTI_TYPE_ZERO_BYTE;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9072 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9073 dgst_size = DGST_SIZE_4_8;
9074 parse_func = truecrypt_parse_hash_1k;
9075 sort_by_digest = sort_by_digest_4_8;
9076 opti_type = OPTI_TYPE_ZERO_BYTE;
9077 dgst_pos0 = 0;
9078 dgst_pos1 = 1;
9079 dgst_pos2 = 2;
9080 dgst_pos3 = 3;
9081 break;
9082
9083 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9084 salt_type = SALT_TYPE_EMBEDDED;
9085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9087 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9088 dgst_size = DGST_SIZE_4_8;
9089 parse_func = truecrypt_parse_hash_1k;
9090 sort_by_digest = sort_by_digest_4_8;
9091 opti_type = OPTI_TYPE_ZERO_BYTE;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 1;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 3;
9096 break;
9097
9098 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9099 salt_type = SALT_TYPE_EMBEDDED;
9100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9102 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9103 dgst_size = DGST_SIZE_4_5;
9104 parse_func = truecrypt_parse_hash_1k;
9105 sort_by_digest = sort_by_digest_4_5;
9106 opti_type = OPTI_TYPE_ZERO_BYTE;
9107 dgst_pos0 = 0;
9108 dgst_pos1 = 1;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 3;
9111 break;
9112
9113 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9114 salt_type = SALT_TYPE_EMBEDDED;
9115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9117 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9118 dgst_size = DGST_SIZE_4_5;
9119 parse_func = truecrypt_parse_hash_1k;
9120 sort_by_digest = sort_by_digest_4_5;
9121 opti_type = OPTI_TYPE_ZERO_BYTE;
9122 dgst_pos0 = 0;
9123 dgst_pos1 = 1;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 3;
9126 break;
9127
9128 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9129 salt_type = SALT_TYPE_EMBEDDED;
9130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9132 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = truecrypt_parse_hash_1k;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE;
9137 dgst_pos0 = 0;
9138 dgst_pos1 = 1;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 3;
9141 break;
9142
9143 case 6300: hash_type = HASH_TYPE_MD5;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9147 kern_type = KERN_TYPE_MD5AIX;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = md5aix_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_ZERO_BYTE;
9152 dgst_pos0 = 0;
9153 dgst_pos1 = 1;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 3;
9156 break;
9157
9158 case 6400: hash_type = HASH_TYPE_SHA256;
9159 salt_type = SALT_TYPE_EMBEDDED;
9160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9162 kern_type = KERN_TYPE_SHA256AIX;
9163 dgst_size = DGST_SIZE_4_8;
9164 parse_func = sha256aix_parse_hash;
9165 sort_by_digest = sort_by_digest_4_8;
9166 opti_type = OPTI_TYPE_ZERO_BYTE;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 6500: hash_type = HASH_TYPE_SHA512;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9177 kern_type = KERN_TYPE_SHA512AIX;
9178 dgst_size = DGST_SIZE_8_8;
9179 parse_func = sha512aix_parse_hash;
9180 sort_by_digest = sort_by_digest_8_8;
9181 opti_type = OPTI_TYPE_ZERO_BYTE
9182 | OPTI_TYPE_USES_BITS_64;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 6600: hash_type = HASH_TYPE_AES;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9193 kern_type = KERN_TYPE_AGILEKEY;
9194 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9195 parse_func = agilekey_parse_hash;
9196 sort_by_digest = sort_by_digest_4_5;
9197 opti_type = OPTI_TYPE_ZERO_BYTE;
9198 dgst_pos0 = 0;
9199 dgst_pos1 = 1;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 3;
9202 break;
9203
9204 case 6700: hash_type = HASH_TYPE_SHA1;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9208 kern_type = KERN_TYPE_SHA1AIX;
9209 dgst_size = DGST_SIZE_4_5;
9210 parse_func = sha1aix_parse_hash;
9211 sort_by_digest = sort_by_digest_4_5;
9212 opti_type = OPTI_TYPE_ZERO_BYTE;
9213 dgst_pos0 = 0;
9214 dgst_pos1 = 1;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 3;
9217 break;
9218
9219 case 6800: hash_type = HASH_TYPE_AES;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9223 kern_type = KERN_TYPE_LASTPASS;
9224 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9225 parse_func = lastpass_parse_hash;
9226 sort_by_digest = sort_by_digest_4_8;
9227 opti_type = OPTI_TYPE_ZERO_BYTE;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 1;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 3;
9232 break;
9233
9234 case 6900: hash_type = HASH_TYPE_GOST;
9235 salt_type = SALT_TYPE_NONE;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9238 kern_type = KERN_TYPE_GOST;
9239 dgst_size = DGST_SIZE_4_8;
9240 parse_func = gost_parse_hash;
9241 sort_by_digest = sort_by_digest_4_8;
9242 opti_type = OPTI_TYPE_ZERO_BYTE;
9243 dgst_pos0 = 0;
9244 dgst_pos1 = 1;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 3;
9247 break;
9248
9249 case 7100: hash_type = HASH_TYPE_SHA512;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9253 kern_type = KERN_TYPE_PBKDF2_SHA512;
9254 dgst_size = DGST_SIZE_8_16;
9255 parse_func = sha512osx_parse_hash;
9256 sort_by_digest = sort_by_digest_8_16;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_USES_BITS_64;
9259 dgst_pos0 = 0;
9260 dgst_pos1 = 1;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 3;
9263 break;
9264
9265 case 7200: hash_type = HASH_TYPE_SHA512;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9269 kern_type = KERN_TYPE_PBKDF2_SHA512;
9270 dgst_size = DGST_SIZE_8_16;
9271 parse_func = sha512grub_parse_hash;
9272 sort_by_digest = sort_by_digest_8_16;
9273 opti_type = OPTI_TYPE_ZERO_BYTE
9274 | OPTI_TYPE_USES_BITS_64;
9275 dgst_pos0 = 0;
9276 dgst_pos1 = 1;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 3;
9279 break;
9280
9281 case 7300: hash_type = HASH_TYPE_SHA1;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_BE
9285 | OPTS_TYPE_ST_ADD80
9286 | OPTS_TYPE_ST_ADDBITS15;
9287 kern_type = KERN_TYPE_RAKP;
9288 dgst_size = DGST_SIZE_4_5;
9289 parse_func = rakp_parse_hash;
9290 sort_by_digest = sort_by_digest_4_5;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_NOT_ITERATED;
9293 dgst_pos0 = 3;
9294 dgst_pos1 = 4;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 1;
9297 break;
9298
9299 case 7400: hash_type = HASH_TYPE_SHA256;
9300 salt_type = SALT_TYPE_EMBEDDED;
9301 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9302 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9303 kern_type = KERN_TYPE_SHA256CRYPT;
9304 dgst_size = DGST_SIZE_4_8;
9305 parse_func = sha256crypt_parse_hash;
9306 sort_by_digest = sort_by_digest_4_8;
9307 opti_type = OPTI_TYPE_ZERO_BYTE;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 7500: hash_type = HASH_TYPE_KRB5PA;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9318 kern_type = KERN_TYPE_KRB5PA;
9319 dgst_size = DGST_SIZE_4_4;
9320 parse_func = krb5pa_parse_hash;
9321 sort_by_digest = sort_by_digest_4_4;
9322 opti_type = OPTI_TYPE_ZERO_BYTE
9323 | OPTI_TYPE_NOT_ITERATED;
9324 dgst_pos0 = 0;
9325 dgst_pos1 = 1;
9326 dgst_pos2 = 2;
9327 dgst_pos3 = 3;
9328 break;
9329
9330 case 7600: hash_type = HASH_TYPE_SHA1;
9331 salt_type = SALT_TYPE_INTERN;
9332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9333 opts_type = OPTS_TYPE_PT_GENERATE_BE
9334 | OPTS_TYPE_PT_ADD80
9335 | OPTS_TYPE_PT_ADDBITS15;
9336 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9337 dgst_size = DGST_SIZE_4_5;
9338 parse_func = redmine_parse_hash;
9339 sort_by_digest = sort_by_digest_4_5;
9340 opti_type = OPTI_TYPE_ZERO_BYTE
9341 | OPTI_TYPE_PRECOMPUTE_INIT
9342 | OPTI_TYPE_EARLY_SKIP
9343 | OPTI_TYPE_NOT_ITERATED
9344 | OPTI_TYPE_PREPENDED_SALT;
9345 dgst_pos0 = 3;
9346 dgst_pos1 = 4;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 1;
9349 break;
9350
9351 case 7700: hash_type = HASH_TYPE_SAPB;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE
9355 | OPTS_TYPE_PT_UPPER
9356 | OPTS_TYPE_ST_UPPER;
9357 kern_type = KERN_TYPE_SAPB;
9358 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9359 parse_func = sapb_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_NOT_ITERATED;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 7800: hash_type = HASH_TYPE_SAPG;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_BE
9374 | OPTS_TYPE_ST_ADD80
9375 | OPTS_TYPE_ST_UPPER;
9376 kern_type = KERN_TYPE_SAPG;
9377 dgst_size = DGST_SIZE_4_5;
9378 parse_func = sapg_parse_hash;
9379 sort_by_digest = sort_by_digest_4_5;
9380 opti_type = OPTI_TYPE_ZERO_BYTE
9381 | OPTI_TYPE_PRECOMPUTE_INIT
9382 | OPTI_TYPE_NOT_ITERATED;
9383 dgst_pos0 = 3;
9384 dgst_pos1 = 4;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 1;
9387 break;
9388
9389 case 7900: hash_type = HASH_TYPE_SHA512;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9393 kern_type = KERN_TYPE_DRUPAL7;
9394 dgst_size = DGST_SIZE_8_8;
9395 parse_func = drupal7_parse_hash;
9396 sort_by_digest = sort_by_digest_8_8;
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_USES_BITS_64;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 8000: hash_type = HASH_TYPE_SHA256;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_BE
9409 | OPTS_TYPE_PT_UNICODE
9410 | OPTS_TYPE_ST_ADD80
9411 | OPTS_TYPE_ST_HEX;
9412 kern_type = KERN_TYPE_SYBASEASE;
9413 dgst_size = DGST_SIZE_4_8;
9414 parse_func = sybasease_parse_hash;
9415 sort_by_digest = sort_by_digest_4_8;
9416 opti_type = OPTI_TYPE_ZERO_BYTE
9417 | OPTI_TYPE_PRECOMPUTE_INIT
9418 | OPTI_TYPE_EARLY_SKIP
9419 | OPTI_TYPE_NOT_ITERATED
9420 | OPTI_TYPE_RAW_HASH;
9421 dgst_pos0 = 3;
9422 dgst_pos1 = 7;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 6;
9425 break;
9426
9427 case 8100: hash_type = HASH_TYPE_SHA1;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9431 kern_type = KERN_TYPE_NETSCALER;
9432 dgst_size = DGST_SIZE_4_5;
9433 parse_func = netscaler_parse_hash;
9434 sort_by_digest = sort_by_digest_4_5;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_PRECOMPUTE_INIT
9437 | OPTI_TYPE_PRECOMPUTE_MERKLE
9438 | OPTI_TYPE_EARLY_SKIP
9439 | OPTI_TYPE_NOT_ITERATED
9440 | OPTI_TYPE_PREPENDED_SALT
9441 | OPTI_TYPE_RAW_HASH;
9442 dgst_pos0 = 3;
9443 dgst_pos1 = 4;
9444 dgst_pos2 = 2;
9445 dgst_pos3 = 1;
9446 break;
9447
9448 case 8200: hash_type = HASH_TYPE_SHA256;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9452 kern_type = KERN_TYPE_CLOUDKEY;
9453 dgst_size = DGST_SIZE_4_8;
9454 parse_func = cloudkey_parse_hash;
9455 sort_by_digest = sort_by_digest_4_8;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 8300: hash_type = HASH_TYPE_SHA1;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE
9467 | OPTS_TYPE_ST_HEX
9468 | OPTS_TYPE_ST_ADD80;
9469 kern_type = KERN_TYPE_NSEC3;
9470 dgst_size = DGST_SIZE_4_5;
9471 parse_func = nsec3_parse_hash;
9472 sort_by_digest = sort_by_digest_4_5;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 3;
9475 dgst_pos1 = 4;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 1;
9478 break;
9479
9480 case 8400: hash_type = HASH_TYPE_SHA1;
9481 salt_type = SALT_TYPE_INTERN;
9482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_BE
9484 | OPTS_TYPE_PT_ADD80
9485 | OPTS_TYPE_PT_ADDBITS15;
9486 kern_type = KERN_TYPE_WBB3;
9487 dgst_size = DGST_SIZE_4_5;
9488 parse_func = wbb3_parse_hash;
9489 sort_by_digest = sort_by_digest_4_5;
9490 opti_type = OPTI_TYPE_ZERO_BYTE
9491 | OPTI_TYPE_PRECOMPUTE_INIT
9492 | OPTI_TYPE_NOT_ITERATED;
9493 dgst_pos0 = 3;
9494 dgst_pos1 = 4;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 1;
9497 break;
9498
9499 case 8500: hash_type = HASH_TYPE_DESRACF;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE
9503 | OPTS_TYPE_ST_UPPER;
9504 kern_type = KERN_TYPE_RACF;
9505 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9506 parse_func = racf_parse_hash;
9507 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9508 opti_type = OPTI_TYPE_ZERO_BYTE
9509 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 8600: hash_type = HASH_TYPE_LOTUS5;
9517 salt_type = SALT_TYPE_NONE;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_LOTUS5;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = lotus5_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_EARLY_SKIP
9525 | OPTI_TYPE_NOT_ITERATED
9526 | OPTI_TYPE_NOT_SALTED
9527 | OPTI_TYPE_RAW_HASH;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 8700: hash_type = HASH_TYPE_LOTUS6;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9538 kern_type = KERN_TYPE_LOTUS6;
9539 dgst_size = DGST_SIZE_4_4;
9540 parse_func = lotus6_parse_hash;
9541 sort_by_digest = sort_by_digest_4_4;
9542 opti_type = OPTI_TYPE_EARLY_SKIP
9543 | OPTI_TYPE_NOT_ITERATED
9544 | OPTI_TYPE_RAW_HASH;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9552 salt_type = SALT_TYPE_EMBEDDED;
9553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9555 kern_type = KERN_TYPE_ANDROIDFDE;
9556 dgst_size = DGST_SIZE_4_4;
9557 parse_func = androidfde_parse_hash;
9558 sort_by_digest = sort_by_digest_4_4;
9559 opti_type = OPTI_TYPE_ZERO_BYTE;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 8900: hash_type = HASH_TYPE_SCRYPT;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9570 kern_type = KERN_TYPE_SCRYPT;
9571 dgst_size = DGST_SIZE_4_8;
9572 parse_func = scrypt_parse_hash;
9573 sort_by_digest = sort_by_digest_4_8;
9574 opti_type = OPTI_TYPE_ZERO_BYTE;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 1;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 3;
9579 break;
9580
9581 case 9000: hash_type = HASH_TYPE_SHA1;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE
9585 | OPTS_TYPE_ST_GENERATE_LE;
9586 kern_type = KERN_TYPE_PSAFE2;
9587 dgst_size = DGST_SIZE_4_5;
9588 parse_func = psafe2_parse_hash;
9589 sort_by_digest = sort_by_digest_4_5;
9590 opti_type = OPTI_TYPE_ZERO_BYTE;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9100: hash_type = HASH_TYPE_LOTUS8;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_LOTUS8;
9602 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9603 parse_func = lotus8_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9605 opti_type = OPTI_TYPE_ZERO_BYTE;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 9200: hash_type = HASH_TYPE_SHA256;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9616 kern_type = KERN_TYPE_PBKDF2_SHA256;
9617 dgst_size = DGST_SIZE_4_32;
9618 parse_func = cisco8_parse_hash;
9619 sort_by_digest = sort_by_digest_4_32;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 9300: hash_type = HASH_TYPE_SCRYPT;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_SCRYPT;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = cisco9_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9646 kern_type = KERN_TYPE_OFFICE2007;
9647 dgst_size = DGST_SIZE_4_4;
9648 parse_func = office2007_parse_hash;
9649 sort_by_digest = sort_by_digest_4_4;
9650 opti_type = OPTI_TYPE_ZERO_BYTE;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9661 kern_type = KERN_TYPE_OFFICE2010;
9662 dgst_size = DGST_SIZE_4_4;
9663 parse_func = office2010_parse_hash;
9664 sort_by_digest = sort_by_digest_4_4;
9665 opti_type = OPTI_TYPE_ZERO_BYTE;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_OFFICE2013;
9677 dgst_size = DGST_SIZE_4_4;
9678 parse_func = office2013_parse_hash;
9679 sort_by_digest = sort_by_digest_4_4;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE
9691 | OPTS_TYPE_PT_ADD80
9692 | OPTS_TYPE_PT_UNICODE;
9693 kern_type = KERN_TYPE_OLDOFFICE01;
9694 dgst_size = DGST_SIZE_4_4;
9695 parse_func = oldoffice01_parse_hash;
9696 sort_by_digest = sort_by_digest_4_4;
9697 opti_type = OPTI_TYPE_ZERO_BYTE
9698 | OPTI_TYPE_PRECOMPUTE_INIT
9699 | OPTI_TYPE_NOT_ITERATED;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE
9710 | OPTS_TYPE_PT_ADD80;
9711 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9712 dgst_size = DGST_SIZE_4_4;
9713 parse_func = oldoffice01cm1_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4;
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_PRECOMPUTE_INIT
9717 | OPTI_TYPE_NOT_ITERATED;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_PT_ADD80
9729 | OPTS_TYPE_PT_UNICODE
9730 | OPTS_TYPE_PT_NEVERCRACK;
9731 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9732 dgst_size = DGST_SIZE_4_4;
9733 parse_func = oldoffice01cm2_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_PRECOMPUTE_INIT
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_BE
9748 | OPTS_TYPE_PT_ADD80
9749 | OPTS_TYPE_PT_UNICODE;
9750 kern_type = KERN_TYPE_OLDOFFICE34;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = oldoffice34_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_PRECOMPUTE_INIT
9756 | OPTI_TYPE_NOT_ITERATED;
9757 dgst_pos0 = 0;
9758 dgst_pos1 = 1;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 3;
9761 break;
9762
9763 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9767 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9768 dgst_size = DGST_SIZE_4_4;
9769 parse_func = oldoffice34cm1_parse_hash;
9770 sort_by_digest = sort_by_digest_4_4;
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_PRECOMPUTE_INIT
9773 | OPTI_TYPE_NOT_ITERATED;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 1;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 3;
9778 break;
9779
9780 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9781 salt_type = SALT_TYPE_EMBEDDED;
9782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_BE
9784 | OPTS_TYPE_PT_ADD80
9785 | OPTS_TYPE_PT_UNICODE
9786 | OPTS_TYPE_PT_NEVERCRACK;
9787 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9788 dgst_size = DGST_SIZE_4_4;
9789 parse_func = oldoffice34cm2_parse_hash;
9790 sort_by_digest = sort_by_digest_4_4;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_PRECOMPUTE_INIT
9793 | OPTI_TYPE_NOT_ITERATED;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 9900: hash_type = HASH_TYPE_MD5;
9801 salt_type = SALT_TYPE_NONE;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9804 kern_type = KERN_TYPE_RADMIN2;
9805 dgst_size = DGST_SIZE_4_4;
9806 parse_func = radmin2_parse_hash;
9807 sort_by_digest = sort_by_digest_4_4;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_PRECOMPUTE_INIT
9810 | OPTI_TYPE_EARLY_SKIP
9811 | OPTI_TYPE_NOT_ITERATED
9812 | OPTI_TYPE_NOT_SALTED;
9813 dgst_pos0 = 0;
9814 dgst_pos1 = 3;
9815 dgst_pos2 = 2;
9816 dgst_pos3 = 1;
9817 break;
9818
9819 case 10000: hash_type = HASH_TYPE_SHA256;
9820 salt_type = SALT_TYPE_EMBEDDED;
9821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9822 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9823 kern_type = KERN_TYPE_PBKDF2_SHA256;
9824 dgst_size = DGST_SIZE_4_32;
9825 parse_func = djangopbkdf2_parse_hash;
9826 sort_by_digest = sort_by_digest_4_32;
9827 opti_type = OPTI_TYPE_ZERO_BYTE;
9828 dgst_pos0 = 0;
9829 dgst_pos1 = 1;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 3;
9832 break;
9833
9834 case 10100: hash_type = HASH_TYPE_SIPHASH;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9838 kern_type = KERN_TYPE_SIPHASH;
9839 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9840 parse_func = siphash_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_NOT_ITERATED
9844 | OPTI_TYPE_RAW_HASH;
9845 dgst_pos0 = 0;
9846 dgst_pos1 = 1;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 3;
9849 break;
9850
9851 case 10200: hash_type = HASH_TYPE_MD5;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE
9855 | OPTS_TYPE_ST_ADD80
9856 | OPTS_TYPE_ST_ADDBITS14;
9857 kern_type = KERN_TYPE_HMACMD5_PW;
9858 dgst_size = DGST_SIZE_4_4;
9859 parse_func = crammd5_parse_hash;
9860 sort_by_digest = sort_by_digest_4_4;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_NOT_ITERATED;
9863 dgst_pos0 = 0;
9864 dgst_pos1 = 3;
9865 dgst_pos2 = 2;
9866 dgst_pos3 = 1;
9867 break;
9868
9869 case 10300: hash_type = HASH_TYPE_SHA1;
9870 salt_type = SALT_TYPE_EMBEDDED;
9871 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9872 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9873 kern_type = KERN_TYPE_SAPH_SHA1;
9874 dgst_size = DGST_SIZE_4_5;
9875 parse_func = saph_sha1_parse_hash;
9876 sort_by_digest = sort_by_digest_4_5;
9877 opti_type = OPTI_TYPE_ZERO_BYTE;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 1;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 3;
9882 break;
9883
9884 case 10400: hash_type = HASH_TYPE_PDFU16;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9888 kern_type = KERN_TYPE_PDF11;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = pdf11_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_NOT_ITERATED;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 10410: hash_type = HASH_TYPE_PDFU16;
9901 salt_type = SALT_TYPE_EMBEDDED;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9904 kern_type = KERN_TYPE_PDF11CM1;
9905 dgst_size = DGST_SIZE_4_4;
9906 parse_func = pdf11cm1_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4;
9908 opti_type = OPTI_TYPE_ZERO_BYTE
9909 | OPTI_TYPE_NOT_ITERATED;
9910 dgst_pos0 = 0;
9911 dgst_pos1 = 1;
9912 dgst_pos2 = 2;
9913 dgst_pos3 = 3;
9914 break;
9915
9916 case 10420: hash_type = HASH_TYPE_PDFU16;
9917 salt_type = SALT_TYPE_EMBEDDED;
9918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9919 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9920 kern_type = KERN_TYPE_PDF11CM2;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = pdf11cm2_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_NOT_ITERATED;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 10500: hash_type = HASH_TYPE_PDFU16;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9936 kern_type = KERN_TYPE_PDF14;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = pdf14_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_ZERO_BYTE
9941 | OPTI_TYPE_NOT_ITERATED;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 10600: hash_type = HASH_TYPE_SHA256;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_BE
9952 | OPTS_TYPE_ST_ADD80
9953 | OPTS_TYPE_ST_ADDBITS15
9954 | OPTS_TYPE_HASH_COPY;
9955 kern_type = KERN_TYPE_SHA256_PWSLT;
9956 dgst_size = DGST_SIZE_4_8;
9957 parse_func = pdf17l3_parse_hash;
9958 sort_by_digest = sort_by_digest_4_8;
9959 opti_type = OPTI_TYPE_ZERO_BYTE
9960 | OPTI_TYPE_PRECOMPUTE_INIT
9961 | OPTI_TYPE_PRECOMPUTE_MERKLE
9962 | OPTI_TYPE_EARLY_SKIP
9963 | OPTI_TYPE_NOT_ITERATED
9964 | OPTI_TYPE_APPENDED_SALT
9965 | OPTI_TYPE_RAW_HASH;
9966 dgst_pos0 = 3;
9967 dgst_pos1 = 7;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 6;
9970 break;
9971
9972 case 10700: hash_type = HASH_TYPE_PDFU32;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_HASH_COPY;
9977 kern_type = KERN_TYPE_PDF17L8;
9978 dgst_size = DGST_SIZE_4_8;
9979 parse_func = pdf17l8_parse_hash;
9980 sort_by_digest = sort_by_digest_4_8;
9981 opti_type = OPTI_TYPE_ZERO_BYTE
9982 | OPTI_TYPE_NOT_ITERATED;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 10800: hash_type = HASH_TYPE_SHA384;
9990 salt_type = SALT_TYPE_NONE;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_BE
9993 | OPTS_TYPE_PT_ADD80
9994 | OPTS_TYPE_PT_ADDBITS15;
9995 kern_type = KERN_TYPE_SHA384;
9996 dgst_size = DGST_SIZE_8_8;
9997 parse_func = sha384_parse_hash;
9998 sort_by_digest = sort_by_digest_8_8;
9999 opti_type = OPTI_TYPE_ZERO_BYTE
10000 | OPTI_TYPE_PRECOMPUTE_INIT
10001 | OPTI_TYPE_PRECOMPUTE_MERKLE
10002 | OPTI_TYPE_EARLY_SKIP
10003 | OPTI_TYPE_NOT_ITERATED
10004 | OPTI_TYPE_NOT_SALTED
10005 | OPTI_TYPE_USES_BITS_64
10006 | OPTI_TYPE_RAW_HASH;
10007 dgst_pos0 = 6;
10008 dgst_pos1 = 7;
10009 dgst_pos2 = 4;
10010 dgst_pos3 = 5;
10011 break;
10012
10013 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_ST_BASE64
10018 | OPTS_TYPE_HASH_COPY;
10019 kern_type = KERN_TYPE_PBKDF2_SHA256;
10020 dgst_size = DGST_SIZE_4_32;
10021 parse_func = pbkdf2_sha256_parse_hash;
10022 sort_by_digest = sort_by_digest_4_32;
10023 opti_type = OPTI_TYPE_ZERO_BYTE;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 1;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 3;
10028 break;
10029
10030 case 11000: hash_type = HASH_TYPE_MD5;
10031 salt_type = SALT_TYPE_INTERN;
10032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_LE
10034 | OPTS_TYPE_PT_ADD80;
10035 kern_type = KERN_TYPE_PRESTASHOP;
10036 dgst_size = DGST_SIZE_4_4;
10037 parse_func = prestashop_parse_hash;
10038 sort_by_digest = sort_by_digest_4_4;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_PRECOMPUTE_INIT
10041 | OPTI_TYPE_NOT_ITERATED
10042 | OPTI_TYPE_PREPENDED_SALT;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 3;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 1;
10047 break;
10048
10049 case 11100: hash_type = HASH_TYPE_MD5;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE
10053 | OPTS_TYPE_ST_ADD80;
10054 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10055 dgst_size = DGST_SIZE_4_4;
10056 parse_func = postgresql_auth_parse_hash;
10057 sort_by_digest = sort_by_digest_4_4;
10058 opti_type = OPTI_TYPE_ZERO_BYTE
10059 | OPTI_TYPE_PRECOMPUTE_INIT
10060 | OPTI_TYPE_PRECOMPUTE_MERKLE
10061 | OPTI_TYPE_EARLY_SKIP;
10062 dgst_pos0 = 0;
10063 dgst_pos1 = 3;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 1;
10066 break;
10067
10068 case 11200: hash_type = HASH_TYPE_SHA1;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_BE
10072 | OPTS_TYPE_PT_ADD80
10073 | OPTS_TYPE_ST_HEX;
10074 kern_type = KERN_TYPE_MYSQL_AUTH;
10075 dgst_size = DGST_SIZE_4_5;
10076 parse_func = mysql_auth_parse_hash;
10077 sort_by_digest = sort_by_digest_4_5;
10078 opti_type = OPTI_TYPE_ZERO_BYTE
10079 | OPTI_TYPE_EARLY_SKIP;
10080 dgst_pos0 = 3;
10081 dgst_pos1 = 4;
10082 dgst_pos2 = 2;
10083 dgst_pos3 = 1;
10084 break;
10085
10086 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10087 salt_type = SALT_TYPE_EMBEDDED;
10088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10089 opts_type = OPTS_TYPE_PT_GENERATE_LE
10090 | OPTS_TYPE_ST_HEX
10091 | OPTS_TYPE_ST_ADD80;
10092 kern_type = KERN_TYPE_BITCOIN_WALLET;
10093 dgst_size = DGST_SIZE_4_4;
10094 parse_func = bitcoin_wallet_parse_hash;
10095 sort_by_digest = sort_by_digest_4_4;
10096 opti_type = OPTI_TYPE_ZERO_BYTE;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 11400: hash_type = HASH_TYPE_MD5;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE
10107 | OPTS_TYPE_PT_ADD80
10108 | OPTS_TYPE_HASH_COPY;
10109 kern_type = KERN_TYPE_SIP_AUTH;
10110 dgst_size = DGST_SIZE_4_4;
10111 parse_func = sip_auth_parse_hash;
10112 sort_by_digest = sort_by_digest_4_4;
10113 opti_type = OPTI_TYPE_ZERO_BYTE;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 3;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 1;
10118 break;
10119
10120 case 11500: hash_type = HASH_TYPE_CRC32;
10121 salt_type = SALT_TYPE_INTERN;
10122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10123 opts_type = OPTS_TYPE_PT_GENERATE_LE
10124 | OPTS_TYPE_ST_GENERATE_LE
10125 | OPTS_TYPE_ST_HEX;
10126 kern_type = KERN_TYPE_CRC32;
10127 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10128 parse_func = crc32_parse_hash;
10129 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10130 opti_type = OPTI_TYPE_ZERO_BYTE;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 1;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 3;
10135 break;
10136
10137 case 11600: hash_type = HASH_TYPE_AES;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE
10141 | OPTS_TYPE_PT_NEVERCRACK;
10142 kern_type = KERN_TYPE_SEVEN_ZIP;
10143 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10144 parse_func = seven_zip_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10154 salt_type = SALT_TYPE_NONE;
10155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_LE
10157 | OPTS_TYPE_PT_ADD01;
10158 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10159 dgst_size = DGST_SIZE_4_8;
10160 parse_func = gost2012sbog_256_parse_hash;
10161 sort_by_digest = sort_by_digest_4_8;
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 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10170 salt_type = SALT_TYPE_NONE;
10171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_LE
10173 | OPTS_TYPE_PT_ADD01;
10174 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10175 dgst_size = DGST_SIZE_4_16;
10176 parse_func = gost2012sbog_512_parse_hash;
10177 sort_by_digest = sort_by_digest_4_16;
10178 opti_type = OPTI_TYPE_ZERO_BYTE;
10179 dgst_pos0 = 0;
10180 dgst_pos1 = 1;
10181 dgst_pos2 = 2;
10182 dgst_pos3 = 3;
10183 break;
10184
10185 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10186 salt_type = SALT_TYPE_EMBEDDED;
10187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10188 opts_type = OPTS_TYPE_PT_GENERATE_LE
10189 | OPTS_TYPE_ST_BASE64
10190 | OPTS_TYPE_HASH_COPY;
10191 kern_type = KERN_TYPE_PBKDF2_MD5;
10192 dgst_size = DGST_SIZE_4_32;
10193 parse_func = pbkdf2_md5_parse_hash;
10194 sort_by_digest = sort_by_digest_4_32;
10195 opti_type = OPTI_TYPE_ZERO_BYTE;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 1;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 3;
10200 break;
10201
10202 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE
10206 | OPTS_TYPE_ST_BASE64
10207 | OPTS_TYPE_HASH_COPY;
10208 kern_type = KERN_TYPE_PBKDF2_SHA1;
10209 dgst_size = DGST_SIZE_4_32;
10210 parse_func = pbkdf2_sha1_parse_hash;
10211 sort_by_digest = sort_by_digest_4_32;
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 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10220 salt_type = SALT_TYPE_EMBEDDED;
10221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10222 opts_type = OPTS_TYPE_PT_GENERATE_LE
10223 | OPTS_TYPE_ST_BASE64
10224 | OPTS_TYPE_HASH_COPY;
10225 kern_type = KERN_TYPE_PBKDF2_SHA512;
10226 dgst_size = DGST_SIZE_8_16;
10227 parse_func = pbkdf2_sha512_parse_hash;
10228 sort_by_digest = sort_by_digest_8_16;
10229 opti_type = OPTI_TYPE_ZERO_BYTE
10230 | OPTI_TYPE_USES_BITS_64;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_ECRYPTFS;
10242 dgst_size = DGST_SIZE_8_8;
10243 parse_func = ecryptfs_parse_hash;
10244 sort_by_digest = sort_by_digest_8_8;
10245 opti_type = OPTI_TYPE_ZERO_BYTE
10246 | OPTI_TYPE_USES_BITS_64;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 1;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 3;
10251 break;
10252
10253 case 12300: hash_type = HASH_TYPE_ORACLET;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_ORACLET;
10258 dgst_size = DGST_SIZE_8_16;
10259 parse_func = oraclet_parse_hash;
10260 sort_by_digest = sort_by_digest_8_16;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_USES_BITS_64;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10273 kern_type = KERN_TYPE_BSDICRYPT;
10274 dgst_size = DGST_SIZE_4_4;
10275 parse_func = bsdicrypt_parse_hash;
10276 sort_by_digest = sort_by_digest_4_4;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 12500: hash_type = HASH_TYPE_RAR3HP;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_RAR3;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = rar3hp_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 case 12600: hash_type = HASH_TYPE_SHA256;
10301 salt_type = SALT_TYPE_INTERN;
10302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10303 opts_type = OPTS_TYPE_PT_GENERATE_BE
10304 | OPTS_TYPE_PT_ADD80;
10305 kern_type = KERN_TYPE_CF10;
10306 dgst_size = DGST_SIZE_4_8;
10307 parse_func = cf10_parse_hash;
10308 sort_by_digest = sort_by_digest_4_8;
10309 opti_type = OPTI_TYPE_ZERO_BYTE
10310 | OPTI_TYPE_PRECOMPUTE_INIT
10311 | OPTI_TYPE_EARLY_SKIP
10312 | OPTI_TYPE_NOT_ITERATED;
10313 dgst_pos0 = 3;
10314 dgst_pos1 = 7;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 6;
10317 break;
10318
10319 case 12700: hash_type = HASH_TYPE_AES;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE
10323 | OPTS_TYPE_HASH_COPY;
10324 kern_type = KERN_TYPE_MYWALLET;
10325 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10326 parse_func = mywallet_parse_hash;
10327 sort_by_digest = sort_by_digest_4_5;
10328 opti_type = OPTI_TYPE_ZERO_BYTE;
10329 dgst_pos0 = 0;
10330 dgst_pos1 = 1;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 3;
10333 break;
10334
10335 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10336 salt_type = SALT_TYPE_EMBEDDED;
10337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10339 kern_type = KERN_TYPE_MS_DRSR;
10340 dgst_size = DGST_SIZE_4_8;
10341 parse_func = ms_drsr_parse_hash;
10342 sort_by_digest = sort_by_digest_4_8;
10343 opti_type = OPTI_TYPE_ZERO_BYTE;
10344 dgst_pos0 = 0;
10345 dgst_pos1 = 1;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 3;
10348 break;
10349
10350 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10351 salt_type = SALT_TYPE_EMBEDDED;
10352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10354 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10355 dgst_size = DGST_SIZE_4_8;
10356 parse_func = androidfde_samsung_parse_hash;
10357 sort_by_digest = sort_by_digest_4_8;
10358 opti_type = OPTI_TYPE_ZERO_BYTE;
10359 dgst_pos0 = 0;
10360 dgst_pos1 = 1;
10361 dgst_pos2 = 2;
10362 dgst_pos3 = 3;
10363 break;
10364
10365 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10366 salt_type = SALT_TYPE_EMBEDDED;
10367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10369 kern_type = KERN_TYPE_RAR5;
10370 dgst_size = DGST_SIZE_4_4;
10371 parse_func = rar5_parse_hash;
10372 sort_by_digest = sort_by_digest_4_4;
10373 opti_type = OPTI_TYPE_ZERO_BYTE;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_KRB5TGS;
10385 dgst_size = DGST_SIZE_4_4;
10386 parse_func = krb5tgs_parse_hash;
10387 sort_by_digest = sort_by_digest_4_4;
10388 opti_type = OPTI_TYPE_ZERO_BYTE
10389 | OPTI_TYPE_NOT_ITERATED;
10390 dgst_pos0 = 0;
10391 dgst_pos1 = 1;
10392 dgst_pos2 = 2;
10393 dgst_pos3 = 3;
10394 break;
10395
10396 default: usage_mini_print (PROGNAME); return (-1);
10397 }
10398
10399 /**
10400 * transpose
10401 */
10402
10403 data.parse_func = parse_func;
10404
10405 /**
10406 * misc stuff
10407 */
10408
10409 if (hex_salt)
10410 {
10411 if (salt_type == SALT_TYPE_INTERN)
10412 {
10413 opts_type |= OPTS_TYPE_ST_HEX;
10414 }
10415 else
10416 {
10417 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10418
10419 return (-1);
10420 }
10421 }
10422
10423 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10424 | (salt_type == SALT_TYPE_EXTERN)
10425 | (salt_type == SALT_TYPE_EMBEDDED)
10426 | (salt_type == SALT_TYPE_VIRTUAL));
10427
10428 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10429
10430 data.hash_type = hash_type;
10431 data.attack_mode = attack_mode;
10432 data.attack_kern = attack_kern;
10433 data.attack_exec = attack_exec;
10434 data.kern_type = kern_type;
10435 data.opts_type = opts_type;
10436 data.dgst_size = dgst_size;
10437 data.salt_type = salt_type;
10438 data.isSalted = isSalted;
10439 data.sort_by_digest = sort_by_digest;
10440 data.dgst_pos0 = dgst_pos0;
10441 data.dgst_pos1 = dgst_pos1;
10442 data.dgst_pos2 = dgst_pos2;
10443 data.dgst_pos3 = dgst_pos3;
10444
10445 esalt_size = 0;
10446
10447 switch (hash_mode)
10448 {
10449 case 2500: esalt_size = sizeof (wpa_t); break;
10450 case 5300: esalt_size = sizeof (ikepsk_t); break;
10451 case 5400: esalt_size = sizeof (ikepsk_t); break;
10452 case 5500: esalt_size = sizeof (netntlm_t); break;
10453 case 5600: esalt_size = sizeof (netntlm_t); break;
10454 case 6211: esalt_size = sizeof (tc_t); break;
10455 case 6212: esalt_size = sizeof (tc_t); break;
10456 case 6213: esalt_size = sizeof (tc_t); break;
10457 case 6221: esalt_size = sizeof (tc_t); break;
10458 case 6222: esalt_size = sizeof (tc_t); break;
10459 case 6223: esalt_size = sizeof (tc_t); break;
10460 case 6231: esalt_size = sizeof (tc_t); break;
10461 case 6232: esalt_size = sizeof (tc_t); break;
10462 case 6233: esalt_size = sizeof (tc_t); break;
10463 case 6241: esalt_size = sizeof (tc_t); break;
10464 case 6242: esalt_size = sizeof (tc_t); break;
10465 case 6243: esalt_size = sizeof (tc_t); break;
10466 case 6600: esalt_size = sizeof (agilekey_t); break;
10467 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10468 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10469 case 7300: esalt_size = sizeof (rakp_t); break;
10470 case 7500: esalt_size = sizeof (krb5pa_t); break;
10471 case 8200: esalt_size = sizeof (cloudkey_t); break;
10472 case 8800: esalt_size = sizeof (androidfde_t); break;
10473 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10474 case 9400: esalt_size = sizeof (office2007_t); break;
10475 case 9500: esalt_size = sizeof (office2010_t); break;
10476 case 9600: esalt_size = sizeof (office2013_t); break;
10477 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10478 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10479 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10480 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10481 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10482 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10483 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10484 case 10200: esalt_size = sizeof (cram_md5_t); break;
10485 case 10400: esalt_size = sizeof (pdf_t); break;
10486 case 10410: esalt_size = sizeof (pdf_t); break;
10487 case 10420: esalt_size = sizeof (pdf_t); break;
10488 case 10500: esalt_size = sizeof (pdf_t); break;
10489 case 10600: esalt_size = sizeof (pdf_t); break;
10490 case 10700: esalt_size = sizeof (pdf_t); break;
10491 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10492 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10493 case 11400: esalt_size = sizeof (sip_t); break;
10494 case 11600: esalt_size = sizeof (seven_zip_t); break;
10495 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10496 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10497 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10498 case 13000: esalt_size = sizeof (rar5_t); break;
10499 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10500 }
10501
10502 data.esalt_size = esalt_size;
10503
10504 /**
10505 * choose dictionary parser
10506 */
10507
10508 if (hash_type == HASH_TYPE_LM)
10509 {
10510 get_next_word_func = get_next_word_lm;
10511 }
10512 else if (opts_type & OPTS_TYPE_PT_UPPER)
10513 {
10514 get_next_word_func = get_next_word_uc;
10515 }
10516 else
10517 {
10518 get_next_word_func = get_next_word_std;
10519 }
10520
10521 /**
10522 * dictstat
10523 */
10524
10525 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10526
10527 #ifdef _POSIX
10528 size_t dictstat_nmemb = 0;
10529 #endif
10530
10531 #ifdef _WIN
10532 uint dictstat_nmemb = 0;
10533 #endif
10534
10535 char dictstat[256] = { 0 };
10536
10537 FILE *dictstat_fp = NULL;
10538
10539 if (keyspace == 0)
10540 {
10541 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10542
10543 dictstat_fp = fopen (dictstat, "rb");
10544
10545 if (dictstat_fp)
10546 {
10547 #ifdef _POSIX
10548 struct stat tmpstat;
10549
10550 fstat (fileno (dictstat_fp), &tmpstat);
10551 #endif
10552
10553 #ifdef _WIN
10554 struct stat64 tmpstat;
10555
10556 _fstat64 (fileno (dictstat_fp), &tmpstat);
10557 #endif
10558
10559 if (tmpstat.st_mtime < COMPTIME)
10560 {
10561 /* with v0.15 the format changed so we have to ensure user is using a good version
10562 since there is no version-header in the dictstat file */
10563
10564 fclose (dictstat_fp);
10565
10566 unlink (dictstat);
10567 }
10568 else
10569 {
10570 while (!feof (dictstat_fp))
10571 {
10572 dictstat_t d;
10573
10574 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10575
10576 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10577
10578 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10579 {
10580 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10581
10582 return -1;
10583 }
10584 }
10585
10586 fclose (dictstat_fp);
10587 }
10588 }
10589 }
10590
10591 /**
10592 * potfile
10593 */
10594
10595 char potfile[256] = { 0 };
10596
10597 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10598
10599 data.pot_fp = NULL;
10600
10601 FILE *out_fp = NULL;
10602 FILE *pot_fp = NULL;
10603
10604 if (show == 1 || left == 1)
10605 {
10606 pot_fp = fopen (potfile, "rb");
10607
10608 if (pot_fp == NULL)
10609 {
10610 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10611
10612 return (-1);
10613 }
10614
10615 if (outfile != NULL)
10616 {
10617 if ((out_fp = fopen (outfile, "ab")) == NULL)
10618 {
10619 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10620
10621 fclose (pot_fp);
10622
10623 return (-1);
10624 }
10625 }
10626 else
10627 {
10628 out_fp = stdout;
10629 }
10630 }
10631 else
10632 {
10633 if (potfile_disable == 0)
10634 {
10635 pot_fp = fopen (potfile, "ab");
10636
10637 if (pot_fp == NULL)
10638 {
10639 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10640
10641 return (-1);
10642 }
10643
10644 data.pot_fp = pot_fp;
10645 }
10646 }
10647
10648 pot_t *pot = NULL;
10649
10650 uint pot_cnt = 0;
10651 uint pot_avail = 0;
10652
10653 if (show == 1 || left == 1)
10654 {
10655 SUPPRESS_OUTPUT = 1;
10656
10657 pot_avail = count_lines (pot_fp);
10658
10659 rewind (pot_fp);
10660
10661 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10662
10663 uint pot_hashes_avail = 0;
10664
10665 uint line_num = 0;
10666
10667 while (!feof (pot_fp))
10668 {
10669 line_num++;
10670
10671 char line_buf[BUFSIZ] = { 0 };
10672
10673 int line_len = fgetl (pot_fp, line_buf);
10674
10675 if (line_len == 0) continue;
10676
10677 char *plain_buf = line_buf + line_len;
10678
10679 pot_t *pot_ptr = &pot[pot_cnt];
10680
10681 hash_t *hashes_buf = &pot_ptr->hash;
10682
10683 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10684 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10685
10686 if (pot_cnt == pot_hashes_avail)
10687 {
10688 uint pos = 0;
10689
10690 for (pos = 0; pos < INCR_POT; pos++)
10691 {
10692 if ((pot_cnt + pos) >= pot_avail) break;
10693
10694 pot_t *tmp_pot = &pot[pot_cnt + pos];
10695
10696 hash_t *tmp_hash = &tmp_pot->hash;
10697
10698 tmp_hash->digest = mymalloc (dgst_size);
10699
10700 if (isSalted)
10701 {
10702 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10703 }
10704
10705 if (esalt_size)
10706 {
10707 tmp_hash->esalt = mymalloc (esalt_size);
10708 }
10709
10710 pot_hashes_avail++;
10711 }
10712 }
10713
10714 int plain_len = 0;
10715
10716 int parser_status;
10717
10718 int iter = MAX_CUT_TRIES;
10719
10720 do
10721 {
10722 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10723 {
10724 if (line_buf[i] == ':')
10725 {
10726 line_len--;
10727
10728 break;
10729 }
10730 }
10731
10732 if (data.hash_mode != 2500)
10733 {
10734 parser_status = parse_func (line_buf, line_len, hashes_buf);
10735 }
10736 else
10737 {
10738 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10739
10740 if (line_len > max_salt_size)
10741 {
10742 parser_status = PARSER_GLOBAL_LENGTH;
10743 }
10744 else
10745 {
10746 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10747
10748 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10749
10750 hashes_buf->salt->salt_len = line_len;
10751
10752 parser_status = PARSER_OK;
10753 }
10754 }
10755
10756 // if NOT parsed without error, we add the ":" to the plain
10757
10758 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10759 {
10760 plain_len++;
10761 plain_buf--;
10762 }
10763
10764 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10765
10766 if (parser_status < PARSER_GLOBAL_ZERO)
10767 {
10768 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10769
10770 continue;
10771 }
10772
10773 if (plain_len >= 255) continue;
10774
10775 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10776
10777 pot_ptr->plain_len = plain_len;
10778
10779 pot_cnt++;
10780 }
10781
10782 fclose (pot_fp);
10783
10784 SUPPRESS_OUTPUT = 0;
10785
10786 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10787 }
10788
10789 /**
10790 * word len
10791 */
10792
10793 uint pw_min = PW_MIN;
10794 uint pw_max = PW_MAX;
10795
10796 switch (hash_mode)
10797 {
10798 case 400: if (pw_max > 40) pw_max = 40;
10799 break;
10800 case 500: if (pw_max > 16) pw_max = 16;
10801 break;
10802 case 1500: if (pw_max > 8) pw_max = 8;
10803 break;
10804 case 1600: if (pw_max > 16) pw_max = 16;
10805 break;
10806 case 1800: if (pw_max > 16) pw_max = 16;
10807 break;
10808 case 2100: if (pw_max > 16) pw_max = 16;
10809 break;
10810 case 2500: if (pw_min < 8) pw_min = 8;
10811 break;
10812 case 3000: if (pw_max > 7) pw_max = 7;
10813 break;
10814 case 5200: if (pw_max > 24) pw_max = 24;
10815 break;
10816 case 5800: if (pw_max > 16) pw_max = 16;
10817 break;
10818 case 6300: if (pw_max > 16) pw_max = 16;
10819 break;
10820 case 7400: if (pw_max > 16) pw_max = 16;
10821 break;
10822 case 7900: if (pw_max > 48) pw_max = 48;
10823 break;
10824 case 8500: if (pw_max > 8) pw_max = 8;
10825 break;
10826 case 8600: if (pw_max > 16) pw_max = 16;
10827 break;
10828 case 9710: pw_min = 5;
10829 pw_max = 5;
10830 break;
10831 case 9810: pw_min = 5;
10832 pw_max = 5;
10833 break;
10834 case 10410: pw_min = 5;
10835 pw_max = 5;
10836 break;
10837 case 10300: if (pw_max < 3) pw_min = 3;
10838 if (pw_max > 40) pw_max = 40;
10839 break;
10840 case 10500: if (pw_max < 3) pw_min = 3;
10841 if (pw_max > 40) pw_max = 40;
10842 break;
10843 case 10700: if (pw_max > 16) pw_max = 16;
10844 break;
10845 case 11300: if (pw_max > 40) pw_max = 40;
10846 break;
10847 case 12500: if (pw_max > 20) pw_max = 20;
10848 break;
10849 case 12800: if (pw_max > 24) pw_max = 24;
10850 break;
10851 }
10852
10853 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10854 {
10855 switch (attack_kern)
10856 {
10857 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10858 break;
10859 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10860 break;
10861 }
10862 }
10863
10864 /**
10865 * charsets : keep them together for more easy maintainnce
10866 */
10867
10868 cs_t mp_sys[6] = { { { 0 }, 0 } };
10869 cs_t mp_usr[4] = { { { 0 }, 0 } };
10870
10871 mp_setup_sys (mp_sys);
10872
10873 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10874 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10875 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10876 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10877
10878 /**
10879 * load hashes, part I: find input mode, count hashes
10880 */
10881
10882 uint hashlist_mode = 0;
10883 uint hashlist_format = HLFMT_HASHCAT;
10884
10885 uint hashes_avail = 0;
10886
10887 if (benchmark == 0)
10888 {
10889 struct stat f;
10890
10891 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10892
10893 if ((hash_mode == 2500) ||
10894 (hash_mode == 5200) ||
10895 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10896 (hash_mode == 9000))
10897 {
10898 hashlist_mode = HL_MODE_ARG;
10899
10900 char *hashfile = myargv[optind];
10901
10902 data.hashfile = hashfile;
10903
10904 logfile_top_var_string ("target", hashfile);
10905 }
10906
10907 if (hashlist_mode == HL_MODE_ARG)
10908 {
10909 if (hash_mode == 2500)
10910 {
10911 struct stat st;
10912
10913 if (stat (data.hashfile, &st) == -1)
10914 {
10915 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10916
10917 return (-1);
10918 }
10919
10920 hashes_avail = st.st_size / sizeof (hccap_t);
10921 }
10922 else
10923 {
10924 hashes_avail = 1;
10925 }
10926 }
10927 else if (hashlist_mode == HL_MODE_FILE)
10928 {
10929 char *hashfile = myargv[optind];
10930
10931 data.hashfile = hashfile;
10932
10933 logfile_top_var_string ("target", hashfile);
10934
10935 FILE *fp = NULL;
10936
10937 if ((fp = fopen (hashfile, "rb")) == NULL)
10938 {
10939 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10940
10941 return (-1);
10942 }
10943
10944 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10945
10946 hashes_avail = count_lines (fp);
10947
10948 rewind (fp);
10949
10950 if (hashes_avail == 0)
10951 {
10952 log_error ("ERROR: hashfile is empty or corrupt");
10953
10954 fclose (fp);
10955
10956 return (-1);
10957 }
10958
10959 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10960
10961 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10962 {
10963 log_error ("ERROR: remove not supported in native hashfile-format mode");
10964
10965 fclose (fp);
10966
10967 return (-1);
10968 }
10969
10970 fclose (fp);
10971 }
10972 }
10973 else
10974 {
10975 hashlist_mode = HL_MODE_ARG;
10976
10977 hashes_avail = 1;
10978 }
10979
10980 if (hash_mode == 3000) hashes_avail *= 2;
10981
10982 data.hashlist_mode = hashlist_mode;
10983 data.hashlist_format = hashlist_format;
10984
10985 logfile_top_uint (hashlist_mode);
10986 logfile_top_uint (hashlist_format);
10987
10988 /**
10989 * load hashes, part II: allocate required memory, set pointers
10990 */
10991
10992 hash_t *hashes_buf = NULL;
10993 void *digests_buf = NULL;
10994 salt_t *salts_buf = NULL;
10995 void *esalts_buf = NULL;
10996
10997 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10998
10999 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11000
11001 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11002 {
11003 u32 hash_pos;
11004
11005 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11006 {
11007 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11008
11009 hashes_buf[hash_pos].hash_info = hash_info;
11010
11011 if (username && (remove || show || left))
11012 {
11013 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11014 }
11015
11016 if (benchmark)
11017 {
11018 hash_info->orighash = (char *) mymalloc (256);
11019 }
11020 }
11021 }
11022
11023 if (isSalted)
11024 {
11025 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11026
11027 if (esalt_size)
11028 {
11029 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11030 }
11031 }
11032 else
11033 {
11034 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11035 }
11036
11037 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11038 {
11039 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11040
11041 if (isSalted)
11042 {
11043 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11044
11045 if (esalt_size)
11046 {
11047 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11048 }
11049 }
11050 else
11051 {
11052 hashes_buf[hash_pos].salt = &salts_buf[0];
11053 }
11054 }
11055
11056 /**
11057 * load hashes, part III: parse hashes or generate them if benchmark
11058 */
11059
11060 uint hashes_cnt = 0;
11061
11062 if (benchmark == 0)
11063 {
11064 if (keyspace == 1)
11065 {
11066 // useless to read hash file for keyspace, cheat a little bit w/ optind
11067 }
11068 else if (hashes_avail == 0)
11069 {
11070 }
11071 else if (hashlist_mode == HL_MODE_ARG)
11072 {
11073 char *input_buf = myargv[optind];
11074
11075 uint input_len = strlen (input_buf);
11076
11077 logfile_top_var_string ("target", input_buf);
11078
11079 char *hash_buf = NULL;
11080 int hash_len = 0;
11081
11082 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11083
11084 if (hash_len)
11085 {
11086 if (opts_type & OPTS_TYPE_HASH_COPY)
11087 {
11088 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11089
11090 hash_info_tmp->orighash = mystrdup (hash_buf);
11091 }
11092
11093 if (isSalted)
11094 {
11095 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11096 }
11097
11098 int parser_status = PARSER_OK;
11099
11100 if (hash_mode == 2500)
11101 {
11102 if (hash_len == 0)
11103 {
11104 log_error ("ERROR: hccap file not specified");
11105
11106 return (-1);
11107 }
11108
11109 hashlist_mode = HL_MODE_FILE;
11110
11111 data.hashlist_mode = hashlist_mode;
11112
11113 FILE *fp = fopen (hash_buf, "rb");
11114
11115 if (fp == NULL)
11116 {
11117 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11118
11119 return (-1);
11120 }
11121
11122 if (hashes_avail < 1)
11123 {
11124 log_error ("ERROR: hccap file is empty or corrupt");
11125
11126 fclose (fp);
11127
11128 return (-1);
11129 }
11130
11131 uint hccap_size = sizeof (hccap_t);
11132
11133 char *in = (char *) mymalloc (hccap_size);
11134
11135 while (!feof (fp))
11136 {
11137 int n = fread (in, hccap_size, 1, fp);
11138
11139 if (n != 1)
11140 {
11141 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11142
11143 break;
11144 }
11145
11146 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11147
11148 if (parser_status != PARSER_OK)
11149 {
11150 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11151
11152 continue;
11153 }
11154
11155 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11156
11157 if ((show == 1) || (left == 1))
11158 {
11159 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11160
11161 char *salt_ptr = (char *) tmp_salt->salt_buf;
11162
11163 int cur_pos = tmp_salt->salt_len;
11164 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11165
11166 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11167
11168 u8 *pke_ptr = (u8 *) wpa->pke;
11169
11170 // do the appending task
11171
11172 snprintf (salt_ptr + cur_pos,
11173 rem_len,
11174 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11175 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11176 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11177
11178
11179 // memset () the remaining part of the salt
11180
11181 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11182 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11183
11184 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11185
11186 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11187 }
11188
11189 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);
11190 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);
11191
11192 hashes_cnt++;
11193 }
11194
11195 fclose (fp);
11196
11197 myfree (in);
11198 }
11199 else if (hash_mode == 3000)
11200 {
11201 if (hash_len == 32)
11202 {
11203 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11204
11205 hash_t *lm_hash_left = NULL;
11206
11207 if (parser_status == PARSER_OK)
11208 {
11209 lm_hash_left = &hashes_buf[hashes_cnt];
11210
11211 hashes_cnt++;
11212 }
11213 else
11214 {
11215 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11216 }
11217
11218 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11219
11220 hash_t *lm_hash_right = NULL;
11221
11222 if (parser_status == PARSER_OK)
11223 {
11224 lm_hash_right = &hashes_buf[hashes_cnt];
11225
11226 hashes_cnt++;
11227 }
11228 else
11229 {
11230 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11231 }
11232
11233 // show / left
11234
11235 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11236 {
11237 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);
11238 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);
11239 }
11240 }
11241 else
11242 {
11243 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11244
11245 if (parser_status == PARSER_OK)
11246 {
11247 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11248 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11249 }
11250
11251 if (parser_status == PARSER_OK)
11252 {
11253 hashes_cnt++;
11254 }
11255 else
11256 {
11257 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11258 }
11259 }
11260 }
11261 else
11262 {
11263 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11264
11265 if (parser_status == PARSER_OK)
11266 {
11267 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11268 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11269 }
11270
11271 if (parser_status == PARSER_OK)
11272 {
11273 hashes_cnt++;
11274 }
11275 else
11276 {
11277 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11278 }
11279 }
11280 }
11281 }
11282 else if (hashlist_mode == HL_MODE_FILE)
11283 {
11284 char *hashfile = data.hashfile;
11285
11286 FILE *fp;
11287
11288 if ((fp = fopen (hashfile, "rb")) == NULL)
11289 {
11290 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11291
11292 return (-1);
11293 }
11294
11295 uint line_num = 0;
11296
11297 while (!feof (fp))
11298 {
11299 line_num++;
11300
11301 char line_buf[BUFSIZ] = { 0 };
11302
11303 int line_len = fgetl (fp, line_buf);
11304
11305 if (line_len == 0) continue;
11306
11307 char *hash_buf = NULL;
11308 int hash_len = 0;
11309
11310 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11311
11312 if (username)
11313 {
11314 char *user_buf = NULL;
11315 int user_len = 0;
11316
11317 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11318
11319 if (remove || show)
11320 {
11321 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11322
11323 *user = (user_t *) mymalloc (sizeof (user_t));
11324
11325 user_t *user_ptr = *user;
11326
11327 if (user_buf != NULL)
11328 {
11329 user_ptr->user_name = mystrdup (user_buf);
11330 }
11331 else
11332 {
11333 user_ptr->user_name = mystrdup ("");
11334 }
11335
11336 user_ptr->user_len = user_len;
11337 }
11338 }
11339
11340 if (opts_type & OPTS_TYPE_HASH_COPY)
11341 {
11342 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11343
11344 hash_info_tmp->orighash = mystrdup (hash_buf);
11345 }
11346
11347 if (isSalted)
11348 {
11349 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11350 }
11351
11352 if (hash_mode == 3000)
11353 {
11354 if (hash_len == 32)
11355 {
11356 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11357
11358 if (parser_status < PARSER_GLOBAL_ZERO)
11359 {
11360 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11361
11362 continue;
11363 }
11364
11365 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11366
11367 hashes_cnt++;
11368
11369 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11370
11371 if (parser_status < PARSER_GLOBAL_ZERO)
11372 {
11373 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11374
11375 continue;
11376 }
11377
11378 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11379
11380 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);
11381
11382 hashes_cnt++;
11383
11384 // show / left
11385
11386 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);
11387 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);
11388 }
11389 else
11390 {
11391 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11392
11393 if (parser_status < PARSER_GLOBAL_ZERO)
11394 {
11395 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11396
11397 continue;
11398 }
11399
11400 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);
11401
11402 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11403 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11404
11405 hashes_cnt++;
11406 }
11407 }
11408 else
11409 {
11410 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11411
11412 if (parser_status < PARSER_GLOBAL_ZERO)
11413 {
11414 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11415
11416 continue;
11417 }
11418
11419 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);
11420
11421 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11422 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11423
11424 hashes_cnt++;
11425 }
11426 }
11427
11428 fclose (fp);
11429
11430 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11431
11432 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11433 }
11434 }
11435 else
11436 {
11437 if (isSalted)
11438 {
11439 hashes_buf[0].salt->salt_len = 8;
11440
11441 // special salt handling
11442
11443 switch (hash_mode)
11444 {
11445 case 1500: hashes_buf[0].salt->salt_len = 2;
11446 break;
11447 case 1731: hashes_buf[0].salt->salt_len = 4;
11448 break;
11449 case 2410: hashes_buf[0].salt->salt_len = 4;
11450 break;
11451 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11452 break;
11453 case 3100: hashes_buf[0].salt->salt_len = 1;
11454 break;
11455 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11456 break;
11457 case 5800: hashes_buf[0].salt->salt_len = 16;
11458 break;
11459 case 6800: hashes_buf[0].salt->salt_len = 32;
11460 break;
11461 case 8400: hashes_buf[0].salt->salt_len = 40;
11462 break;
11463 case 8800: hashes_buf[0].salt->salt_len = 16;
11464 break;
11465 case 8900: hashes_buf[0].salt->salt_len = 16;
11466 hashes_buf[0].salt->scrypt_N = 1024;
11467 hashes_buf[0].salt->scrypt_r = 1;
11468 hashes_buf[0].salt->scrypt_p = 1;
11469 break;
11470 case 9100: hashes_buf[0].salt->salt_len = 16;
11471 break;
11472 case 9300: hashes_buf[0].salt->salt_len = 14;
11473 hashes_buf[0].salt->scrypt_N = 16384;
11474 hashes_buf[0].salt->scrypt_r = 1;
11475 hashes_buf[0].salt->scrypt_p = 1;
11476 break;
11477 case 9400: hashes_buf[0].salt->salt_len = 16;
11478 break;
11479 case 9500: hashes_buf[0].salt->salt_len = 16;
11480 break;
11481 case 9600: hashes_buf[0].salt->salt_len = 16;
11482 break;
11483 case 9700: hashes_buf[0].salt->salt_len = 16;
11484 break;
11485 case 9710: hashes_buf[0].salt->salt_len = 16;
11486 break;
11487 case 9720: hashes_buf[0].salt->salt_len = 16;
11488 break;
11489 case 9800: hashes_buf[0].salt->salt_len = 16;
11490 break;
11491 case 9810: hashes_buf[0].salt->salt_len = 16;
11492 break;
11493 case 9820: hashes_buf[0].salt->salt_len = 16;
11494 break;
11495 case 10300: hashes_buf[0].salt->salt_len = 12;
11496 break;
11497 case 11500: hashes_buf[0].salt->salt_len = 4;
11498 break;
11499 case 11600: hashes_buf[0].salt->salt_len = 4;
11500 break;
11501 case 12400: hashes_buf[0].salt->salt_len = 4;
11502 break;
11503 case 12500: hashes_buf[0].salt->salt_len = 8;
11504 break;
11505 case 12600: hashes_buf[0].salt->salt_len = 64;
11506 break;
11507 }
11508
11509 // special esalt handling
11510
11511 switch (hash_mode)
11512 {
11513 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11514 break;
11515 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11516 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11517 break;
11518 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11519 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11520 break;
11521 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11522 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11523 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11524 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11525 break;
11526 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11527 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11528 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11529 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11530 break;
11531 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11532 break;
11533 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11534 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11535 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11536 break;
11537 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11538 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11539 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11540 break;
11541 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11542 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11543 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11544 break;
11545 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11546 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11547 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11548 break;
11549 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11550 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11551 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11552 break;
11553 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11554 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11555 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11556 break;
11557 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11558 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11559 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11560 break;
11561 }
11562 }
11563
11564 // set hashfile
11565
11566 switch (hash_mode)
11567 {
11568 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11569 break;
11570 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11571 break;
11572 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11573 break;
11574 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11575 break;
11576 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11577 break;
11578 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11579 break;
11580 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11581 break;
11582 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11583 break;
11584 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11585 break;
11586 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11587 break;
11588 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11589 break;
11590 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11591 break;
11592 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11593 break;
11594 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11595 break;
11596 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11597 break;
11598 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11599 break;
11600 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11601 break;
11602 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11603 break;
11604 }
11605
11606 // set default iterations
11607
11608 switch (hash_mode)
11609 {
11610 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11611 break;
11612 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11613 break;
11614 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11615 break;
11616 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11617 break;
11618 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11619 break;
11620 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11621 break;
11622 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11623 break;
11624 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11625 break;
11626 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11627 break;
11628 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11629 break;
11630 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11631 break;
11632 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11633 break;
11634 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11635 break;
11636 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11637 break;
11638 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11639 break;
11640 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11641 break;
11642 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11643 break;
11644 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11645 break;
11646 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11647 break;
11648 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11649 break;
11650 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11651 break;
11652 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11653 break;
11654 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11655 break;
11656 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11657 break;
11658 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11659 break;
11660 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11661 break;
11662 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11663 break;
11664 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11665 break;
11666 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11667 break;
11668 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11669 break;
11670 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11671 break;
11672 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11673 break;
11674 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11675 break;
11676 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11677 break;
11678 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11679 break;
11680 case 8900: hashes_buf[0].salt->salt_iter = 1;
11681 break;
11682 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11683 break;
11684 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11685 break;
11686 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11687 break;
11688 case 9300: hashes_buf[0].salt->salt_iter = 1;
11689 break;
11690 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11691 break;
11692 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11693 break;
11694 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11695 break;
11696 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11697 break;
11698 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11699 break;
11700 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11701 break;
11702 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11703 break;
11704 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11705 break;
11706 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11707 break;
11708 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11709 break;
11710 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11711 break;
11712 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11713 break;
11714 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11715 break;
11716 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11717 break;
11718 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11719 break;
11720 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11721 break;
11722 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11723 break;
11724 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11725 break;
11726 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11727 break;
11728 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11729 break;
11730 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11731 break;
11732 }
11733
11734 hashes_cnt = 1;
11735 }
11736
11737 if (show == 1 || left == 1)
11738 {
11739 for (uint i = 0; i < pot_cnt; i++)
11740 {
11741 pot_t *pot_ptr = &pot[i];
11742
11743 hash_t *hashes_buf = &pot_ptr->hash;
11744
11745 local_free (hashes_buf->digest);
11746
11747 if (isSalted)
11748 {
11749 local_free (hashes_buf->salt);
11750 }
11751 }
11752
11753 local_free (pot);
11754
11755 if (data.quiet == 0) log_info_nn ("");
11756
11757 return (0);
11758 }
11759
11760 if (keyspace == 0)
11761 {
11762 if (hashes_cnt == 0)
11763 {
11764 log_error ("ERROR: No hashes loaded");
11765
11766 return (-1);
11767 }
11768 }
11769
11770 /**
11771 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11772 */
11773
11774 if (data.outfile != NULL)
11775 {
11776 if (data.hashfile != NULL)
11777 {
11778 #ifdef _POSIX
11779 struct stat tmpstat_outfile;
11780 struct stat tmpstat_hashfile;
11781 #endif
11782
11783 #ifdef _WIN
11784 struct stat64 tmpstat_outfile;
11785 struct stat64 tmpstat_hashfile;
11786 #endif
11787
11788 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11789
11790 if (tmp_outfile_fp)
11791 {
11792 #ifdef _POSIX
11793 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11794 #endif
11795
11796 #ifdef _WIN
11797 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11798 #endif
11799
11800 fclose (tmp_outfile_fp);
11801 }
11802
11803 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11804
11805 if (tmp_hashfile_fp)
11806 {
11807 #ifdef _POSIX
11808 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11809 #endif
11810
11811 #ifdef _WIN
11812 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11813 #endif
11814
11815 fclose (tmp_hashfile_fp);
11816 }
11817
11818 if (tmp_outfile_fp && tmp_outfile_fp)
11819 {
11820 tmpstat_outfile.st_mode = 0;
11821 tmpstat_outfile.st_nlink = 0;
11822 tmpstat_outfile.st_uid = 0;
11823 tmpstat_outfile.st_gid = 0;
11824 tmpstat_outfile.st_rdev = 0;
11825 tmpstat_outfile.st_atime = 0;
11826
11827 tmpstat_hashfile.st_mode = 0;
11828 tmpstat_hashfile.st_nlink = 0;
11829 tmpstat_hashfile.st_uid = 0;
11830 tmpstat_hashfile.st_gid = 0;
11831 tmpstat_hashfile.st_rdev = 0;
11832 tmpstat_hashfile.st_atime = 0;
11833
11834 #ifdef _POSIX
11835 tmpstat_outfile.st_blksize = 0;
11836 tmpstat_outfile.st_blocks = 0;
11837
11838 tmpstat_hashfile.st_blksize = 0;
11839 tmpstat_hashfile.st_blocks = 0;
11840 #endif
11841
11842 #ifdef _POSIX
11843 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11844 {
11845 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11846
11847 return (-1);
11848 }
11849 #endif
11850
11851 #ifdef _WIN
11852 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11853 {
11854 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11855
11856 return (-1);
11857 }
11858 #endif
11859 }
11860 }
11861 }
11862
11863 /**
11864 * Remove duplicates
11865 */
11866
11867 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11868
11869 if (isSalted)
11870 {
11871 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11872 }
11873 else
11874 {
11875 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11876 }
11877
11878 uint hashes_cnt_orig = hashes_cnt;
11879
11880 hashes_cnt = 1;
11881
11882 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11883 {
11884 if (isSalted)
11885 {
11886 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11887 {
11888 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11889 }
11890 }
11891 else
11892 {
11893 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11894 }
11895
11896 if (hashes_pos > hashes_cnt)
11897 {
11898 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11899 }
11900
11901 hashes_cnt++;
11902 }
11903
11904 /**
11905 * Potfile removes
11906 */
11907
11908 uint potfile_remove_cracks = 0;
11909
11910 if (potfile_disable == 0)
11911 {
11912 hash_t hash_buf;
11913
11914 hash_buf.digest = mymalloc (dgst_size);
11915 hash_buf.salt = NULL;
11916 hash_buf.esalt = NULL;
11917 hash_buf.hash_info = NULL;
11918 hash_buf.cracked = 0;
11919
11920 if (isSalted)
11921 {
11922 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11923 }
11924
11925 if (esalt_size)
11926 {
11927 hash_buf.esalt = mymalloc (esalt_size);
11928 }
11929
11930 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11931
11932 // no solution for these special hash types (for instane because they use hashfile in output etc)
11933 if ((hash_mode != 5200) &&
11934 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11935 (hash_mode != 9000))
11936 {
11937 FILE *fp = fopen (potfile, "rb");
11938
11939 if (fp != NULL)
11940 {
11941 while (!feof (fp))
11942 {
11943 char line_buf[BUFSIZ] = { 0 };
11944
11945 char *ptr = fgets (line_buf, BUFSIZ - 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 // to be safe work with a copy (because of line_len loop, i etc)
11986
11987 char line_buf_cpy[BUFSIZ] = { 0 };
11988
11989 memcpy (line_buf_cpy, line_buf, i);
11990
11991 char *mac2_pos = strrchr (line_buf_cpy, ':');
11992
11993 if (mac2_pos == NULL) continue;
11994
11995 mac2_pos[0] = 0;
11996 mac2_pos++;
11997
11998 if (strlen (mac2_pos) != 12) continue;
11999
12000 char *mac1_pos = strrchr (line_buf_cpy, ':');
12001
12002 if (mac1_pos == NULL) continue;
12003
12004 mac1_pos[0] = 0;
12005 mac1_pos++;
12006
12007 if (strlen (mac1_pos) != 12) continue;
12008
12009 uint essid_length = mac1_pos - line_buf_cpy - 1;
12010
12011 // here we need the ESSID
12012 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12013
12014 hash_buf.salt->salt_len = essid_length;
12015
12016 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12017
12018 if (found)
12019 {
12020 wpa_t *wpa = (wpa_t *) found->esalt;
12021
12022 uint pke[25] = { 0 };
12023
12024 char *pke_ptr = (char *) pke;
12025
12026 for (uint i = 0; i < 25; i++)
12027 {
12028 pke[i] = byte_swap_32 (wpa->pke[i]);
12029 }
12030
12031 u8 mac1[6] = { 0 };
12032 u8 mac2[6] = { 0 };
12033
12034 memcpy (mac1, pke_ptr + 23, 6);
12035 memcpy (mac2, pke_ptr + 29, 6);
12036
12037 // compare hex string(s) vs binary MAC address(es)
12038
12039 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12040 {
12041 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12042 {
12043 found = NULL;
12044 break;
12045 }
12046 }
12047
12048 // early skip ;)
12049 if (!found) continue;
12050
12051 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12052 {
12053 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12054 {
12055 found = NULL;
12056 break;
12057 }
12058 }
12059 }
12060 }
12061 }
12062 else
12063 {
12064 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12065
12066 if (parser_status == PARSER_OK)
12067 {
12068 if (isSalted)
12069 {
12070 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12071 }
12072 else
12073 {
12074 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12075 }
12076 }
12077 }
12078
12079 if (found == NULL) continue;
12080
12081 if (!found->cracked) potfile_remove_cracks++;
12082
12083 found->cracked = 1;
12084
12085 if (found) break;
12086
12087 iter--;
12088 }
12089 }
12090
12091 fclose (fp);
12092 }
12093 }
12094
12095 if (esalt_size)
12096 {
12097 local_free (hash_buf.esalt);
12098 }
12099
12100 if (isSalted)
12101 {
12102 local_free (hash_buf.salt);
12103 }
12104
12105 local_free (hash_buf.digest);
12106 }
12107
12108 /**
12109 * Now generate all the buffers required for later
12110 */
12111
12112 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12113
12114 salt_t *salts_buf_new = NULL;
12115 void *esalts_buf_new = NULL;
12116
12117 if (isSalted)
12118 {
12119 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12124 }
12125 }
12126 else
12127 {
12128 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12129 }
12130
12131 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12132
12133 uint digests_cnt = hashes_cnt;
12134 uint digests_done = 0;
12135
12136 uint size_digests = digests_cnt * dgst_size;
12137 uint size_shown = digests_cnt * sizeof (uint);
12138
12139 uint *digests_shown = (uint *) mymalloc (size_shown);
12140 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12141
12142 uint salts_cnt = 0;
12143 uint salts_done = 0;
12144
12145 hashinfo_t **hash_info = NULL;
12146
12147 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12148 {
12149 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12150
12151 if (username && (remove || show))
12152 {
12153 uint user_pos;
12154
12155 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12156 {
12157 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12158
12159 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12160 }
12161 }
12162 }
12163
12164 uint *salts_shown = (uint *) mymalloc (size_shown);
12165
12166 salt_t *salt_buf;
12167
12168 {
12169 // copied from inner loop
12170
12171 salt_buf = &salts_buf_new[salts_cnt];
12172
12173 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12174
12175 if (esalt_size)
12176 {
12177 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12178 }
12179
12180 salt_buf->digests_cnt = 0;
12181 salt_buf->digests_done = 0;
12182 salt_buf->digests_offset = 0;
12183
12184 salts_cnt++;
12185 }
12186
12187 if (hashes_buf[0].cracked == 1)
12188 {
12189 digests_shown[0] = 1;
12190
12191 digests_done++;
12192
12193 salt_buf->digests_done++;
12194 }
12195
12196 salt_buf->digests_cnt++;
12197
12198 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12199
12200 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12201 {
12202 hash_info[0] = hashes_buf[0].hash_info;
12203 }
12204
12205 // copy from inner loop
12206
12207 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12208 {
12209 if (isSalted)
12210 {
12211 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12212 {
12213 salt_buf = &salts_buf_new[salts_cnt];
12214
12215 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12216
12217 if (esalt_size)
12218 {
12219 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12220 }
12221
12222 salt_buf->digests_cnt = 0;
12223 salt_buf->digests_done = 0;
12224 salt_buf->digests_offset = hashes_pos;
12225
12226 salts_cnt++;
12227 }
12228 }
12229
12230 if (hashes_buf[hashes_pos].cracked == 1)
12231 {
12232 digests_shown[hashes_pos] = 1;
12233
12234 digests_done++;
12235
12236 salt_buf->digests_done++;
12237 }
12238
12239 salt_buf->digests_cnt++;
12240
12241 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12242
12243 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12244 {
12245 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12246 }
12247 }
12248
12249 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12250 {
12251 salt_t *salt_buf = &salts_buf_new[salt_pos];
12252
12253 if (salt_buf->digests_done == salt_buf->digests_cnt)
12254 {
12255 salts_shown[salt_pos] = 1;
12256
12257 salts_done++;
12258 }
12259
12260 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12261 }
12262
12263 local_free (digests_buf);
12264 local_free (salts_buf);
12265 local_free (esalts_buf);
12266
12267 digests_buf = digests_buf_new;
12268 salts_buf = salts_buf_new;
12269 esalts_buf = esalts_buf_new;
12270
12271 local_free (hashes_buf);
12272
12273 /**
12274 * special modification not set from parser
12275 */
12276
12277 switch (hash_mode)
12278 {
12279 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12280 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12281 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12282 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12283 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12284 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12285 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12286 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12287 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12288 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12289 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12290 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12291 }
12292
12293 if (truecrypt_keyfiles)
12294 {
12295 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12296
12297 char *keyfiles = strdup (truecrypt_keyfiles);
12298
12299 char *keyfile = strtok (keyfiles, ",");
12300
12301 do
12302 {
12303 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12304
12305 } while ((keyfile = strtok (NULL, ",")) != NULL);
12306
12307 free (keyfiles);
12308 }
12309
12310 data.digests_cnt = digests_cnt;
12311 data.digests_done = digests_done;
12312 data.digests_buf = digests_buf;
12313 data.digests_shown = digests_shown;
12314 data.digests_shown_tmp = digests_shown_tmp;
12315
12316 data.salts_cnt = salts_cnt;
12317 data.salts_done = salts_done;
12318 data.salts_buf = salts_buf;
12319 data.salts_shown = salts_shown;
12320
12321 data.esalts_buf = esalts_buf;
12322 data.hash_info = hash_info;
12323
12324 /**
12325 * Automatic Optimizers
12326 */
12327
12328 if (salts_cnt == 1)
12329 opti_type |= OPTI_TYPE_SINGLE_SALT;
12330
12331 if (digests_cnt == 1)
12332 opti_type |= OPTI_TYPE_SINGLE_HASH;
12333
12334 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12335 opti_type |= OPTI_TYPE_NOT_ITERATED;
12336
12337 if (attack_mode == ATTACK_MODE_BF)
12338 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12339
12340 data.opti_type = opti_type;
12341
12342 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12343 {
12344 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12345 {
12346 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12347 {
12348 if (opts_type & OPTS_TYPE_ST_ADD80)
12349 {
12350 opts_type &= ~OPTS_TYPE_ST_ADD80;
12351 opts_type |= OPTS_TYPE_PT_ADD80;
12352 }
12353
12354 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12355 {
12356 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12357 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12358 }
12359
12360 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12361 {
12362 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12363 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12364 }
12365 }
12366 }
12367 }
12368
12369 /**
12370 * Some algorithm, like descrypt, can benefit from JIT compilation
12371 */
12372
12373 int force_jit_compilation = -1;
12374
12375 if (hash_mode == 8900)
12376 {
12377 force_jit_compilation = 8900;
12378 }
12379 else if (hash_mode == 9300)
12380 {
12381 force_jit_compilation = 8900;
12382 }
12383 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12384 {
12385 force_jit_compilation = 1500;
12386 }
12387
12388 /**
12389 * generate bitmap tables
12390 */
12391
12392 const uint bitmap_shift1 = 5;
12393 const uint bitmap_shift2 = 13;
12394
12395 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12396
12397 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12398 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12399 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12400 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12401 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12402 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12403 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12404 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12405
12406 uint bitmap_bits;
12407 uint bitmap_nums;
12408 uint bitmap_mask;
12409 uint bitmap_size;
12410
12411 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12412 {
12413 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12414
12415 bitmap_nums = 1 << bitmap_bits;
12416
12417 bitmap_mask = bitmap_nums - 1;
12418
12419 bitmap_size = bitmap_nums * sizeof (uint);
12420
12421 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12422
12423 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;
12424 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;
12425
12426 break;
12427 }
12428
12429 bitmap_nums = 1 << bitmap_bits;
12430
12431 bitmap_mask = bitmap_nums - 1;
12432
12433 bitmap_size = bitmap_nums * sizeof (uint);
12434
12435 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);
12436 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);
12437
12438 /**
12439 * prepare quick rule
12440 */
12441
12442 data.rule_buf_l = rule_buf_l;
12443 data.rule_buf_r = rule_buf_r;
12444
12445 int rule_len_l = (int) strlen (rule_buf_l);
12446 int rule_len_r = (int) strlen (rule_buf_r);
12447
12448 data.rule_len_l = rule_len_l;
12449 data.rule_len_r = rule_len_r;
12450
12451 /**
12452 * load rules
12453 */
12454
12455 uint *all_kernel_rules_cnt = NULL;
12456
12457 kernel_rule_t **all_kernel_rules_buf = NULL;
12458
12459 if (rp_files_cnt)
12460 {
12461 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12462
12463 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12464 }
12465
12466 char rule_buf[BUFSIZ] = { 0 };
12467
12468 int rule_len = 0;
12469
12470 for (uint i = 0; i < rp_files_cnt; i++)
12471 {
12472 uint kernel_rules_avail = 0;
12473
12474 uint kernel_rules_cnt = 0;
12475
12476 kernel_rule_t *kernel_rules_buf = NULL;
12477
12478 char *rp_file = rp_files[i];
12479
12480 char in[BLOCK_SIZE] = { 0 };
12481 char out[BLOCK_SIZE] = { 0 };
12482
12483 FILE *fp = NULL;
12484
12485 uint rule_line = 0;
12486
12487 if ((fp = fopen (rp_file, "rb")) == NULL)
12488 {
12489 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12490
12491 return (-1);
12492 }
12493
12494 while (!feof (fp))
12495 {
12496 memset (rule_buf, 0, BUFSIZ);
12497
12498 rule_len = fgetl (fp, rule_buf);
12499
12500 rule_line++;
12501
12502 if (rule_len == 0) continue;
12503
12504 if (rule_buf[0] == '#') continue;
12505
12506 if (kernel_rules_avail == kernel_rules_cnt)
12507 {
12508 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12509
12510 kernel_rules_avail += INCR_RULES;
12511 }
12512
12513 memset (in, 0, BLOCK_SIZE);
12514 memset (out, 0, BLOCK_SIZE);
12515
12516 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12517
12518 if (result == -1)
12519 {
12520 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12521
12522 continue;
12523 }
12524
12525 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12526 {
12527 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12528
12529 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12530
12531 continue;
12532 }
12533
12534 /* its so slow
12535 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12536 {
12537 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12538
12539 continue;
12540 }
12541 */
12542
12543 kernel_rules_cnt++;
12544 }
12545
12546 fclose (fp);
12547
12548 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12549
12550 all_kernel_rules_buf[i] = kernel_rules_buf;
12551 }
12552
12553 /**
12554 * merge rules or automatic rule generator
12555 */
12556
12557 uint kernel_rules_cnt = 0;
12558
12559 kernel_rule_t *kernel_rules_buf = NULL;
12560
12561 if (attack_mode == ATTACK_MODE_STRAIGHT)
12562 {
12563 if (rp_files_cnt)
12564 {
12565 kernel_rules_cnt = 1;
12566
12567 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12568
12569 repeats[0] = kernel_rules_cnt;
12570
12571 for (uint i = 0; i < rp_files_cnt; i++)
12572 {
12573 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12574
12575 repeats[i + 1] = kernel_rules_cnt;
12576 }
12577
12578 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12579
12580 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12581
12582 for (uint i = 0; i < kernel_rules_cnt; i++)
12583 {
12584 uint out_pos = 0;
12585
12586 kernel_rule_t *out = &kernel_rules_buf[i];
12587
12588 for (uint j = 0; j < rp_files_cnt; j++)
12589 {
12590 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12591 uint in_pos;
12592
12593 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12594
12595 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12596 {
12597 if (out_pos == RULES_MAX - 1)
12598 {
12599 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12600
12601 break;
12602 }
12603
12604 out->cmds[out_pos] = in->cmds[in_pos];
12605 }
12606 }
12607 }
12608
12609 local_free (repeats);
12610 }
12611 else if (rp_gen)
12612 {
12613 uint kernel_rules_avail = 0;
12614
12615 while (kernel_rules_cnt < rp_gen)
12616 {
12617 if (kernel_rules_avail == kernel_rules_cnt)
12618 {
12619 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12620
12621 kernel_rules_avail += INCR_RULES;
12622 }
12623
12624 memset (rule_buf, 0, BLOCK_SIZE);
12625
12626 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12627
12628 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12629
12630 kernel_rules_cnt++;
12631 }
12632 }
12633 }
12634
12635 /**
12636 * generate NOP rules
12637 */
12638
12639 if (kernel_rules_cnt == 0)
12640 {
12641 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12642
12643 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12644
12645 kernel_rules_cnt++;
12646 }
12647
12648 data.kernel_rules_cnt = kernel_rules_cnt;
12649 data.kernel_rules_buf = kernel_rules_buf;
12650
12651 /**
12652 * OpenCL platforms: detect
12653 */
12654
12655 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12656 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12657
12658 cl_uint platforms_cnt = 0;
12659 cl_uint platform_devices_cnt = 0;
12660
12661 if (keyspace == 0)
12662 {
12663 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12664
12665 if (platforms_cnt == 0)
12666 {
12667 log_error ("ERROR: No OpenCL compatible platform found");
12668
12669 return (-1);
12670 }
12671 }
12672
12673 /**
12674 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12675 */
12676
12677 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12678 {
12679 cl_platform_id platform = platforms[platform_id];
12680
12681 char platform_vendor[INFOSZ] = { 0 };
12682
12683 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12684
12685 #ifdef HAVE_HWMON
12686 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12687 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12688 {
12689 // make sure that we do not directly control the fan for NVidia
12690
12691 gpu_temp_retain = 0;
12692
12693 data.gpu_temp_retain = gpu_temp_retain;
12694 }
12695 #endif // HAVE_NVML || HAVE_NVAPI
12696 #endif
12697 }
12698
12699 /**
12700 * OpenCL devices: simply push all devices from all platforms into the same device array
12701 */
12702
12703 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12704
12705 data.devices_param = devices_param;
12706
12707 uint devices_cnt = 0;
12708
12709 uint devices_active = 0;
12710
12711 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12712 {
12713 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12714
12715 cl_platform_id platform = platforms[platform_id];
12716
12717 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12718
12719 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12720 {
12721 size_t param_value_size = 0;
12722
12723 const uint device_id = devices_cnt;
12724
12725 hc_device_param_t *device_param = &data.devices_param[device_id];
12726
12727 device_param->device = platform_devices[platform_devices_id];
12728
12729 device_param->device_id = device_id;
12730
12731 device_param->platform_devices_id = platform_devices_id;
12732
12733 // device_type
12734
12735 cl_device_type device_type;
12736
12737 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12738
12739 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12740
12741 device_param->device_type = device_type;
12742
12743 // vendor_id
12744
12745 cl_uint vendor_id = 0;
12746
12747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12748
12749 device_param->vendor_id = vendor_id;
12750
12751 // device_name
12752
12753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12754
12755 char *device_name = (char *) mymalloc (param_value_size);
12756
12757 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12758
12759 device_param->device_name = device_name;
12760
12761 // tuning db
12762
12763 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12764
12765 // device_version
12766
12767 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12768
12769 char *device_version = (char *) mymalloc (param_value_size);
12770
12771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12772
12773 device_param->device_version = device_version;
12774
12775 // device_opencl_version
12776
12777 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12778
12779 char *device_opencl_version = (char *) mymalloc (param_value_size);
12780
12781 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12782
12783 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12784
12785 myfree (device_opencl_version);
12786
12787 if (strstr (device_version, "pocl"))
12788 {
12789 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12790 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12791
12792 cl_uint vendor_id = VENDOR_ID_GENERIC;
12793
12794 device_param->vendor_id = vendor_id;
12795 }
12796
12797 // vector_width
12798
12799 cl_uint vector_width;
12800
12801 if (opencl_vector_width_chgd == 0)
12802 {
12803 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12804 {
12805 if (opti_type & OPTI_TYPE_USES_BITS_64)
12806 {
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12808 }
12809 else
12810 {
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12812 }
12813 }
12814 else
12815 {
12816 vector_width = (cl_uint) tuningdb_entry->vector_width;
12817 }
12818 }
12819 else
12820 {
12821 vector_width = opencl_vector_width;
12822 }
12823
12824 if (vector_width > 16) vector_width = 16;
12825
12826 device_param->vector_width = vector_width;
12827
12828 // max_compute_units
12829
12830 cl_uint device_processors;
12831
12832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12833
12834 device_param->device_processors = device_processors;
12835
12836 // max_mem_alloc_size
12837
12838 cl_ulong device_maxmem_alloc;
12839
12840 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12841
12842 device_param->device_maxmem_alloc = device_maxmem_alloc;
12843
12844 // max_mem_alloc_size
12845
12846 cl_ulong device_global_mem;
12847
12848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12849
12850 device_param->device_global_mem = device_global_mem;
12851
12852 // max_clock_frequency
12853
12854 cl_uint device_maxclock_frequency;
12855
12856 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12857
12858 device_param->device_maxclock_frequency = device_maxclock_frequency;
12859
12860 // skipped
12861
12862 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12863 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12864
12865 device_param->skipped = (skipped1 || skipped2);
12866
12867 // driver_version
12868 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12869
12870 char *driver_version = (char *) mymalloc (param_value_size);
12871
12872 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12873
12874 device_param->driver_version = driver_version;
12875
12876 // device_name_chksum
12877
12878 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12879
12880 #if __x86_64__
12881 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);
12882 #else
12883 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);
12884 #endif
12885
12886 uint device_name_digest[4] = { 0 };
12887
12888 md5_64 ((uint *) device_name_chksum, device_name_digest);
12889
12890 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12891
12892 device_param->device_name_chksum = device_name_chksum;
12893
12894 // device_processor_cores
12895
12896 if (device_type & CL_DEVICE_TYPE_CPU)
12897 {
12898 cl_uint device_processor_cores = 1;
12899
12900 device_param->device_processor_cores = device_processor_cores;
12901 }
12902
12903 if (device_type & CL_DEVICE_TYPE_GPU)
12904 {
12905 if (vendor_id == VENDOR_ID_AMD)
12906 {
12907 cl_uint device_processor_cores = 0;
12908
12909 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12910
12911 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12912
12913 device_param->device_processor_cores = device_processor_cores;
12914 }
12915 else if (vendor_id == VENDOR_ID_NV)
12916 {
12917 cl_uint kernel_exec_timeout = 0;
12918
12919 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12920
12921 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12922
12923 device_param->kernel_exec_timeout = kernel_exec_timeout;
12924
12925 cl_uint device_processor_cores = 0;
12926
12927 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12928
12929 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12930
12931 device_param->device_processor_cores = device_processor_cores;
12932
12933 cl_uint sm_minor = 0;
12934 cl_uint sm_major = 0;
12935
12936 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12937 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12938
12939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12940 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12941
12942 device_param->sm_minor = sm_minor;
12943 device_param->sm_major = sm_major;
12944 }
12945 else
12946 {
12947 cl_uint device_processor_cores = 1;
12948
12949 device_param->device_processor_cores = device_processor_cores;
12950 }
12951 }
12952
12953 // display results
12954
12955 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12956 {
12957 if (device_param->skipped == 0)
12958 {
12959 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12960 device_id + 1,
12961 device_name,
12962 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12963 (unsigned int) (device_global_mem / 1024 / 1024),
12964 (unsigned int) (device_maxclock_frequency),
12965 (unsigned int) device_processors);
12966 }
12967 else
12968 {
12969 log_info ("Device #%u: %s, skipped",
12970 device_id + 1,
12971 device_name);
12972 }
12973 }
12974
12975 // common driver check
12976
12977 if (device_param->skipped == 0)
12978 {
12979 if (strstr (device_version, "pocl"))
12980 {
12981 if (force == 0)
12982 {
12983 log_info ("");
12984 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12985 log_info ("You are STRONGLY encouraged not to use it");
12986 log_info ("You can use --force to override this but do not post error reports if you do so");
12987 log_info ("");
12988
12989 return (-1);
12990 }
12991 }
12992
12993 if (device_type & CL_DEVICE_TYPE_GPU)
12994 {
12995 if (vendor_id == VENDOR_ID_NV)
12996 {
12997 if (device_param->kernel_exec_timeout != 0)
12998 {
12999 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);
13000 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13001 }
13002 }
13003 else if (vendor_id == VENDOR_ID_AMD)
13004 {
13005 int catalyst_check = (force == 1) ? 0 : 1;
13006
13007 int catalyst_warn = 0;
13008
13009 int catalyst_broken = 0;
13010
13011 if (catalyst_check == 1)
13012 {
13013 catalyst_warn = 1;
13014
13015 // v14.9 and higher
13016 if (atoi (device_param->driver_version) >= 1573)
13017 {
13018 catalyst_warn = 0;
13019 }
13020
13021 catalyst_check = 0;
13022 }
13023
13024 if (catalyst_broken == 1)
13025 {
13026 log_info ("");
13027 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13028 log_info ("It will pass over cracked hashes and does not report them as cracked");
13029 log_info ("You are STRONGLY encouraged not to use it");
13030 log_info ("You can use --force to override this but do not post error reports if you do so");
13031 log_info ("");
13032
13033 return (-1);
13034 }
13035
13036 if (catalyst_warn == 1)
13037 {
13038 log_info ("");
13039 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13040 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13041 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13042 #ifdef _WIN
13043 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13044 #endif
13045 log_info ("You can use --force to override this but do not post error reports if you do so");
13046 log_info ("");
13047
13048 return (-1);
13049 }
13050 }
13051 }
13052
13053 /**
13054 * kernel accel and loops tuning db adjustment
13055 */
13056
13057 uint _kernel_accel = kernel_accel;
13058 uint _kernel_loops = kernel_loops;
13059
13060 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
13061
13062 if (kernel_accel_chgd == 0)
13063 {
13064 if (tuningdb_entry)
13065 {
13066 _kernel_accel = tuningdb_entry->kernel_accel;
13067 }
13068 }
13069
13070 if (kernel_loops_chgd == 0)
13071 {
13072 if (tuningdb_entry)
13073 {
13074 _kernel_loops = tuningdb_entry->kernel_loops;
13075
13076 if (workload_profile == 1)
13077 {
13078 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13079 }
13080 else if (workload_profile == 2)
13081 {
13082 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13083 }
13084 }
13085 }
13086
13087 device_param->kernel_accel = _kernel_accel;
13088 device_param->kernel_loops = _kernel_loops;
13089
13090 devices_active++;
13091 }
13092
13093 // next please
13094
13095 devices_cnt++;
13096 }
13097 }
13098
13099 if (keyspace == 0 && devices_active == 0)
13100 {
13101 log_error ("ERROR: No devices found/left");
13102
13103 return (-1);
13104 }
13105
13106 data.devices_cnt = devices_cnt;
13107
13108 data.devices_active = devices_active;
13109
13110 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13111 {
13112 log_info ("");
13113 }
13114
13115 /**
13116 * HM devices: init
13117 */
13118
13119 #ifdef HAVE_HWMON
13120 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13121 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13122 #endif
13123
13124 #ifdef HAVE_ADL
13125 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13126 #endif
13127
13128 if (gpu_temp_disable == 0)
13129 {
13130 #if defined(WIN) && defined(HAVE_NVAPI)
13131 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13132
13133 if (nvapi_init (nvapi) == 0)
13134 data.hm_nv = nvapi;
13135
13136 if (data.hm_nv)
13137 {
13138 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13139 {
13140 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13141
13142 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13143
13144 int tmp_out = 0;
13145
13146 for (int i = 0; i < tmp_in; i++)
13147 {
13148 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13149 }
13150
13151 for (int i = 0; i < tmp_out; i++)
13152 {
13153 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13154
13155 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13156
13157 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;
13158 }
13159 }
13160 }
13161 #endif // WIN && HAVE_NVAPI
13162
13163 #if defined(LINUX) && defined(HAVE_NVML)
13164 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13165
13166 if (nvml_init (nvml) == 0)
13167 data.hm_nv = nvml;
13168
13169 if (data.hm_nv)
13170 {
13171 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13172 {
13173 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13174
13175 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13176
13177 int tmp_out = 0;
13178
13179 for (int i = 0; i < tmp_in; i++)
13180 {
13181 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13182 }
13183
13184 for (int i = 0; i < tmp_out; i++)
13185 {
13186 unsigned int speed;
13187
13188 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;
13189 }
13190 }
13191 }
13192 #endif // LINUX && HAVE_NVML
13193
13194 data.hm_amd = NULL;
13195
13196 #ifdef HAVE_ADL
13197 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13198
13199 if (adl_init (adl) == 0)
13200 data.hm_amd = adl;
13201
13202 if (data.hm_amd)
13203 {
13204 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13205 {
13206 // total number of adapters
13207
13208 int hm_adapters_num;
13209
13210 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13211
13212 // adapter info
13213
13214 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13215
13216 if (lpAdapterInfo == NULL) return (-1);
13217
13218 // get a list (of ids of) valid/usable adapters
13219
13220 int num_adl_adapters = 0;
13221
13222 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13223
13224 if (num_adl_adapters > 0)
13225 {
13226 hc_thread_mutex_lock (mux_adl);
13227
13228 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13229
13230 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13231
13232 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13233 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13234
13235 hc_thread_mutex_unlock (mux_adl);
13236 }
13237
13238 myfree (valid_adl_device_list);
13239 myfree (lpAdapterInfo);
13240 }
13241 }
13242 #endif // HAVE_ADL
13243
13244 if (data.hm_amd == NULL && data.hm_nv == NULL)
13245 {
13246 gpu_temp_disable = 1;
13247 }
13248 }
13249
13250 /**
13251 * OpenCL devices: allocate buffer for device specific information
13252 */
13253
13254 #ifdef HAVE_HWMON
13255 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13256
13257 #ifdef HAVE_ADL
13258 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13259
13260 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13261 #endif // ADL
13262 #endif
13263
13264 /**
13265 * enable custom signal handler(s)
13266 */
13267
13268 if (benchmark == 0)
13269 {
13270 hc_signal (sigHandler_default);
13271 }
13272 else
13273 {
13274 hc_signal (sigHandler_benchmark);
13275 }
13276
13277 /**
13278 * User-defined GPU temp handling
13279 */
13280
13281 #ifdef HAVE_HWMON
13282 if (gpu_temp_disable == 1)
13283 {
13284 gpu_temp_abort = 0;
13285 gpu_temp_retain = 0;
13286 }
13287
13288 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13289 {
13290 if (gpu_temp_abort < gpu_temp_retain)
13291 {
13292 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13293
13294 return (-1);
13295 }
13296 }
13297
13298 data.gpu_temp_disable = gpu_temp_disable;
13299 data.gpu_temp_abort = gpu_temp_abort;
13300 data.gpu_temp_retain = gpu_temp_retain;
13301 #endif
13302
13303 /**
13304 * inform the user
13305 */
13306
13307 if (data.quiet == 0)
13308 {
13309 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13310
13311 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);
13312
13313 if (attack_mode == ATTACK_MODE_STRAIGHT)
13314 {
13315 log_info ("Rules: %u", kernel_rules_cnt);
13316 }
13317
13318 if (opti_type)
13319 {
13320 log_info ("Applicable Optimizers:");
13321
13322 for (uint i = 0; i < 32; i++)
13323 {
13324 const uint opti_bit = 1u << i;
13325
13326 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13327 }
13328 }
13329
13330 /**
13331 * Watchdog and Temperature balance
13332 */
13333
13334 #ifdef HAVE_HWMON
13335 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13336 {
13337 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13338 }
13339
13340 if (gpu_temp_abort == 0)
13341 {
13342 log_info ("Watchdog: Temperature abort trigger disabled");
13343 }
13344 else
13345 {
13346 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13347 }
13348
13349 if (gpu_temp_retain == 0)
13350 {
13351 log_info ("Watchdog: Temperature retain trigger disabled");
13352 }
13353 else
13354 {
13355 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13356 }
13357 #endif
13358 }
13359
13360 if (data.quiet == 0) log_info ("");
13361
13362 /**
13363 * HM devices: copy
13364 */
13365
13366 if (gpu_temp_disable == 0)
13367 {
13368 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13369 {
13370 hc_device_param_t *device_param = &data.devices_param[device_id];
13371
13372 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13373
13374 if (device_param->skipped) continue;
13375
13376 const uint platform_devices_id = device_param->platform_devices_id;
13377
13378 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13379 if (device_param->vendor_id == VENDOR_ID_NV)
13380 {
13381 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13382 }
13383 #endif
13384
13385 #ifdef HAVE_ADL
13386 if (device_param->vendor_id == VENDOR_ID_AMD)
13387 {
13388 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13389 }
13390 #endif
13391 }
13392 }
13393
13394 /*
13395 * Temporary fix:
13396 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13397 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13398 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13399 * Driver / ADL bug?
13400 */
13401
13402 #ifdef HAVE_ADL
13403 if (powertune_enable == 1)
13404 {
13405 hc_thread_mutex_lock (mux_adl);
13406
13407 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13408 {
13409 hc_device_param_t *device_param = &data.devices_param[device_id];
13410
13411 if (device_param->skipped) continue;
13412
13413 if (data.hm_device[device_id].od_version == 6)
13414 {
13415 // set powertune value only
13416
13417 int powertune_supported = 0;
13418
13419 int ADL_rc = 0;
13420
13421 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13422 {
13423 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13424
13425 return (-1);
13426 }
13427
13428 if (powertune_supported != 0)
13429 {
13430 // powertune set
13431 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13432
13433 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13434 {
13435 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13436
13437 return (-1);
13438 }
13439
13440 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13441 {
13442 log_error ("ERROR: Failed to set new ADL PowerControl values");
13443
13444 return (-1);
13445 }
13446 }
13447 }
13448 }
13449
13450 hc_thread_mutex_unlock (mux_adl);
13451 }
13452 #endif // HAVE_ADK
13453 #endif // HAVE_HWMON
13454
13455 #ifdef OSX
13456 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13457 {
13458 if (force == 0)
13459 {
13460 log_info ("");
13461 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13462 log_info ("You can use --force to override this but do not post error reports if you do so");
13463 log_info ("");
13464
13465 continue;
13466 }
13467 }
13468 #endif
13469
13470 #ifdef DEBUG
13471 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13472 #endif
13473
13474 uint kernel_power_all = 0;
13475
13476 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13477 {
13478 /**
13479 * host buffer
13480 */
13481
13482 hc_device_param_t *device_param = &data.devices_param[device_id];
13483
13484 if (device_param->skipped) continue;
13485
13486 /**
13487 * device properties
13488 */
13489
13490 const char *device_name_chksum = device_param->device_name_chksum;
13491 const u32 device_processors = device_param->device_processors;
13492 const u32 device_processor_cores = device_param->device_processor_cores;
13493
13494 /**
13495 * create context for each device
13496 */
13497
13498 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13499
13500 /**
13501 * create command-queue
13502 */
13503
13504 // not supported with NV
13505 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13506
13507 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13508
13509 /**
13510 * create input buffers on device : calculate size of fixed memory buffers
13511 */
13512
13513 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13514 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13515
13516 device_param->size_root_css = size_root_css;
13517 device_param->size_markov_css = size_markov_css;
13518
13519 uint size_results = KERNEL_THREADS * sizeof (uint);
13520
13521 device_param->size_results = size_results;
13522
13523 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13524 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13525
13526 uint size_plains = digests_cnt * sizeof (plain_t);
13527 uint size_salts = salts_cnt * sizeof (salt_t);
13528 uint size_esalts = salts_cnt * esalt_size;
13529
13530 device_param->size_plains = size_plains;
13531 device_param->size_digests = size_digests;
13532 device_param->size_shown = size_shown;
13533 device_param->size_salts = size_salts;
13534
13535 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13536 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13537 uint size_tm = 32 * sizeof (bs_word_t);
13538
13539 // scryptV stuff
13540
13541 u64 size_scryptV = 1;
13542
13543 if ((hash_mode == 8900) || (hash_mode == 9300))
13544 {
13545 uint tmto_start = 0;
13546 uint tmto_stop = 10;
13547
13548 if (scrypt_tmto)
13549 {
13550 tmto_start = scrypt_tmto;
13551 }
13552 else
13553 {
13554 // in case the user did not specify the tmto manually
13555 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13556 // but set the lower end only in case the user has a device with too less memory
13557
13558 if (hash_mode == 8900)
13559 {
13560 if (device_param->vendor_id == VENDOR_ID_AMD)
13561 {
13562 tmto_start = 1;
13563 }
13564 else if (device_param->vendor_id == VENDOR_ID_NV)
13565 {
13566 tmto_start = 3;
13567 }
13568 }
13569 else if (hash_mode == 9300)
13570 {
13571 if (device_param->vendor_id == VENDOR_ID_AMD)
13572 {
13573 tmto_start = 3;
13574 }
13575 else if (device_param->vendor_id == VENDOR_ID_NV)
13576 {
13577 tmto_start = 5;
13578 }
13579 }
13580 }
13581
13582 if (quiet == 0) log_info ("");
13583
13584 uint shader_per_mp = 1;
13585
13586 if (device_param->vendor_id == VENDOR_ID_AMD)
13587 {
13588 shader_per_mp = 8;
13589 }
13590 else if (device_param->vendor_id == VENDOR_ID_NV)
13591 {
13592 shader_per_mp = 32;
13593 }
13594
13595 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13596 {
13597 // TODO: in theory the following calculation needs to be done per salt, not global
13598 // we assume all hashes have the same scrypt settings
13599
13600 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13601
13602 size_scryptV /= 1 << tmto;
13603
13604 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13605
13606 if (size_scryptV > device_param->device_maxmem_alloc)
13607 {
13608 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13609
13610 continue;
13611 }
13612
13613 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13614 {
13615 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13616 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13617 }
13618
13619 break;
13620 }
13621
13622 if (data.salts_buf[0].scrypt_phy == 0)
13623 {
13624 log_error ("ERROR: can't allocate enough device memory");
13625
13626 return -1;
13627 }
13628
13629 if (quiet == 0) log_info ("");
13630 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13631 }
13632
13633 /**
13634 * create input buffers on device : calculate size of dynamic size memory buffers
13635 */
13636
13637 uint kernel_threads = KERNEL_THREADS;
13638
13639 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13640
13641 if (hash_mode == 3200) kernel_threads = 8;
13642 if (hash_mode == 9000) kernel_threads = 8;
13643
13644 /**
13645 * some algorithms need a fixed kernel-loops count
13646 */
13647
13648 u32 kernel_loops_min = 1;
13649 u32 kernel_loops_max = 1024;
13650
13651 if (hash_mode == 1500)
13652 {
13653 const u32 kernel_loops_fixed = 1024;
13654
13655 kernel_loops_min = kernel_loops_fixed;
13656 kernel_loops_max = kernel_loops_fixed;
13657 }
13658
13659 if (hash_mode == 3000)
13660 {
13661 const u32 kernel_loops_fixed = 1024;
13662
13663 kernel_loops_min = kernel_loops_fixed;
13664 kernel_loops_max = kernel_loops_fixed;
13665 }
13666
13667 if (hash_mode == 8900)
13668 {
13669 const u32 kernel_loops_fixed = 1;
13670
13671 kernel_loops_min = kernel_loops_fixed;
13672 kernel_loops_max = kernel_loops_fixed;
13673 }
13674
13675 if (hash_mode == 9300)
13676 {
13677 const u32 kernel_loops_fixed = 1;
13678
13679 kernel_loops_min = kernel_loops_fixed;
13680 kernel_loops_max = kernel_loops_fixed;
13681 }
13682
13683 if (hash_mode == 12500)
13684 {
13685 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13686
13687 kernel_loops_min = kernel_loops_fixed;
13688 kernel_loops_max = kernel_loops_fixed;
13689 }
13690
13691 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13692 {
13693 if (data.salts_buf[0].salt_iter < kernel_loops_max)
13694 {
13695 kernel_loops_max = data.salts_buf[0].salt_iter;
13696 }
13697 }
13698
13699 device_param->kernel_loops_min = kernel_loops_min;
13700 device_param->kernel_loops_max = kernel_loops_max;
13701
13702 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13703
13704 uint size_pws = 4;
13705 uint size_tmps = 4;
13706 uint size_hooks = 4;
13707
13708 uint kernel_accel_min = 1;
13709 uint kernel_accel_max = 1024;
13710
13711 /**
13712 * some algorithms need a special kernel-accel
13713 */
13714
13715 if (hash_mode == 8900)
13716 {
13717 kernel_accel_max = 64;
13718 }
13719
13720 if (hash_mode == 9300)
13721 {
13722 kernel_accel_max = 64;
13723 }
13724
13725 while (kernel_accel_max)
13726 {
13727 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13728
13729 // size_pws
13730
13731 size_pws = kernel_power_max * sizeof (pw_t);
13732
13733 // size_tmps
13734
13735 switch (hash_mode)
13736 {
13737 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13738 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13739 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13740 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13741 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13742 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13743 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13744 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13745 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13746 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13747 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13748 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13749 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13751 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13752 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13753 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13754 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13755 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13756 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13757 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13758 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13759 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13760 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13761 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13762 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13763 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13764 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13765 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13766 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13767 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13768 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13769 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13770 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13771 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13772 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13773 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13774 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13776 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13777 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13778 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13779 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13780 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13781 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13782 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13783 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13784 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13785 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13786 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13787 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13788 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13789 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13790 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13791 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13792 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13793 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13794 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13795 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13796 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13797 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13798 };
13799
13800 // size_hooks
13801
13802 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13803 {
13804 // none yet
13805 }
13806
13807 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13808 // if not, decrease amplifier and try again
13809
13810 int skip = 0;
13811
13812 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13813 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13814 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13815
13816 if (( bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + bitmap_size
13820 + bitmap_size
13821 + bitmap_size
13822 + bitmap_size
13823 + bitmap_size
13824 + size_bfs
13825 + size_combs
13826 + size_digests
13827 + size_esalts
13828 + size_hooks
13829 + size_markov_css
13830 + size_plains
13831 + size_pws
13832 + size_results
13833 + size_root_css
13834 + size_rules
13835 + size_rules_c
13836 + size_salts
13837 + size_scryptV
13838 + size_shown
13839 + size_tm
13840 + size_tmps) > device_param->device_global_mem) skip = 1;
13841
13842 if (skip == 1)
13843 {
13844 kernel_accel_max--;
13845
13846 continue;
13847 }
13848
13849 break;
13850 }
13851
13852 if (kernel_accel_max == 0)
13853 {
13854 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13855
13856 return -1;
13857 }
13858
13859 device_param->kernel_accel_min = kernel_accel_min;
13860 device_param->kernel_accel_max = kernel_accel_max;
13861
13862 if (kernel_accel_max < kernel_accel)
13863 {
13864 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13865
13866 device_param->kernel_accel = kernel_accel_max;
13867 }
13868
13869 const u32 kernel_accel = device_param->kernel_accel;
13870
13871 device_param->size_pws = size_pws;
13872 device_param->size_tmps = size_tmps;
13873 device_param->size_hooks = size_hooks;
13874
13875 // do not confuse kernel_accel_max with kernel_accel here
13876
13877 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13878
13879 device_param->kernel_threads = kernel_threads;
13880 device_param->kernel_power_user = kernel_power;
13881
13882 kernel_power_all += kernel_power;
13883
13884 /**
13885 * default building options
13886 */
13887
13888 char build_opts[1024] = { 0 };
13889
13890 // we don't have sm_* on vendors not NV but it doesn't matter
13891
13892 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13893
13894 /**
13895 * main kernel
13896 */
13897
13898 {
13899 /**
13900 * kernel source filename
13901 */
13902
13903 char source_file[256] = { 0 };
13904
13905 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13906
13907 struct stat sst;
13908
13909 if (stat (source_file, &sst) == -1)
13910 {
13911 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13912
13913 return -1;
13914 }
13915
13916 /**
13917 * kernel cached filename
13918 */
13919
13920 char cached_file[256] = { 0 };
13921
13922 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13923
13924 int cached = 1;
13925
13926 struct stat cst;
13927
13928 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13929 {
13930 cached = 0;
13931 }
13932
13933 /**
13934 * kernel compile or load
13935 */
13936
13937 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13938
13939 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13940
13941 if (force_jit_compilation == -1)
13942 {
13943 if (cached == 0)
13944 {
13945 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13946
13947 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13948
13949 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13950
13951 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13952
13953 if (rc != 0)
13954 {
13955 device_param->skipped = true;
13956 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13957 continue;
13958 }
13959
13960 size_t binary_size;
13961
13962 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13963
13964 u8 *binary = (u8 *) mymalloc (binary_size);
13965
13966 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13967
13968 writeProgramBin (cached_file, binary, binary_size);
13969
13970 local_free (binary);
13971 }
13972 else
13973 {
13974 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13975
13976 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13977
13978 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13979
13980 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13981 }
13982 }
13983 else
13984 {
13985 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13986
13987 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13988
13989 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13990
13991 char build_opts_update[1024] = { 0 };
13992
13993 if (force_jit_compilation == 1500)
13994 {
13995 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13996 }
13997 else if (force_jit_compilation == 8900)
13998 {
13999 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);
14000 }
14001
14002 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14003
14004 if (rc != 0)
14005 {
14006 device_param->skipped = true;
14007 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14008 }
14009 }
14010
14011 local_free (kernel_lengths);
14012 local_free (kernel_sources[0]);
14013 local_free (kernel_sources);
14014 }
14015
14016 /**
14017 * word generator kernel
14018 */
14019
14020 if (attack_mode != ATTACK_MODE_STRAIGHT)
14021 {
14022 /**
14023 * kernel mp source filename
14024 */
14025
14026 char source_file[256] = { 0 };
14027
14028 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14029
14030 struct stat sst;
14031
14032 if (stat (source_file, &sst) == -1)
14033 {
14034 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14035
14036 return -1;
14037 }
14038
14039 /**
14040 * kernel mp cached filename
14041 */
14042
14043 char cached_file[256] = { 0 };
14044
14045 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14046
14047 int cached = 1;
14048
14049 struct stat cst;
14050
14051 if (stat (cached_file, &cst) == -1)
14052 {
14053 cached = 0;
14054 }
14055
14056 /**
14057 * kernel compile or load
14058 */
14059
14060 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14061
14062 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14063
14064 if (cached == 0)
14065 {
14066 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14067
14068 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14069
14070 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14071
14072 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14073
14074 if (rc != 0)
14075 {
14076 device_param->skipped = true;
14077 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14078 continue;
14079 }
14080
14081 size_t binary_size;
14082
14083 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14084
14085 u8 *binary = (u8 *) mymalloc (binary_size);
14086
14087 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14088
14089 writeProgramBin (cached_file, binary, binary_size);
14090
14091 local_free (binary);
14092 }
14093 else
14094 {
14095 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14096
14097 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14098
14099 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14100
14101 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14102 }
14103
14104 local_free (kernel_lengths);
14105 local_free (kernel_sources[0]);
14106 local_free (kernel_sources);
14107 }
14108
14109 /**
14110 * amplifier kernel
14111 */
14112
14113 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14114 {
14115
14116 }
14117 else
14118 {
14119 /**
14120 * kernel amp source filename
14121 */
14122
14123 char source_file[256] = { 0 };
14124
14125 generate_source_kernel_amp_filename (attack_kern, 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 amp cached filename
14138 */
14139
14140 char cached_file[256] = { 0 };
14141
14142 generate_cached_kernel_amp_filename (attack_kern, 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_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14168
14169 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 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_amp, 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_amp, 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_amp = 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_amp, 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 // some algorithm collide too fast, make that impossible
14207
14208 if (benchmark == 1)
14209 {
14210 ((uint *) digests_buf)[0] = -1;
14211 ((uint *) digests_buf)[1] = -1;
14212 ((uint *) digests_buf)[2] = -1;
14213 ((uint *) digests_buf)[3] = -1;
14214 }
14215
14216 /**
14217 * global buffers
14218 */
14219
14220 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14221 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14222 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14223 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14224 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14225 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14226 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14227 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14228 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14229 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14230 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14231 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14232 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14233 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14234 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14235 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14236 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14237 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14238
14239 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);
14240 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);
14241 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);
14242 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);
14243 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);
14244 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);
14245 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);
14246 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);
14247 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14248 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14249 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14250
14251 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14252 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14253 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14254 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14255 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14256 run_kernel_bzero (device_param, device_param->d_result, size_results);
14257
14258 /**
14259 * special buffers
14260 */
14261
14262 if (attack_kern == ATTACK_KERN_STRAIGHT)
14263 {
14264 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14265 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14266
14267 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14268
14269 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14270 }
14271 else if (attack_kern == ATTACK_KERN_COMBI)
14272 {
14273 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14274 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14275 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14276 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14277
14278 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14279 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14280 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14281 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14282 }
14283 else if (attack_kern == ATTACK_KERN_BF)
14284 {
14285 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14286 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14287 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14288 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14289 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14290
14291 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14292 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14293 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14294 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14295 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14296 }
14297
14298 if (size_esalts)
14299 {
14300 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14301
14302 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14303 }
14304
14305 /**
14306 * main host data
14307 */
14308
14309 uint *result = (uint *) mymalloc (size_results);
14310
14311 device_param->result = result;
14312
14313 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14314
14315 device_param->pws_buf = pws_buf;
14316
14317 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14318
14319 for (int i = 0; i < 64; i++)
14320 {
14321 pw_caches[i].pw_buf.pw_len = i;
14322 pw_caches[i].cnt = 0;
14323 }
14324
14325 device_param->pw_caches = pw_caches;
14326
14327 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14328
14329 device_param->combs_buf = combs_buf;
14330
14331 void *hooks_buf = mymalloc (size_hooks);
14332
14333 device_param->hooks_buf = hooks_buf;
14334
14335 device_param->pw_transpose = pw_transpose_to_hi1;
14336 device_param->pw_add = pw_add_to_hc1;
14337
14338 /**
14339 * kernel args
14340 */
14341
14342 device_param->kernel_params_buf32[21] = bitmap_mask;
14343 device_param->kernel_params_buf32[22] = bitmap_shift1;
14344 device_param->kernel_params_buf32[23] = bitmap_shift2;
14345 device_param->kernel_params_buf32[24] = 0; // salt_pos
14346 device_param->kernel_params_buf32[25] = 0; // loop_pos
14347 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14348 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14349 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14350 device_param->kernel_params_buf32[29] = 0; // digests_offset
14351 device_param->kernel_params_buf32[30] = 0; // combs_mode
14352 device_param->kernel_params_buf32[31] = 0; // gid_max
14353
14354 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14355 ? &device_param->d_pws_buf
14356 : &device_param->d_pws_amp_buf;
14357 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14358 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14359 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14360 device_param->kernel_params[ 4] = &device_param->d_tmps;
14361 device_param->kernel_params[ 5] = &device_param->d_hooks;
14362 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14363 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14364 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14365 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14366 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14367 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14368 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14369 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14370 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14371 device_param->kernel_params[15] = &device_param->d_digests_buf;
14372 device_param->kernel_params[16] = &device_param->d_digests_shown;
14373 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14374 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14375 device_param->kernel_params[19] = &device_param->d_result;
14376 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14377 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14378 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14379 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14380 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14381 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14382 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14383 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14384 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14385 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14386 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14387 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14388
14389 device_param->kernel_params_mp_buf64[3] = 0;
14390 device_param->kernel_params_mp_buf32[4] = 0;
14391 device_param->kernel_params_mp_buf32[5] = 0;
14392 device_param->kernel_params_mp_buf32[6] = 0;
14393 device_param->kernel_params_mp_buf32[7] = 0;
14394 device_param->kernel_params_mp_buf32[8] = 0;
14395
14396 device_param->kernel_params_mp[0] = NULL;
14397 device_param->kernel_params_mp[1] = NULL;
14398 device_param->kernel_params_mp[2] = NULL;
14399 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14400 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14401 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14402 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14403 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14404 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14405
14406 device_param->kernel_params_mp_l_buf64[3] = 0;
14407 device_param->kernel_params_mp_l_buf32[4] = 0;
14408 device_param->kernel_params_mp_l_buf32[5] = 0;
14409 device_param->kernel_params_mp_l_buf32[6] = 0;
14410 device_param->kernel_params_mp_l_buf32[7] = 0;
14411 device_param->kernel_params_mp_l_buf32[8] = 0;
14412 device_param->kernel_params_mp_l_buf32[9] = 0;
14413
14414 device_param->kernel_params_mp_l[0] = NULL;
14415 device_param->kernel_params_mp_l[1] = NULL;
14416 device_param->kernel_params_mp_l[2] = NULL;
14417 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14418 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14419 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14420 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14421 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14422 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14423 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14424
14425 device_param->kernel_params_mp_r_buf64[3] = 0;
14426 device_param->kernel_params_mp_r_buf32[4] = 0;
14427 device_param->kernel_params_mp_r_buf32[5] = 0;
14428 device_param->kernel_params_mp_r_buf32[6] = 0;
14429 device_param->kernel_params_mp_r_buf32[7] = 0;
14430 device_param->kernel_params_mp_r_buf32[8] = 0;
14431
14432 device_param->kernel_params_mp_r[0] = NULL;
14433 device_param->kernel_params_mp_r[1] = NULL;
14434 device_param->kernel_params_mp_r[2] = NULL;
14435 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14436 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14437 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14438 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14439 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14440 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14441
14442 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14443 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14444
14445 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14446 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14447 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14448 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14449 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14450 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14451 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14452
14453 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14454
14455 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14456 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14457
14458 /**
14459 * kernel name
14460 */
14461
14462 char kernel_name[64] = { 0 };
14463
14464 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14465 {
14466 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14467 {
14468 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14469
14470 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14471
14472 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14473
14474 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14475
14476 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14477
14478 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14479 }
14480 else
14481 {
14482 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14483
14484 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14485
14486 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14487
14488 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14489
14490 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14491
14492 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14493 }
14494
14495 if (data.attack_mode == ATTACK_MODE_BF)
14496 {
14497 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14498 {
14499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14500
14501 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14502
14503 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14504
14505 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14506 }
14507 }
14508 }
14509 else
14510 {
14511 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14512
14513 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14514
14515 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14516
14517 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14518
14519 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14520
14521 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14522
14523 if (opts_type & OPTS_TYPE_HOOK12)
14524 {
14525 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14526
14527 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14528 }
14529
14530 if (opts_type & OPTS_TYPE_HOOK23)
14531 {
14532 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14533
14534 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14535 }
14536 }
14537
14538 for (uint i = 0; i <= 20; i++)
14539 {
14540 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14541 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14542 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14543
14544 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14545 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14546 }
14547
14548 for (uint i = 21; i <= 31; i++)
14549 {
14550 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14551 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14552 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14553
14554 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14555 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14556 }
14557
14558 if (attack_mode == ATTACK_MODE_BF)
14559 {
14560 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14561 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14562
14563 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14564 {
14565 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14566
14567 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14568 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14569 }
14570 }
14571 else if (attack_mode == ATTACK_MODE_HYBRID1)
14572 {
14573 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14574 }
14575 else if (attack_mode == ATTACK_MODE_HYBRID2)
14576 {
14577 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14578 }
14579
14580 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14581 {
14582 // nothing to do
14583 }
14584 else
14585 {
14586 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14587 }
14588
14589 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14590 {
14591 // nothing to do
14592 }
14593 else
14594 {
14595 for (uint i = 0; i < 5; i++)
14596 {
14597 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14598 }
14599
14600 for (uint i = 5; i < 7; i++)
14601 {
14602 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14603 }
14604 }
14605
14606 /**
14607 * Store initial fanspeed if gpu_temp_retain is enabled
14608 */
14609
14610 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14611 int gpu_temp_retain_set = 0;
14612
14613 if (gpu_temp_disable == 0)
14614 {
14615 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14616 {
14617 hc_thread_mutex_lock (mux_adl);
14618
14619 if (data.hm_device[device_id].fan_supported == 1)
14620 {
14621 if (gpu_temp_retain_chgd == 0)
14622 {
14623 uint cur_temp = 0;
14624 uint default_temp = 0;
14625
14626 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);
14627
14628 if (ADL_rc == ADL_OK)
14629 {
14630 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14631
14632 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14633
14634 // special case with multi gpu setups: always use minimum retain
14635
14636 if (gpu_temp_retain_set == 0)
14637 {
14638 gpu_temp_retain = gpu_temp_retain_target;
14639 gpu_temp_retain_set = 1;
14640 }
14641 else
14642 {
14643 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14644 }
14645
14646 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14647 }
14648 }
14649
14650 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14651
14652 temp_retain_fanspeed_value[device_id] = fan_speed;
14653
14654 if (fan_speed == -1)
14655 {
14656 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14657
14658 temp_retain_fanspeed_value[device_id] = 0;
14659 }
14660 }
14661
14662 hc_thread_mutex_unlock (mux_adl);
14663 }
14664 }
14665
14666 /**
14667 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14668 */
14669
14670 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14671 {
14672 hc_thread_mutex_lock (mux_adl);
14673
14674 if (data.hm_device[device_id].od_version == 6)
14675 {
14676 int ADL_rc;
14677
14678 // check powertune capabilities first, if not available then skip device
14679
14680 int powertune_supported = 0;
14681
14682 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14683 {
14684 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14685
14686 return (-1);
14687 }
14688
14689 if (powertune_supported != 0)
14690 {
14691 // powercontrol settings
14692
14693 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14694
14695 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14696 {
14697 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14698 }
14699
14700 if (ADL_rc != ADL_OK)
14701 {
14702 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14703
14704 return (-1);
14705 }
14706
14707 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14708 {
14709 log_error ("ERROR: Failed to set new ADL PowerControl values");
14710
14711 return (-1);
14712 }
14713
14714 // clocks
14715
14716 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14717
14718 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14719
14720 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)
14721 {
14722 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14723
14724 return (-1);
14725 }
14726
14727 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14728
14729 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14730
14731 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14732 {
14733 log_error ("ERROR: Failed to get ADL device capabilities");
14734
14735 return (-1);
14736 }
14737
14738 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14739 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14740
14741 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14742 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14743
14744 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14745 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14746
14747 // warning if profile has too low max values
14748
14749 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14750 {
14751 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14752 }
14753
14754 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14755 {
14756 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14757 }
14758
14759 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14760
14761 performance_state->iNumberOfPerformanceLevels = 2;
14762
14763 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14764 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14765 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14766 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14767
14768 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)
14769 {
14770 log_info ("ERROR: Failed to set ADL performance state");
14771
14772 return (-1);
14773 }
14774
14775 local_free (performance_state);
14776 }
14777 }
14778
14779 hc_thread_mutex_unlock (mux_adl);
14780 }
14781 #endif // HAVE_HWMON && HAVE_ADL
14782 }
14783
14784 data.kernel_power_all = kernel_power_all;
14785
14786 if (data.quiet == 0) log_info ("");
14787
14788 /**
14789 * Inform user which algorithm is checked and at which workload setting
14790 */
14791
14792 if (benchmark == 1)
14793 {
14794 quiet = 0;
14795
14796 data.quiet = quiet;
14797
14798 char *hash_type = strhashtype (data.hash_mode); // not a bug
14799
14800 log_info ("Hashtype: %s", hash_type);
14801 log_info ("");
14802 }
14803
14804 /**
14805 * keep track of the progress
14806 */
14807
14808 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14809 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14810 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14811
14812 /**
14813 * open filehandles
14814 */
14815
14816 #if _WIN
14817 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14818 {
14819 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14820
14821 return (-1);
14822 }
14823
14824 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14825 {
14826 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14827
14828 return (-1);
14829 }
14830
14831 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14832 {
14833 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14834
14835 return (-1);
14836 }
14837 #endif
14838
14839 /**
14840 * dictionary pad
14841 */
14842
14843 segment_size *= (1024 * 1024);
14844
14845 data.segment_size = segment_size;
14846
14847 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14848
14849 wl_data->buf = (char *) mymalloc (segment_size);
14850 wl_data->avail = segment_size;
14851 wl_data->incr = segment_size;
14852 wl_data->cnt = 0;
14853 wl_data->pos = 0;
14854
14855 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14856
14857 data.wordlist_mode = wordlist_mode;
14858
14859 cs_t *css_buf = NULL;
14860 uint css_cnt = 0;
14861 uint dictcnt = 0;
14862 uint maskcnt = 1;
14863 char **masks = NULL;
14864 char **dictfiles = NULL;
14865
14866 uint mask_from_file = 0;
14867
14868 if (attack_mode == ATTACK_MODE_STRAIGHT)
14869 {
14870 if (wordlist_mode == WL_MODE_FILE)
14871 {
14872 int wls_left = myargc - (optind + 1);
14873
14874 for (int i = 0; i < wls_left; i++)
14875 {
14876 char *l0_filename = myargv[optind + 1 + i];
14877
14878 struct stat l0_stat;
14879
14880 if (stat (l0_filename, &l0_stat) == -1)
14881 {
14882 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14883
14884 return (-1);
14885 }
14886
14887 uint is_dir = S_ISDIR (l0_stat.st_mode);
14888
14889 if (is_dir == 0)
14890 {
14891 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14892
14893 dictcnt++;
14894
14895 dictfiles[dictcnt - 1] = l0_filename;
14896 }
14897 else
14898 {
14899 // do not allow --keyspace w/ a directory
14900
14901 if (keyspace == 1)
14902 {
14903 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14904
14905 return (-1);
14906 }
14907
14908 char **dictionary_files = NULL;
14909
14910 dictionary_files = scan_directory (l0_filename);
14911
14912 if (dictionary_files != NULL)
14913 {
14914 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14915
14916 for (int d = 0; dictionary_files[d] != NULL; d++)
14917 {
14918 char *l1_filename = dictionary_files[d];
14919
14920 struct stat l1_stat;
14921
14922 if (stat (l1_filename, &l1_stat) == -1)
14923 {
14924 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14925
14926 return (-1);
14927 }
14928
14929 if (S_ISREG (l1_stat.st_mode))
14930 {
14931 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14932
14933 dictcnt++;
14934
14935 dictfiles[dictcnt - 1] = strdup (l1_filename);
14936 }
14937 }
14938 }
14939
14940 local_free (dictionary_files);
14941 }
14942 }
14943
14944 if (dictcnt < 1)
14945 {
14946 log_error ("ERROR: No usable dictionary file found.");
14947
14948 return (-1);
14949 }
14950 }
14951 else if (wordlist_mode == WL_MODE_STDIN)
14952 {
14953 dictcnt = 1;
14954 }
14955 }
14956 else if (attack_mode == ATTACK_MODE_COMBI)
14957 {
14958 // display
14959
14960 char *dictfile1 = myargv[optind + 1 + 0];
14961 char *dictfile2 = myargv[optind + 1 + 1];
14962
14963 // find the bigger dictionary and use as base
14964
14965 FILE *fp1 = NULL;
14966 FILE *fp2 = NULL;
14967
14968 struct stat tmp_stat;
14969
14970 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14971 {
14972 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14973
14974 return (-1);
14975 }
14976
14977 if (stat (dictfile1, &tmp_stat) == -1)
14978 {
14979 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14980
14981 fclose (fp1);
14982
14983 return (-1);
14984 }
14985
14986 if (S_ISDIR (tmp_stat.st_mode))
14987 {
14988 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14989
14990 fclose (fp1);
14991
14992 return (-1);
14993 }
14994
14995 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14996 {
14997 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14998
14999 fclose (fp1);
15000
15001 return (-1);
15002 }
15003
15004 if (stat (dictfile2, &tmp_stat) == -1)
15005 {
15006 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15007
15008 fclose (fp1);
15009 fclose (fp2);
15010
15011 return (-1);
15012 }
15013
15014 if (S_ISDIR (tmp_stat.st_mode))
15015 {
15016 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15017
15018 fclose (fp1);
15019 fclose (fp2);
15020
15021 return (-1);
15022 }
15023
15024 data.combs_cnt = 1;
15025
15026 data.quiet = 1;
15027
15028 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15029
15030 data.quiet = quiet;
15031
15032 if (words1_cnt == 0)
15033 {
15034 log_error ("ERROR: %s: empty file", dictfile1);
15035
15036 fclose (fp1);
15037 fclose (fp2);
15038
15039 return (-1);
15040 }
15041
15042 data.combs_cnt = 1;
15043
15044 data.quiet = 1;
15045
15046 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15047
15048 data.quiet = quiet;
15049
15050 if (words2_cnt == 0)
15051 {
15052 log_error ("ERROR: %s: empty file", dictfile2);
15053
15054 fclose (fp1);
15055 fclose (fp2);
15056
15057 return (-1);
15058 }
15059
15060 fclose (fp1);
15061 fclose (fp2);
15062
15063 data.dictfile = dictfile1;
15064 data.dictfile2 = dictfile2;
15065
15066 if (words1_cnt >= words2_cnt)
15067 {
15068 data.combs_cnt = words2_cnt;
15069 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15070
15071 dictfiles = &data.dictfile;
15072
15073 dictcnt = 1;
15074 }
15075 else
15076 {
15077 data.combs_cnt = words1_cnt;
15078 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15079
15080 dictfiles = &data.dictfile2;
15081
15082 dictcnt = 1;
15083
15084 // we also have to switch wordlist related rules!
15085
15086 char *tmpc = data.rule_buf_l;
15087
15088 data.rule_buf_l = data.rule_buf_r;
15089 data.rule_buf_r = tmpc;
15090
15091 int tmpi = data.rule_len_l;
15092
15093 data.rule_len_l = data.rule_len_r;
15094 data.rule_len_r = tmpi;
15095 }
15096 }
15097 else if (attack_mode == ATTACK_MODE_BF)
15098 {
15099 char *mask = NULL;
15100
15101 maskcnt = 0;
15102
15103 if (benchmark == 0)
15104 {
15105 mask = myargv[optind + 1];
15106
15107 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15108
15109 if ((optind + 2) <= myargc)
15110 {
15111 struct stat file_stat;
15112
15113 if (stat (mask, &file_stat) == -1)
15114 {
15115 maskcnt = 1;
15116
15117 masks[maskcnt - 1] = mystrdup (mask);
15118 }
15119 else
15120 {
15121 int wls_left = myargc - (optind + 1);
15122
15123 uint masks_avail = INCR_MASKS;
15124
15125 for (int i = 0; i < wls_left; i++)
15126 {
15127 if (i != 0)
15128 {
15129 mask = myargv[optind + 1 + i];
15130
15131 if (stat (mask, &file_stat) == -1)
15132 {
15133 log_error ("ERROR: %s: %s", mask, strerror (errno));
15134
15135 return (-1);
15136 }
15137 }
15138
15139 uint is_file = S_ISREG (file_stat.st_mode);
15140
15141 if (is_file == 1)
15142 {
15143 FILE *mask_fp;
15144
15145 if ((mask_fp = fopen (mask, "r")) == NULL)
15146 {
15147 log_error ("ERROR: %s: %s", mask, strerror (errno));
15148
15149 return (-1);
15150 }
15151
15152 char line_buf[BUFSIZ] = { 0 };
15153
15154 while (!feof (mask_fp))
15155 {
15156 memset (line_buf, 0, BUFSIZ);
15157
15158 int line_len = fgetl (mask_fp, line_buf);
15159
15160 if (line_len == 0) continue;
15161
15162 if (line_buf[0] == '#') continue;
15163
15164 if (masks_avail == maskcnt)
15165 {
15166 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15167
15168 masks_avail += INCR_MASKS;
15169 }
15170
15171 masks[maskcnt] = mystrdup (line_buf);
15172
15173 maskcnt++;
15174 }
15175
15176 fclose (mask_fp);
15177 }
15178 else
15179 {
15180 log_error ("ERROR: %s: unsupported file-type", mask);
15181
15182 return (-1);
15183 }
15184 }
15185
15186 mask_from_file = 1;
15187 }
15188 }
15189 else
15190 {
15191 custom_charset_1 = (char *) "?l?d?u";
15192 custom_charset_2 = (char *) "?l?d";
15193 custom_charset_3 = (char *) "?l?d*!$@_";
15194
15195 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15196 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15197 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15198
15199 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15200
15201 wordlist_mode = WL_MODE_MASK;
15202
15203 data.wordlist_mode = wordlist_mode;
15204
15205 increment = 1;
15206
15207 maskcnt = 1;
15208 }
15209 }
15210 else
15211 {
15212 /**
15213 * generate full masks and charsets
15214 */
15215
15216 masks = (char **) mymalloc (sizeof (char *));
15217
15218 switch (hash_mode)
15219 {
15220 case 1731: pw_min = 5;
15221 pw_max = 5;
15222 mask = mystrdup ("?b?b?b?b?b");
15223 break;
15224 case 12500: pw_min = 5;
15225 pw_max = 5;
15226 mask = mystrdup ("?b?b?b?b?b");
15227 break;
15228 default: pw_min = 7;
15229 pw_max = 7;
15230 mask = mystrdup ("?b?b?b?b?b?b?b");
15231 break;
15232 }
15233
15234 maskcnt = 1;
15235
15236 masks[maskcnt - 1] = mystrdup (mask);
15237
15238 wordlist_mode = WL_MODE_MASK;
15239
15240 data.wordlist_mode = wordlist_mode;
15241
15242 increment = 1;
15243 }
15244
15245 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15246
15247 if (increment)
15248 {
15249 if (increment_min > pw_min) pw_min = increment_min;
15250
15251 if (increment_max < pw_max) pw_max = increment_max;
15252 }
15253 }
15254 else if (attack_mode == ATTACK_MODE_HYBRID1)
15255 {
15256 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15257
15258 // display
15259
15260 char *mask = myargv[myargc - 1];
15261
15262 maskcnt = 0;
15263
15264 masks = (char **) mymalloc (1 * sizeof (char *));
15265
15266 // mod
15267
15268 struct stat file_stat;
15269
15270 if (stat (mask, &file_stat) == -1)
15271 {
15272 maskcnt = 1;
15273
15274 masks[maskcnt - 1] = mystrdup (mask);
15275 }
15276 else
15277 {
15278 uint is_file = S_ISREG (file_stat.st_mode);
15279
15280 if (is_file == 1)
15281 {
15282 FILE *mask_fp;
15283
15284 if ((mask_fp = fopen (mask, "r")) == NULL)
15285 {
15286 log_error ("ERROR: %s: %s", mask, strerror (errno));
15287
15288 return (-1);
15289 }
15290
15291 char line_buf[BUFSIZ] = { 0 };
15292
15293 uint masks_avail = 1;
15294
15295 while (!feof (mask_fp))
15296 {
15297 memset (line_buf, 0, BUFSIZ);
15298
15299 int line_len = fgetl (mask_fp, line_buf);
15300
15301 if (line_len == 0) continue;
15302
15303 if (line_buf[0] == '#') continue;
15304
15305 if (masks_avail == maskcnt)
15306 {
15307 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15308
15309 masks_avail += INCR_MASKS;
15310 }
15311
15312 masks[maskcnt] = mystrdup (line_buf);
15313
15314 maskcnt++;
15315 }
15316
15317 fclose (mask_fp);
15318
15319 mask_from_file = 1;
15320 }
15321 else
15322 {
15323 maskcnt = 1;
15324
15325 masks[maskcnt - 1] = mystrdup (mask);
15326 }
15327 }
15328
15329 // base
15330
15331 int wls_left = myargc - (optind + 2);
15332
15333 for (int i = 0; i < wls_left; i++)
15334 {
15335 char *filename = myargv[optind + 1 + i];
15336
15337 struct stat file_stat;
15338
15339 if (stat (filename, &file_stat) == -1)
15340 {
15341 log_error ("ERROR: %s: %s", filename, strerror (errno));
15342
15343 return (-1);
15344 }
15345
15346 uint is_dir = S_ISDIR (file_stat.st_mode);
15347
15348 if (is_dir == 0)
15349 {
15350 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15351
15352 dictcnt++;
15353
15354 dictfiles[dictcnt - 1] = filename;
15355 }
15356 else
15357 {
15358 // do not allow --keyspace w/ a directory
15359
15360 if (keyspace == 1)
15361 {
15362 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15363
15364 return (-1);
15365 }
15366
15367 char **dictionary_files = NULL;
15368
15369 dictionary_files = scan_directory (filename);
15370
15371 if (dictionary_files != NULL)
15372 {
15373 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15374
15375 for (int d = 0; dictionary_files[d] != NULL; d++)
15376 {
15377 char *l1_filename = dictionary_files[d];
15378
15379 struct stat l1_stat;
15380
15381 if (stat (l1_filename, &l1_stat) == -1)
15382 {
15383 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15384
15385 return (-1);
15386 }
15387
15388 if (S_ISREG (l1_stat.st_mode))
15389 {
15390 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15391
15392 dictcnt++;
15393
15394 dictfiles[dictcnt - 1] = strdup (l1_filename);
15395 }
15396 }
15397 }
15398
15399 local_free (dictionary_files);
15400 }
15401 }
15402
15403 if (dictcnt < 1)
15404 {
15405 log_error ("ERROR: No usable dictionary file found.");
15406
15407 return (-1);
15408 }
15409
15410 if (increment)
15411 {
15412 maskcnt = 0;
15413
15414 uint mask_min = increment_min; // we can't reject smaller masks here
15415 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15416
15417 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15418 {
15419 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15420
15421 if (cur_mask == NULL) break;
15422
15423 masks[maskcnt] = cur_mask;
15424
15425 maskcnt++;
15426
15427 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15428 }
15429 }
15430 }
15431 else if (attack_mode == ATTACK_MODE_HYBRID2)
15432 {
15433 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15434
15435 // display
15436
15437 char *mask = myargv[optind + 1 + 0];
15438
15439 maskcnt = 0;
15440
15441 masks = (char **) mymalloc (1 * sizeof (char *));
15442
15443 // mod
15444
15445 struct stat file_stat;
15446
15447 if (stat (mask, &file_stat) == -1)
15448 {
15449 maskcnt = 1;
15450
15451 masks[maskcnt - 1] = mystrdup (mask);
15452 }
15453 else
15454 {
15455 uint is_file = S_ISREG (file_stat.st_mode);
15456
15457 if (is_file == 1)
15458 {
15459 FILE *mask_fp;
15460
15461 if ((mask_fp = fopen (mask, "r")) == NULL)
15462 {
15463 log_error ("ERROR: %s: %s", mask, strerror (errno));
15464
15465 return (-1);
15466 }
15467
15468 char line_buf[BUFSIZ] = { 0 };
15469
15470 uint masks_avail = 1;
15471
15472 while (!feof (mask_fp))
15473 {
15474 memset (line_buf, 0, BUFSIZ);
15475
15476 int line_len = fgetl (mask_fp, line_buf);
15477
15478 if (line_len == 0) continue;
15479
15480 if (line_buf[0] == '#') continue;
15481
15482 if (masks_avail == maskcnt)
15483 {
15484 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15485
15486 masks_avail += INCR_MASKS;
15487 }
15488
15489 masks[maskcnt] = mystrdup (line_buf);
15490
15491 maskcnt++;
15492 }
15493
15494 fclose (mask_fp);
15495
15496 mask_from_file = 1;
15497 }
15498 else
15499 {
15500 maskcnt = 1;
15501
15502 masks[maskcnt - 1] = mystrdup (mask);
15503 }
15504 }
15505
15506 // base
15507
15508 int wls_left = myargc - (optind + 2);
15509
15510 for (int i = 0; i < wls_left; i++)
15511 {
15512 char *filename = myargv[optind + 2 + i];
15513
15514 struct stat file_stat;
15515
15516 if (stat (filename, &file_stat) == -1)
15517 {
15518 log_error ("ERROR: %s: %s", filename, strerror (errno));
15519
15520 return (-1);
15521 }
15522
15523 uint is_dir = S_ISDIR (file_stat.st_mode);
15524
15525 if (is_dir == 0)
15526 {
15527 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15528
15529 dictcnt++;
15530
15531 dictfiles[dictcnt - 1] = filename;
15532 }
15533 else
15534 {
15535 // do not allow --keyspace w/ a directory
15536
15537 if (keyspace == 1)
15538 {
15539 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15540
15541 return (-1);
15542 }
15543
15544 char **dictionary_files = NULL;
15545
15546 dictionary_files = scan_directory (filename);
15547
15548 if (dictionary_files != NULL)
15549 {
15550 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15551
15552 for (int d = 0; dictionary_files[d] != NULL; d++)
15553 {
15554 char *l1_filename = dictionary_files[d];
15555
15556 struct stat l1_stat;
15557
15558 if (stat (l1_filename, &l1_stat) == -1)
15559 {
15560 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15561
15562 return (-1);
15563 }
15564
15565 if (S_ISREG (l1_stat.st_mode))
15566 {
15567 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15568
15569 dictcnt++;
15570
15571 dictfiles[dictcnt - 1] = strdup (l1_filename);
15572 }
15573 }
15574 }
15575
15576 local_free (dictionary_files);
15577 }
15578 }
15579
15580 if (dictcnt < 1)
15581 {
15582 log_error ("ERROR: No usable dictionary file found.");
15583
15584 return (-1);
15585 }
15586
15587 if (increment)
15588 {
15589 maskcnt = 0;
15590
15591 uint mask_min = increment_min; // we can't reject smaller masks here
15592 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15593
15594 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15595 {
15596 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15597
15598 if (cur_mask == NULL) break;
15599
15600 masks[maskcnt] = cur_mask;
15601
15602 maskcnt++;
15603
15604 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15605 }
15606 }
15607 }
15608
15609 data.pw_min = pw_min;
15610 data.pw_max = pw_max;
15611
15612 /**
15613 * weak hash check
15614 */
15615
15616 if (weak_hash_threshold >= salts_cnt)
15617 {
15618 hc_device_param_t *device_param = NULL;
15619
15620 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15621 {
15622 device_param = &data.devices_param[device_id];
15623
15624 if (device_param->skipped) continue;
15625
15626 break;
15627 }
15628
15629 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15630
15631 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15632 {
15633 weak_hash_check (device_param, salt_pos);
15634 }
15635 }
15636
15637 // Display hack, guarantee that there is at least one \r before real start
15638
15639 if (data.quiet == 0) log_info_nn ("");
15640
15641 /**
15642 * status and monitor threads
15643 */
15644
15645 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15646
15647 hc_thread_t i_thread = 0;
15648
15649 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15650 {
15651 hc_thread_create (i_thread, thread_keypress, &benchmark);
15652 }
15653
15654 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15655
15656 uint ni_threads_cnt = 0;
15657
15658 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15659
15660 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15661
15662 ni_threads_cnt++;
15663
15664 /**
15665 * Outfile remove
15666 */
15667
15668 if (keyspace == 0)
15669 {
15670 if (outfile_check_timer != 0)
15671 {
15672 if (data.outfile_check_directory != NULL)
15673 {
15674 if ((hash_mode != 5200) &&
15675 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15676 (hash_mode != 9000))
15677 {
15678 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15679
15680 ni_threads_cnt++;
15681 }
15682 else
15683 {
15684 outfile_check_timer = 0;
15685 }
15686 }
15687 else
15688 {
15689 outfile_check_timer = 0;
15690 }
15691 }
15692 }
15693
15694 /**
15695 * Inform the user if we got some hashes remove because of the pot file remove feature
15696 */
15697
15698 if (data.quiet == 0)
15699 {
15700 if (potfile_remove_cracks > 0)
15701 {
15702 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15703 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15704 }
15705 }
15706
15707 data.outfile_check_timer = outfile_check_timer;
15708
15709 /**
15710 * main loop
15711 */
15712
15713 char **induction_dictionaries = NULL;
15714
15715 int induction_dictionaries_cnt = 0;
15716
15717 hcstat_table_t *root_table_buf = NULL;
15718 hcstat_table_t *markov_table_buf = NULL;
15719
15720 uint initial_restore_done = 0;
15721
15722 data.maskcnt = maskcnt;
15723
15724 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15725 {
15726 if (data.devices_status == STATUS_CRACKED) break;
15727
15728 data.devices_status = STATUS_INIT;
15729
15730 if (maskpos > rd->maskpos)
15731 {
15732 rd->dictpos = 0;
15733 }
15734
15735 rd->maskpos = maskpos;
15736 data.maskpos = maskpos;
15737
15738 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15739 {
15740 char *mask = masks[maskpos];
15741
15742 if (mask_from_file == 1)
15743 {
15744 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15745
15746 char *str_ptr;
15747 uint str_pos;
15748
15749 uint mask_offset = 0;
15750
15751 uint separator_cnt;
15752
15753 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15754 {
15755 str_ptr = strstr (mask + mask_offset, ",");
15756
15757 if (str_ptr == NULL) break;
15758
15759 str_pos = str_ptr - mask;
15760
15761 // escaped separator, i.e. "\,"
15762
15763 if (str_pos > 0)
15764 {
15765 if (mask[str_pos - 1] == '\\')
15766 {
15767 separator_cnt --;
15768
15769 mask_offset = str_pos + 1;
15770
15771 continue;
15772 }
15773 }
15774
15775 // reset the offset
15776
15777 mask_offset = 0;
15778
15779 mask[str_pos] = '\0';
15780
15781 switch (separator_cnt)
15782 {
15783 case 0:
15784 mp_reset_usr (mp_usr, 0);
15785
15786 custom_charset_1 = mask;
15787 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15788 break;
15789
15790 case 1:
15791 mp_reset_usr (mp_usr, 1);
15792
15793 custom_charset_2 = mask;
15794 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15795 break;
15796
15797 case 2:
15798 mp_reset_usr (mp_usr, 2);
15799
15800 custom_charset_3 = mask;
15801 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15802 break;
15803
15804 case 3:
15805 mp_reset_usr (mp_usr, 3);
15806
15807 custom_charset_4 = mask;
15808 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15809 break;
15810 }
15811
15812 mask = mask + str_pos + 1;
15813 }
15814 }
15815
15816 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15817 {
15818 if (maskpos > 0)
15819 {
15820 local_free (css_buf);
15821 local_free (data.root_css_buf);
15822 local_free (data.markov_css_buf);
15823
15824 local_free (masks[maskpos - 1]);
15825 }
15826
15827 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15828
15829 data.mask = mask;
15830 data.css_cnt = css_cnt;
15831 data.css_buf = css_buf;
15832
15833 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15834
15835 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15836
15837 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15838 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15839
15840 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15841
15842 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15843
15844 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15845 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15846
15847 data.root_css_buf = root_css_buf;
15848 data.markov_css_buf = markov_css_buf;
15849
15850 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15851
15852 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15853
15854 local_free (root_table_buf);
15855 local_free (markov_table_buf);
15856
15857 // args
15858
15859 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15860 {
15861 hc_device_param_t *device_param = &data.devices_param[device_id];
15862
15863 if (device_param->skipped) continue;
15864
15865 device_param->kernel_params_mp[0] = &device_param->d_combs;
15866 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15867 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15868
15869 device_param->kernel_params_mp_buf64[3] = 0;
15870 device_param->kernel_params_mp_buf32[4] = css_cnt;
15871 device_param->kernel_params_mp_buf32[5] = 0;
15872 device_param->kernel_params_mp_buf32[6] = 0;
15873 device_param->kernel_params_mp_buf32[7] = 0;
15874
15875 if (attack_mode == ATTACK_MODE_HYBRID1)
15876 {
15877 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15878 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15879 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15880 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15881 }
15882 else if (attack_mode == ATTACK_MODE_HYBRID2)
15883 {
15884 device_param->kernel_params_mp_buf32[5] = 0;
15885 device_param->kernel_params_mp_buf32[6] = 0;
15886 device_param->kernel_params_mp_buf32[7] = 0;
15887 }
15888
15889 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]);
15890 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]);
15891 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]);
15892
15893 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);
15894 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);
15895 }
15896 }
15897 else if (attack_mode == ATTACK_MODE_BF)
15898 {
15899 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15900
15901 if (increment)
15902 {
15903 for (uint i = 0; i < dictcnt; i++)
15904 {
15905 local_free (dictfiles[i]);
15906 }
15907
15908 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15909 {
15910 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15911
15912 if (l1_filename == NULL) break;
15913
15914 dictcnt++;
15915
15916 dictfiles[dictcnt - 1] = l1_filename;
15917 }
15918 }
15919 else
15920 {
15921 dictcnt++;
15922
15923 dictfiles[dictcnt - 1] = mask;
15924 }
15925
15926 if (dictcnt == 0)
15927 {
15928 log_error ("ERROR: Mask is too small");
15929
15930 return (-1);
15931 }
15932 }
15933 }
15934
15935 free (induction_dictionaries);
15936
15937 // induction_dictionaries_cnt = 0; // implied
15938
15939 if (attack_mode != ATTACK_MODE_BF)
15940 {
15941 if (keyspace == 0)
15942 {
15943 induction_dictionaries = scan_directory (induction_directory);
15944
15945 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15946 }
15947 }
15948
15949 if (induction_dictionaries_cnt)
15950 {
15951 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15952 }
15953
15954 /**
15955 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15956 */
15957 if (keyspace == 1)
15958 {
15959 if ((maskcnt > 1) || (dictcnt > 1))
15960 {
15961 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15962
15963 return (-1);
15964 }
15965 }
15966
15967 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15968 {
15969 char *subid = logfile_generate_subid ();
15970
15971 data.subid = subid;
15972
15973 logfile_sub_msg ("START");
15974
15975 data.devices_status = STATUS_INIT;
15976
15977 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15978 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15979 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15980
15981 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15982
15983 data.cpt_pos = 0;
15984
15985 data.cpt_start = time (NULL);
15986
15987 data.cpt_total = 0;
15988
15989 if (data.restore == 0)
15990 {
15991 rd->words_cur = skip;
15992
15993 skip = 0;
15994
15995 data.skip = 0;
15996 }
15997
15998 data.ms_paused = 0;
15999
16000 data.words_cur = rd->words_cur;
16001
16002 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16003 {
16004 hc_device_param_t *device_param = &data.devices_param[device_id];
16005
16006 if (device_param->skipped) continue;
16007
16008 device_param->speed_pos = 0;
16009
16010 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16011 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16012 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16013
16014 device_param->exec_pos = 0;
16015
16016 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16017
16018 device_param->kernel_power = device_param->kernel_power_user;
16019
16020 device_param->outerloop_pos = 0;
16021 device_param->outerloop_left = 0;
16022 device_param->innerloop_pos = 0;
16023 device_param->innerloop_left = 0;
16024
16025 // some more resets:
16026
16027 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16028
16029 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16030
16031 device_param->pw_cnt = 0;
16032 device_param->pws_cnt = 0;
16033
16034 device_param->words_off = 0;
16035 device_param->words_done = 0;
16036 }
16037
16038 data.kernel_power_div = 0;
16039
16040 // figure out some workload
16041
16042 if (attack_mode == ATTACK_MODE_STRAIGHT)
16043 {
16044 if (data.wordlist_mode == WL_MODE_FILE)
16045 {
16046 char *dictfile = NULL;
16047
16048 if (induction_dictionaries_cnt)
16049 {
16050 dictfile = induction_dictionaries[0];
16051 }
16052 else
16053 {
16054 dictfile = dictfiles[dictpos];
16055 }
16056
16057 data.dictfile = dictfile;
16058
16059 logfile_sub_string (dictfile);
16060
16061 for (uint i = 0; i < rp_files_cnt; i++)
16062 {
16063 logfile_sub_var_string ("rulefile", rp_files[i]);
16064 }
16065
16066 FILE *fd2 = fopen (dictfile, "rb");
16067
16068 if (fd2 == NULL)
16069 {
16070 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16071
16072 return (-1);
16073 }
16074
16075 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16076
16077 fclose (fd2);
16078
16079 if (data.words_cnt == 0)
16080 {
16081 if (data.devices_status == STATUS_CRACKED) break;
16082 if (data.devices_status == STATUS_ABORTED) break;
16083
16084 dictpos++;
16085
16086 continue;
16087 }
16088 }
16089 }
16090 else if (attack_mode == ATTACK_MODE_COMBI)
16091 {
16092 char *dictfile = data.dictfile;
16093 char *dictfile2 = data.dictfile2;
16094
16095 logfile_sub_string (dictfile);
16096 logfile_sub_string (dictfile2);
16097
16098 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16099 {
16100 FILE *fd2 = fopen (dictfile, "rb");
16101
16102 if (fd2 == NULL)
16103 {
16104 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16105
16106 return (-1);
16107 }
16108
16109 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16110
16111 fclose (fd2);
16112 }
16113 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16114 {
16115 FILE *fd2 = fopen (dictfile2, "rb");
16116
16117 if (fd2 == NULL)
16118 {
16119 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16120
16121 return (-1);
16122 }
16123
16124 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16125
16126 fclose (fd2);
16127 }
16128
16129 if (data.words_cnt == 0)
16130 {
16131 if (data.devices_status == STATUS_CRACKED) break;
16132 if (data.devices_status == STATUS_ABORTED) break;
16133
16134 dictpos++;
16135
16136 continue;
16137 }
16138 }
16139 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16140 {
16141 char *dictfile = NULL;
16142
16143 if (induction_dictionaries_cnt)
16144 {
16145 dictfile = induction_dictionaries[0];
16146 }
16147 else
16148 {
16149 dictfile = dictfiles[dictpos];
16150 }
16151
16152 data.dictfile = dictfile;
16153
16154 char *mask = data.mask;
16155
16156 logfile_sub_string (dictfile);
16157 logfile_sub_string (mask);
16158
16159 FILE *fd2 = fopen (dictfile, "rb");
16160
16161 if (fd2 == NULL)
16162 {
16163 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16164
16165 return (-1);
16166 }
16167
16168 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16169
16170 fclose (fd2);
16171
16172 if (data.words_cnt == 0)
16173 {
16174 if (data.devices_status == STATUS_CRACKED) break;
16175 if (data.devices_status == STATUS_ABORTED) break;
16176
16177 dictpos++;
16178
16179 continue;
16180 }
16181 }
16182 else if (attack_mode == ATTACK_MODE_BF)
16183 {
16184 local_free (css_buf);
16185 local_free (data.root_css_buf);
16186 local_free (data.markov_css_buf);
16187
16188 char *mask = dictfiles[dictpos];
16189
16190 logfile_sub_string (mask);
16191
16192 // base
16193
16194 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16195
16196 if (opts_type & OPTS_TYPE_PT_UNICODE)
16197 {
16198 uint css_cnt_unicode = css_cnt * 2;
16199
16200 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16201
16202 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16203 {
16204 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16205
16206 css_buf_unicode[j + 1].cs_buf[0] = 0;
16207 css_buf_unicode[j + 1].cs_len = 1;
16208 }
16209
16210 free (css_buf);
16211
16212 css_buf = css_buf_unicode;
16213 css_cnt = css_cnt_unicode;
16214 }
16215
16216 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16217
16218 uint mask_min = pw_min;
16219 uint mask_max = pw_max;
16220
16221 if (opts_type & OPTS_TYPE_PT_UNICODE)
16222 {
16223 mask_min *= 2;
16224 mask_max *= 2;
16225 }
16226
16227 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16228 {
16229 if (css_cnt < mask_min)
16230 {
16231 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16232 }
16233
16234 if (css_cnt > mask_max)
16235 {
16236 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16237 }
16238
16239 // skip to next mask
16240
16241 dictpos++;
16242
16243 rd->dictpos = dictpos;
16244
16245 logfile_sub_msg ("STOP");
16246
16247 continue;
16248 }
16249
16250 uint save_css_cnt = css_cnt;
16251
16252 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16253 {
16254 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16255 {
16256 uint salt_len = (uint) data.salts_buf[0].salt_len;
16257 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16258
16259 uint css_cnt_salt = css_cnt + salt_len;
16260
16261 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16262
16263 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16264
16265 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16266 {
16267 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16268 css_buf_salt[j].cs_len = 1;
16269 }
16270
16271 free (css_buf);
16272
16273 css_buf = css_buf_salt;
16274 css_cnt = css_cnt_salt;
16275 }
16276 }
16277
16278 data.mask = mask;
16279 data.css_cnt = css_cnt;
16280 data.css_buf = css_buf;
16281
16282 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16283
16284 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16285
16286 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16287
16288 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16289 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16290
16291 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16292
16293 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16294
16295 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16296 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16297
16298 data.root_css_buf = root_css_buf;
16299 data.markov_css_buf = markov_css_buf;
16300
16301 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16302
16303 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16304
16305 local_free (root_table_buf);
16306 local_free (markov_table_buf);
16307
16308 // copy + args
16309
16310 uint css_cnt_l = css_cnt;
16311 uint css_cnt_r;
16312
16313 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16314 {
16315 if (save_css_cnt < 6)
16316 {
16317 css_cnt_r = 1;
16318 }
16319 else if (save_css_cnt == 6)
16320 {
16321 css_cnt_r = 2;
16322 }
16323 else
16324 {
16325 if (opts_type & OPTS_TYPE_PT_UNICODE)
16326 {
16327 if (save_css_cnt == 8 || save_css_cnt == 10)
16328 {
16329 css_cnt_r = 2;
16330 }
16331 else
16332 {
16333 css_cnt_r = 4;
16334 }
16335 }
16336 else
16337 {
16338 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16339 {
16340 css_cnt_r = 3;
16341 }
16342 else
16343 {
16344 css_cnt_r = 4;
16345 }
16346 }
16347 }
16348 }
16349 else
16350 {
16351 css_cnt_r = 1;
16352
16353 /* unfinished code?
16354 int sum = css_buf[css_cnt_r - 1].cs_len;
16355
16356 for (uint i = 1; i < 4 && i < css_cnt; i++)
16357 {
16358 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16359
16360 css_cnt_r++;
16361
16362 sum *= css_buf[css_cnt_r - 1].cs_len;
16363 }
16364 */
16365 }
16366
16367 css_cnt_l -= css_cnt_r;
16368
16369 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16370
16371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16372 {
16373 hc_device_param_t *device_param = &data.devices_param[device_id];
16374
16375 if (device_param->skipped) continue;
16376
16377 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16378 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16379 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16380
16381 device_param->kernel_params_mp_l_buf64[3] = 0;
16382 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16383 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16384 device_param->kernel_params_mp_l_buf32[6] = 0;
16385 device_param->kernel_params_mp_l_buf32[7] = 0;
16386 device_param->kernel_params_mp_l_buf32[8] = 0;
16387
16388 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16389 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16390 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16391 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16392
16393 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16394 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16395 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16396
16397 device_param->kernel_params_mp_r_buf64[3] = 0;
16398 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16399 device_param->kernel_params_mp_r_buf32[5] = 0;
16400 device_param->kernel_params_mp_r_buf32[6] = 0;
16401 device_param->kernel_params_mp_r_buf32[7] = 0;
16402
16403 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]);
16404 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]);
16405 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]);
16406
16407 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]);
16408 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]);
16409 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]);
16410
16411 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);
16412 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);
16413 }
16414 }
16415
16416 u64 words_base = data.words_cnt;
16417
16418 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16419 {
16420 if (data.kernel_rules_cnt)
16421 {
16422 words_base /= data.kernel_rules_cnt;
16423 }
16424 }
16425 else if (data.attack_kern == ATTACK_KERN_COMBI)
16426 {
16427 if (data.combs_cnt)
16428 {
16429 words_base /= data.combs_cnt;
16430 }
16431 }
16432 else if (data.attack_kern == ATTACK_KERN_BF)
16433 {
16434 if (data.bfs_cnt)
16435 {
16436 words_base /= data.bfs_cnt;
16437 }
16438 }
16439
16440 data.words_base = words_base;
16441
16442 if (keyspace == 1)
16443 {
16444 log_info ("%llu", (unsigned long long int) words_base);
16445
16446 return (0);
16447 }
16448
16449 if (data.words_cur > data.words_base)
16450 {
16451 log_error ("ERROR: restore value greater keyspace");
16452
16453 return (-1);
16454 }
16455
16456 if (data.words_cur)
16457 {
16458 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16459 {
16460 for (uint i = 0; i < data.salts_cnt; i++)
16461 {
16462 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16463 }
16464 }
16465 else if (data.attack_kern == ATTACK_KERN_COMBI)
16466 {
16467 for (uint i = 0; i < data.salts_cnt; i++)
16468 {
16469 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16470 }
16471 }
16472 else if (data.attack_kern == ATTACK_KERN_BF)
16473 {
16474 for (uint i = 0; i < data.salts_cnt; i++)
16475 {
16476 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16477 }
16478 }
16479 }
16480
16481 /*
16482 * Inform user about possible slow speeds
16483 */
16484
16485 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16486 {
16487 if (data.words_base < kernel_power_all)
16488 {
16489 if (quiet == 0)
16490 {
16491 log_info ("");
16492 log_info ("ATTENTION!");
16493 log_info (" The wordlist or mask you are using is too small.");
16494 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16495 log_info (" The cracking speed will drop.");
16496 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16497 log_info ("");
16498 }
16499 }
16500 }
16501
16502 /*
16503 * Update loopback file
16504 */
16505
16506 if (loopback == 1)
16507 {
16508 time_t now;
16509
16510 time (&now);
16511
16512 uint random_num = get_random_num (0, 9999);
16513
16514 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16515
16516 data.loopback_file = loopback_file;
16517 }
16518
16519 /*
16520 * Update dictionary statistic
16521 */
16522
16523 if (keyspace == 0)
16524 {
16525 dictstat_fp = fopen (dictstat, "wb");
16526
16527 if (dictstat_fp)
16528 {
16529 lock_file (dictstat_fp);
16530
16531 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16532
16533 fclose (dictstat_fp);
16534 }
16535 }
16536
16537 data.devices_status = STATUS_RUNNING;
16538
16539 if (initial_restore_done == 0)
16540 {
16541 if (data.restore_disable == 0) cycle_restore ();
16542
16543 initial_restore_done = 1;
16544 }
16545
16546 hc_timer_set (&data.timer_running);
16547
16548 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16549 {
16550 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16551 {
16552 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16553 if (quiet == 0) fflush (stdout);
16554 }
16555 }
16556 else if (wordlist_mode == WL_MODE_STDIN)
16557 {
16558 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16559 if (data.quiet == 0) log_info ("");
16560 }
16561
16562 time_t runtime_start;
16563
16564 time (&runtime_start);
16565
16566 data.runtime_start = runtime_start;
16567
16568 /**
16569 * create cracker threads
16570 */
16571
16572 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16573
16574 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16575 {
16576 hc_device_param_t *device_param = &devices_param[device_id];
16577
16578 if (wordlist_mode == WL_MODE_STDIN)
16579 {
16580 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16581 }
16582 else
16583 {
16584 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16585 }
16586 }
16587
16588 // wait for crack threads to exit
16589
16590 hc_thread_wait (data.devices_cnt, c_threads);
16591
16592 local_free (c_threads);
16593
16594 data.restore = 0;
16595
16596 // finalize task
16597
16598 logfile_sub_var_uint ("status-after-work", data.devices_status);
16599
16600 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16601
16602 if (data.devices_status == STATUS_CRACKED) break;
16603 if (data.devices_status == STATUS_ABORTED) break;
16604
16605 if (data.devices_status == STATUS_BYPASS)
16606 {
16607 data.devices_status = STATUS_RUNNING;
16608 }
16609
16610 if (induction_dictionaries_cnt)
16611 {
16612 unlink (induction_dictionaries[0]);
16613 }
16614
16615 free (induction_dictionaries);
16616
16617 if (attack_mode != ATTACK_MODE_BF)
16618 {
16619 induction_dictionaries = scan_directory (induction_directory);
16620
16621 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16622 }
16623
16624 if (benchmark == 0)
16625 {
16626 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16627 {
16628 if (quiet == 0) clear_prompt ();
16629
16630 if (quiet == 0) log_info ("");
16631
16632 if (status == 1)
16633 {
16634 status_display ();
16635 }
16636 else
16637 {
16638 if (quiet == 0) status_display ();
16639 }
16640
16641 if (quiet == 0) log_info ("");
16642 }
16643 }
16644
16645 if (attack_mode == ATTACK_MODE_BF)
16646 {
16647 dictpos++;
16648
16649 rd->dictpos = dictpos;
16650 }
16651 else
16652 {
16653 if (induction_dictionaries_cnt)
16654 {
16655 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16656 }
16657 else
16658 {
16659 dictpos++;
16660
16661 rd->dictpos = dictpos;
16662 }
16663 }
16664
16665 time_t runtime_stop;
16666
16667 time (&runtime_stop);
16668
16669 data.runtime_stop = runtime_stop;
16670
16671 logfile_sub_uint (runtime_start);
16672 logfile_sub_uint (runtime_stop);
16673
16674 logfile_sub_msg ("STOP");
16675
16676 global_free (subid);
16677 }
16678
16679 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16680
16681 if (data.devices_status == STATUS_CRACKED) break;
16682 if (data.devices_status == STATUS_ABORTED) break;
16683 if (data.devices_status == STATUS_QUIT) break;
16684
16685 if (data.devices_status == STATUS_BYPASS)
16686 {
16687 data.devices_status = STATUS_RUNNING;
16688 }
16689 }
16690
16691 // 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
16692
16693 if (attack_mode == ATTACK_MODE_STRAIGHT)
16694 {
16695 if (data.wordlist_mode == WL_MODE_FILE)
16696 {
16697 if (data.dictfile == NULL)
16698 {
16699 if (dictfiles != NULL)
16700 {
16701 data.dictfile = dictfiles[0];
16702
16703 hc_timer_set (&data.timer_running);
16704 }
16705 }
16706 }
16707 }
16708 // NOTE: combi is okay because it is already set beforehand
16709 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16710 {
16711 if (data.dictfile == NULL)
16712 {
16713 if (dictfiles != NULL)
16714 {
16715 hc_timer_set (&data.timer_running);
16716
16717 data.dictfile = dictfiles[0];
16718 }
16719 }
16720 }
16721 else if (attack_mode == ATTACK_MODE_BF)
16722 {
16723 if (data.mask == NULL)
16724 {
16725 hc_timer_set (&data.timer_running);
16726
16727 data.mask = masks[0];
16728 }
16729 }
16730
16731 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16732 {
16733 data.devices_status = STATUS_EXHAUSTED;
16734 }
16735
16736 // if cracked / aborted remove last induction dictionary
16737
16738 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16739 {
16740 struct stat induct_stat;
16741
16742 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16743 {
16744 unlink (induction_dictionaries[file_pos]);
16745 }
16746 }
16747
16748 // wait for non-interactive threads
16749
16750 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16751 {
16752 hc_thread_wait (1, &ni_threads[thread_idx]);
16753 }
16754
16755 local_free (ni_threads);
16756
16757 // wait for interactive threads
16758
16759 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16760 {
16761 hc_thread_wait (1, &i_thread);
16762 }
16763
16764 // we dont need restore file anymore
16765 if (data.restore_disable == 0)
16766 {
16767 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16768 {
16769 unlink (eff_restore_file);
16770 unlink (new_restore_file);
16771 }
16772 else
16773 {
16774 cycle_restore ();
16775 }
16776 }
16777
16778 // finally save left hashes
16779
16780 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16781 {
16782 save_hash ();
16783 }
16784
16785 /**
16786 * Clean up
16787 */
16788
16789 if (benchmark == 1)
16790 {
16791 status_benchmark ();
16792
16793 log_info ("");
16794 }
16795 else
16796 {
16797 if (quiet == 0) clear_prompt ();
16798
16799 if (quiet == 0) log_info ("");
16800
16801 if (status == 1)
16802 {
16803 status_display ();
16804 }
16805 else
16806 {
16807 if (quiet == 0) status_display ();
16808 }
16809
16810 if (quiet == 0) log_info ("");
16811 }
16812
16813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16814 {
16815 hc_device_param_t *device_param = &data.devices_param[device_id];
16816
16817 if (device_param->skipped) continue;
16818
16819 local_free (device_param->result);
16820
16821 local_free (device_param->pw_caches);
16822
16823 local_free (device_param->combs_buf);
16824
16825 local_free (device_param->hooks_buf);
16826
16827 local_free (device_param->device_name);
16828
16829 local_free (device_param->device_name_chksum);
16830
16831 local_free (device_param->device_version);
16832
16833 local_free (device_param->driver_version);
16834
16835 if (device_param->pws_buf) myfree (device_param->pws_buf);
16836 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16837 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16838 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16839 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16840 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16841 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16842 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16843 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16844 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16845 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16846 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16847 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16848 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16849 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16850 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16851 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16852 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16853 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16854 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16855 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16856 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16857 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16858 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16859 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16860 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16861 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16862 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16863 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16864
16865 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16866 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16867 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16868 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16869 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16870 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16871 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16872 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16873 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16874 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16875 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16876
16877 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16878 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16879 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16880
16881 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16882 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16883 }
16884
16885 // reset default fan speed
16886
16887 #ifdef HAVE_HWMON
16888 if (gpu_temp_disable == 0)
16889 {
16890 #ifdef HAVE_ADL
16891 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16892 {
16893 hc_thread_mutex_lock (mux_adl);
16894
16895 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16896 {
16897 hc_device_param_t *device_param = &data.devices_param[device_id];
16898
16899 if (device_param->skipped) continue;
16900
16901 if (data.hm_device[device_id].fan_supported == 1)
16902 {
16903 int fanspeed = temp_retain_fanspeed_value[device_id];
16904
16905 if (fanspeed == -1) continue;
16906
16907 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16908
16909 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16910 }
16911 }
16912
16913 hc_thread_mutex_unlock (mux_adl);
16914 }
16915 #endif // HAVE_ADL
16916 }
16917
16918 #ifdef HAVE_ADL
16919 // reset power tuning
16920
16921 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16922 {
16923 hc_thread_mutex_lock (mux_adl);
16924
16925 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16926 {
16927 hc_device_param_t *device_param = &data.devices_param[device_id];
16928
16929 if (device_param->skipped) continue;
16930
16931 if (data.hm_device[device_id].od_version == 6)
16932 {
16933 // check powertune capabilities first, if not available then skip device
16934
16935 int powertune_supported = 0;
16936
16937 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16938 {
16939 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16940
16941 return (-1);
16942 }
16943
16944 if (powertune_supported != 0)
16945 {
16946 // powercontrol settings
16947
16948 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)
16949 {
16950 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16951
16952 return (-1);
16953 }
16954
16955 // clocks
16956
16957 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16958
16959 performance_state->iNumberOfPerformanceLevels = 2;
16960
16961 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16962 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16963 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16964 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16965
16966 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)
16967 {
16968 log_info ("ERROR: Failed to restore ADL performance state");
16969
16970 return (-1);
16971 }
16972
16973 local_free (performance_state);
16974 }
16975 }
16976 }
16977
16978 hc_thread_mutex_unlock (mux_adl);
16979 }
16980 #endif // HAVE_ADL
16981
16982 if (gpu_temp_disable == 0)
16983 {
16984 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16985 if (data.hm_nv)
16986 {
16987 #if defined(LINUX) && defined(HAVE_NVML)
16988
16989 hm_NVML_nvmlShutdown (data.hm_nv);
16990
16991 nvml_close (data.hm_nv);
16992
16993 #elif defined(WIN) && (HAVE_NVAPI)
16994
16995 hm_NvAPI_Unload (data.hm_nv);
16996
16997 nvapi_close (data.hm_nv);
16998
16999 #endif
17000
17001 data.hm_nv = NULL;
17002 }
17003 #endif
17004
17005 #ifdef HAVE_ADL
17006 if (data.hm_amd)
17007 {
17008 hm_ADL_Main_Control_Destroy (data.hm_amd);
17009
17010 adl_close (data.hm_amd);
17011 data.hm_amd = NULL;
17012 }
17013 #endif
17014 }
17015 #endif // HAVE_HWMON
17016
17017 // free memory
17018
17019 local_free (masks);
17020
17021 local_free (dictstat_base);
17022
17023 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17024 {
17025 pot_t *pot_ptr = &pot[pot_pos];
17026
17027 hash_t *hash = &pot_ptr->hash;
17028
17029 local_free (hash->digest);
17030
17031 if (isSalted)
17032 {
17033 local_free (hash->salt);
17034 }
17035 }
17036
17037 local_free (pot);
17038
17039 local_free (all_kernel_rules_cnt);
17040 local_free (all_kernel_rules_buf);
17041
17042 local_free (wl_data->buf);
17043 local_free (wl_data);
17044
17045 local_free (bitmap_s1_a);
17046 local_free (bitmap_s1_b);
17047 local_free (bitmap_s1_c);
17048 local_free (bitmap_s1_d);
17049 local_free (bitmap_s2_a);
17050 local_free (bitmap_s2_b);
17051 local_free (bitmap_s2_c);
17052 local_free (bitmap_s2_d);
17053
17054 #ifdef HAVE_HWMON
17055 local_free (temp_retain_fanspeed_value);
17056 #ifdef HAVE_ADL
17057 local_free (od_clock_mem_status);
17058 local_free (od_power_control_status);
17059 #endif // ADL
17060 #endif
17061
17062 global_free (devices_param);
17063
17064 global_free (kernel_rules_buf);
17065
17066 global_free (root_css_buf);
17067 global_free (markov_css_buf);
17068
17069 global_free (digests_buf);
17070 global_free (digests_shown);
17071 global_free (digests_shown_tmp);
17072
17073 global_free (salts_buf);
17074 global_free (salts_shown);
17075
17076 global_free (esalts_buf);
17077
17078 global_free (words_progress_done);
17079 global_free (words_progress_rejected);
17080 global_free (words_progress_restored);
17081
17082 if (pot_fp) fclose (pot_fp);
17083
17084 if (data.devices_status == STATUS_QUIT) break;
17085 }
17086
17087 // destroy others mutex
17088
17089 hc_thread_mutex_delete (mux_dispatcher);
17090 hc_thread_mutex_delete (mux_counter);
17091 hc_thread_mutex_delete (mux_display);
17092 hc_thread_mutex_delete (mux_adl);
17093
17094 // free memory
17095
17096 local_free (eff_restore_file);
17097 local_free (new_restore_file);
17098
17099 local_free (rd);
17100
17101 // tuning db
17102
17103 tuning_db_destroy (tuning_db);
17104
17105 // loopback
17106
17107 local_free (loopback_file);
17108
17109 if (loopback == 1) unlink (loopback_file);
17110
17111 // induction directory
17112
17113 if (induction_dir == NULL)
17114 {
17115 if (attack_mode != ATTACK_MODE_BF)
17116 {
17117 if (rmdir (induction_directory) == -1)
17118 {
17119 if (errno == ENOENT)
17120 {
17121 // good, we can ignore
17122 }
17123 else if (errno == ENOTEMPTY)
17124 {
17125 // good, we can ignore
17126 }
17127 else
17128 {
17129 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17130
17131 return (-1);
17132 }
17133 }
17134
17135 local_free (induction_directory);
17136 }
17137 }
17138
17139 // outfile-check directory
17140
17141 if (outfile_check_dir == NULL)
17142 {
17143 if (rmdir (outfile_check_directory) == -1)
17144 {
17145 if (errno == ENOENT)
17146 {
17147 // good, we can ignore
17148 }
17149 else if (errno == ENOTEMPTY)
17150 {
17151 // good, we can ignore
17152 }
17153 else
17154 {
17155 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17156
17157 return (-1);
17158 }
17159 }
17160
17161 local_free (outfile_check_directory);
17162 }
17163
17164 time_t proc_stop;
17165
17166 time (&proc_stop);
17167
17168 logfile_top_uint (proc_start);
17169 logfile_top_uint (proc_stop);
17170
17171 logfile_top_msg ("STOP");
17172
17173 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17174 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17175
17176 if (data.ocl) ocl_close (data.ocl);
17177
17178 if (data.devices_status == STATUS_ABORTED) return 2;
17179 if (data.devices_status == STATUS_QUIT) return 2;
17180 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17181 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17182 if (data.devices_status == STATUS_CRACKED) return 0;
17183
17184 return -1;
17185 }
Hashcat additions to support pwdhash