projects / hashcat.git / blob
? search:


7ca5e12159704c0609ec398d05eee2cd7050ab50
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
22
23 #define INCR_RULES 10000
24 #define INCR_SALTS 100000
25 #define INCR_MASKS 1000
26 #define INCR_POT 1000
27
28 #define USAGE 0
29 #define VERSION 0
30 #define QUIET 0
31 #define MARKOV_THRESHOLD 0
32 #define MARKOV_DISABLE 0
33 #define MARKOV_CLASSIC 0
34 #define BENCHMARK 0
35 #define RESTORE 0
36 #define RESTORE_TIMER 60
37 #define RESTORE_DISABLE 0
38 #define STATUS 0
39 #define STATUS_TIMER 10
40 #define STATUS_AUTOMAT 0
41 #define LOOPBACK 0
42 #define WEAK_HASH_THRESHOLD 100
43 #define SHOW 0
44 #define LEFT 0
45 #define USERNAME 0
46 #define REMOVE 0
47 #define REMOVE_TIMER 60
48 #define SKIP 0
49 #define LIMIT 0
50 #define KEYSPACE 0
51 #define POTFILE_DISABLE 0
52 #define DEBUG_MODE 0
53 #define RP_GEN 0
54 #define RP_GEN_FUNC_MIN 1
55 #define RP_GEN_FUNC_MAX 4
56 #define RP_GEN_SEED 0
57 #define RULE_BUF_L ":"
58 #define RULE_BUF_R ":"
59 #define FORCE 0
60 #define RUNTIME 0
61 #define HEX_CHARSET 0
62 #define HEX_SALT 0
63 #define HEX_WORDLIST 0
64 #define OUTFILE_FORMAT 3
65 #define OUTFILE_AUTOHEX 1
66 #define OUTFILE_CHECK_TIMER 5
67 #define ATTACK_MODE 0
68 #define HASH_MODE 0
69 #define SEGMENT_SIZE 32
70 #define INCREMENT 0
71 #define INCREMENT_MIN 1
72 #define INCREMENT_MAX PW_MAX
73 #define SEPARATOR ':'
74 #define BITMAP_MIN 16
75 #define BITMAP_MAX 24
76 #define GPU_TEMP_DISABLE 0
77 #define GPU_TEMP_ABORT 90
78 #define GPU_TEMP_RETAIN 80
79 #define WORKLOAD_PROFILE 2
80 #define KERNEL_ACCEL 0
81 #define KERNEL_LOOPS 0
82 #define KERNEL_RULES 1024
83 #define KERNEL_COMBS 1024
84 #define KERNEL_BFS 1024
85 #define KERNEL_THREADS 64
86 #define POWERTUNE_ENABLE 0
87 #define LOGFILE_DISABLE 0
88 #define SCRYPT_TMTO 0
89 #define OPENCL_VECTOR_WIDTH 0
90
91 #define WL_MODE_STDIN 1
92 #define WL_MODE_FILE 2
93 #define WL_MODE_MASK 3
94
95 #define HL_MODE_FILE 4
96 #define HL_MODE_ARG 5
97
98 #define HLFMT_HASHCAT 0
99 #define HLFMT_PWDUMP 1
100 #define HLFMT_PASSWD 2
101 #define HLFMT_SHADOW 3
102 #define HLFMT_DCC 4
103 #define HLFMT_DCC2 5
104 #define HLFMT_NETNTLM1 7
105 #define HLFMT_NETNTLM2 8
106 #define HLFMT_NSLDAP 9
107 #define HLFMT_NSLDAPS 10
108 #define HLFMTS_CNT 11
109
110 #define ATTACK_MODE_STRAIGHT 0
111 #define ATTACK_MODE_COMBI 1
112 #define ATTACK_MODE_TOGGLE 2
113 #define ATTACK_MODE_BF 3
114 #define ATTACK_MODE_PERM 4
115 #define ATTACK_MODE_TABLE 5
116 #define ATTACK_MODE_HYBRID1 6
117 #define ATTACK_MODE_HYBRID2 7
118 #define ATTACK_MODE_NONE 100
119
120 #define ATTACK_KERN_STRAIGHT 0
121 #define ATTACK_KERN_COMBI 1
122 #define ATTACK_KERN_BF 3
123 #define ATTACK_KERN_NONE 100
124
125 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
126 #define ATTACK_EXEC_INSIDE_KERNEL 11
127
128 #define COMBINATOR_MODE_BASE_LEFT 10001
129 #define COMBINATOR_MODE_BASE_RIGHT 10002
130
131 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
132 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
133
134 #define MAX_CUT_TRIES 4
135
136 #define MAX_DICTSTAT 10000
137
138 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
139
140 #define global_free(attr) \
141 { \
142 myfree ((void *) data.attr); \
143 \
144 data.attr = NULL; \
145 }
146
147 #define local_free(attr) \
148 { \
149 myfree ((void *) attr); \
150 \
151 attr = NULL; \
152 }
153
154 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
155 {
156 900,
157 0,
158 5100,
159 100,
160 1400,
161 10800,
162 1700,
163 5000,
164 10100,
165 6000,
166 6100,
167 6900,
168 11700,
169 11800,
170 400,
171 8900,
172 11900,
173 12000,
174 10900,
175 12100,
176 23,
177 2500,
178 5300,
179 5400,
180 5500,
181 5600,
182 7300,
183 7500,
184 8300,
185 11100,
186 11200,
187 11400,
188 121,
189 2611,
190 2711,
191 2811,
192 8400,
193 11,
194 2612,
195 7900,
196 21,
197 11000,
198 124,
199 10000,
200 3711,
201 7600,
202 12,
203 131,
204 132,
205 1731,
206 200,
207 300,
208 3100,
209 112,
210 12300,
211 8000,
212 141,
213 1441,
214 1600,
215 12600,
216 1421,
217 101,
218 111,
219 1711,
220 3000, // broken in osx
221 1000,
222 1100,
223 2100,
224 12800,
225 1500, // broken in osx
226 12400,
227 500,
228 3200,
229 7400,
230 1800,
231 122,
232 1722,
233 7100,
234 6300,
235 6700,
236 6400,
237 6500,
238 2400,
239 2410,
240 5700,
241 9200,
242 9300,
243 22,
244 501,
245 5800,
246 8100,
247 8500,
248 7200,
249 9900,
250 7700,
251 7800,
252 10300,
253 8600,
254 8700,
255 9100,
256 133,
257 11600,
258 12500,
259 13000,
260 6211,
261 6221,
262 6231,
263 6241,
264 8800,
265 12900,
266 12200,
267 9700,
268 9710,
269 9800,
270 9810,
271 9400,
272 9500,
273 9600,
274 10400,
275 10410,
276 10500,
277 10600,
278 10700, // broken in osx
279 9000,
280 5200,
281 6800,
282 6600,
283 8200,
284 11300,
285 12700
286 };
287
288 /**
289 * types
290 */
291
292 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
293
294 /**
295 * globals
296 */
297
298 static unsigned int full01 = 0x01010101;
299 static unsigned int full80 = 0x80808080;
300
301 int SUPPRESS_OUTPUT = 0;
302
303 hc_thread_mutex_t mux_adl;
304 hc_thread_mutex_t mux_counter;
305 hc_thread_mutex_t mux_dispatcher;
306 hc_thread_mutex_t mux_display;
307
308 hc_global_data_t data;
309
310 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
311
312 const char *USAGE_MINI[] =
313 {
314 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
315 "",
316 "Try --help for more help.",
317 NULL
318 };
319
320 const char *USAGE_BIG[] =
321 {
322 "%s, advanced password recovery",
323 "",
324 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
325 "",
326 "=======",
327 "Options",
328 "=======",
329 "",
330 "* General:",
331 "",
332 " -m, --hash-type=NUM Hash-type, see references below",
333 " -a, --attack-mode=NUM Attack-mode, see references below",
334 " -V, --version Print version",
335 " -h, --help Print help",
336 " --quiet Suppress output",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -b, --benchmark Run benchmark",
387 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
388 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
389 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
390 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
391 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
392 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
393 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
394 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
395 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
396 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
397 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
398 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
399 #ifdef HAVE_HWMON
400 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
401 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
402 #ifdef HAVE_ADL
403 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
404 #endif
405 #endif
406 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
407 "",
408 "* Distributed:",
409 "",
410 " -s, --skip=NUM Skip number of words",
411 " -l, --limit=NUM Limit number of words",
412 " --keyspace Show keyspace base:mod values and quit",
413 "",
414 "* Rules:",
415 "",
416 " -j, --rule-left=RULE Single rule applied to each word from left dict",
417 " -k, --rule-right=RULE Single rule applied to each word from right dict",
418 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
419 " -g, --generate-rules=NUM Generate NUM random rules",
420 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
421 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
422 " --generate-rules-seed=NUM Force RNG seed to NUM",
423 "",
424 "* Custom charsets:",
425 "",
426 " -1, --custom-charset1=CS User-defined charsets",
427 " -2, --custom-charset2=CS Example:",
428 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
429 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
430 "",
431 "* Increment:",
432 "",
433 " -i, --increment Enable increment mode",
434 " --increment-min=NUM Start incrementing at NUM",
435 " --increment-max=NUM Stop incrementing at NUM",
436 "",
437 "==========",
438 "References",
439 "==========",
440 "",
441 "* Workload Profile:",
442 "",
443 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
444 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
445 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
446 "",
447 "* OpenCL device-types:",
448 "",
449 " 1 = CPU devices",
450 " 2 = GPU devices",
451 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
452 "",
453 "* Outfile Formats:",
454 "",
455 " 1 = hash[:salt]",
456 " 2 = plain",
457 " 3 = hash[:salt]:plain",
458 " 4 = hex_plain",
459 " 5 = hash[:salt]:hex_plain",
460 " 6 = plain:hex_plain",
461 " 7 = hash[:salt]:plain:hex_plain",
462 " 8 = crackpos",
463 " 9 = hash[:salt]:crackpos",
464 " 10 = plain:crackpos",
465 " 11 = hash[:salt]:plain:crackpos",
466 " 12 = hex_plain:crackpos",
467 " 13 = hash[:salt]:hex_plain:crackpos",
468 " 14 = plain:hex_plain:crackpos",
469 " 15 = hash[:salt]:plain:hex_plain:crackpos",
470 "",
471 "* Debug mode output formats (for hybrid mode only, by using rules):",
472 "",
473 " 1 = save finding rule",
474 " 2 = save original word",
475 " 3 = save original word and finding rule",
476 " 4 = save original word, finding rule and modified plain",
477 "",
478 "* Built-in charsets:",
479 "",
480 " ?l = abcdefghijklmnopqrstuvwxyz",
481 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
482 " ?d = 0123456789",
483 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
484 " ?a = ?l?u?d?s",
485 " ?b = 0x00 - 0xff",
486 "",
487 "* Attack modes:",
488 "",
489 " 0 = Straight",
490 " 1 = Combination",
491 " 3 = Brute-force",
492 " 6 = Hybrid dict + mask",
493 " 7 = Hybrid mask + dict",
494 "",
495 "* Hash types:",
496 "",
497 "[[ Roll-your-own: Raw Hashes ]]",
498 "",
499 " 900 = MD4",
500 " 0 = MD5",
501 " 5100 = Half MD5",
502 " 100 = SHA1",
503 " 10800 = SHA-384",
504 " 1400 = SHA-256",
505 " 1700 = SHA-512",
506 " 5000 = SHA-3(Keccak)",
507 " 10100 = SipHash",
508 " 6000 = RipeMD160",
509 " 6100 = Whirlpool",
510 " 6900 = GOST R 34.11-94",
511 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
512 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
513 "",
514 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
515 "",
516 " 10 = md5($pass.$salt)",
517 " 20 = md5($salt.$pass)",
518 " 30 = md5(unicode($pass).$salt)",
519 " 40 = md5($salt.unicode($pass))",
520 " 3800 = md5($salt.$pass.$salt)",
521 " 3710 = md5($salt.md5($pass))",
522 " 2600 = md5(md5($pass)",
523 " 4300 = md5(strtoupper(md5($pass)))",
524 " 4400 = md5(sha1($pass))",
525 " 110 = sha1($pass.$salt)",
526 " 120 = sha1($salt.$pass)",
527 " 130 = sha1(unicode($pass).$salt)",
528 " 140 = sha1($salt.unicode($pass))",
529 " 4500 = sha1(sha1($pass)",
530 " 4700 = sha1(md5($pass))",
531 " 4900 = sha1($salt.$pass.$salt)",
532 " 1410 = sha256($pass.$salt)",
533 " 1420 = sha256($salt.$pass)",
534 " 1430 = sha256(unicode($pass).$salt)",
535 " 1440 = sha256($salt.unicode($pass))",
536 " 1710 = sha512($pass.$salt)",
537 " 1720 = sha512($salt.$pass)",
538 " 1730 = sha512(unicode($pass).$salt)",
539 " 1740 = sha512($salt.unicode($pass))",
540 "",
541 "[[ Roll-your-own: Authenticated Hashes ]]",
542 "",
543 " 50 = HMAC-MD5 (key = $pass)",
544 " 60 = HMAC-MD5 (key = $salt)",
545 " 150 = HMAC-SHA1 (key = $pass)",
546 " 160 = HMAC-SHA1 (key = $salt)",
547 " 1450 = HMAC-SHA256 (key = $pass)",
548 " 1460 = HMAC-SHA256 (key = $salt)",
549 " 1750 = HMAC-SHA512 (key = $pass)",
550 " 1760 = HMAC-SHA512 (key = $salt)",
551 "",
552 "[[ Generic KDF ]]",
553 "",
554 " 400 = phpass",
555 " 8900 = scrypt",
556 " 11900 = PBKDF2-HMAC-MD5",
557 " 12000 = PBKDF2-HMAC-SHA1",
558 " 10900 = PBKDF2-HMAC-SHA256",
559 " 12100 = PBKDF2-HMAC-SHA512",
560 "",
561 "[[ Network protocols, Challenge-Response ]]",
562 "",
563 " 23 = Skype",
564 " 2500 = WPA/WPA2",
565 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
566 " 5300 = IKE-PSK MD5",
567 " 5400 = IKE-PSK SHA1",
568 " 5500 = NetNTLMv1",
569 " 5500 = NetNTLMv1 + ESS",
570 " 5600 = NetNTLMv2",
571 " 7300 = IPMI2 RAKP HMAC-SHA1",
572 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
573 " 8300 = DNSSEC (NSEC3)",
574 " 10200 = Cram MD5",
575 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
576 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
577 " 11400 = SIP digest authentication (MD5)",
578 "",
579 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
580 "",
581 " 121 = SMF (Simple Machines Forum)",
582 " 400 = phpBB3",
583 " 2611 = vBulletin < v3.8.5",
584 " 2711 = vBulletin > v3.8.5",
585 " 2811 = MyBB",
586 " 2811 = IPB (Invison Power Board)",
587 " 8400 = WBB3 (Woltlab Burning Board)",
588 " 11 = Joomla < 2.5.18",
589 " 400 = Joomla > 2.5.18",
590 " 400 = Wordpress",
591 " 2612 = PHPS",
592 " 7900 = Drupal7",
593 " 21 = osCommerce",
594 " 21 = xt:Commerce",
595 " 11000 = PrestaShop",
596 " 124 = Django (SHA-1)",
597 " 10000 = Django (PBKDF2-SHA256)",
598 " 3711 = Mediawiki B type",
599 " 7600 = Redmine",
600 "",
601 "[[ Database Server ]]",
602 "",
603 " 12 = PostgreSQL",
604 " 131 = MSSQL(2000)",
605 " 132 = MSSQL(2005)",
606 " 1731 = MSSQL(2012)",
607 " 1731 = MSSQL(2014)",
608 " 200 = MySQL323",
609 " 300 = MySQL4.1/MySQL5",
610 " 3100 = Oracle H: Type (Oracle 7+)",
611 " 112 = Oracle S: Type (Oracle 11+)",
612 " 12300 = Oracle T: Type (Oracle 12+)",
613 " 8000 = Sybase ASE",
614 "",
615 "[[ HTTP, SMTP, LDAP Server ]]",
616 "",
617 " 141 = EPiServer 6.x < v4",
618 " 1441 = EPiServer 6.x > v4",
619 " 1600 = Apache $apr1$",
620 " 12600 = ColdFusion 10+",
621 " 1421 = hMailServer",
622 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
623 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
624 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
625 "",
626 "[[ Checksums ]]",
627 "",
628 " 11500 = CRC32",
629 "",
630 "[[ Operating-Systems ]]",
631 "",
632 " 3000 = LM",
633 " 1000 = NTLM",
634 " 1100 = Domain Cached Credentials (DCC), MS Cache",
635 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
636 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
637 " 1500 = descrypt, DES(Unix), Traditional DES",
638 " 12400 = BSDiCrypt, Extended DES",
639 " 500 = md5crypt $1$, MD5(Unix)",
640 " 3200 = bcrypt $2*$, Blowfish(Unix)",
641 " 7400 = sha256crypt $5$, SHA256(Unix)",
642 " 1800 = sha512crypt $6$, SHA512(Unix)",
643 " 122 = OSX v10.4",
644 " 122 = OSX v10.5",
645 " 122 = OSX v10.6",
646 " 1722 = OSX v10.7",
647 " 7100 = OSX v10.8",
648 " 7100 = OSX v10.9",
649 " 7100 = OSX v10.10",
650 " 6300 = AIX {smd5}",
651 " 6700 = AIX {ssha1}",
652 " 6400 = AIX {ssha256}",
653 " 6500 = AIX {ssha512}",
654 " 2400 = Cisco-PIX",
655 " 2410 = Cisco-ASA",
656 " 500 = Cisco-IOS $1$",
657 " 5700 = Cisco-IOS $4$",
658 " 9200 = Cisco-IOS $8$",
659 " 9300 = Cisco-IOS $9$",
660 " 22 = Juniper Netscreen/SSG (ScreenOS)",
661 " 501 = Juniper IVE",
662 " 5800 = Android PIN",
663 " 8100 = Citrix Netscaler",
664 " 8500 = RACF",
665 " 7200 = GRUB 2",
666 " 9900 = Radmin2",
667 "",
668 "[[ Enterprise Application Software (EAS) ]]",
669 "",
670 " 7700 = SAP CODVN B (BCODE)",
671 " 7800 = SAP CODVN F/G (PASSCODE)",
672 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
673 " 8600 = Lotus Notes/Domino 5",
674 " 8700 = Lotus Notes/Domino 6",
675 " 9100 = Lotus Notes/Domino 8",
676 " 133 = PeopleSoft",
677 "",
678 "[[ Archives ]]",
679 "",
680 " 11600 = 7-Zip",
681 " 12500 = RAR3-hp",
682 " 13000 = RAR5",
683 "",
684 "[[ Full-Disk encryptions (FDE) ]]",
685 "",
686 " 62XY = TrueCrypt 5.0+",
687 " X = 1 = PBKDF2-HMAC-RipeMD160",
688 " X = 2 = PBKDF2-HMAC-SHA512",
689 " X = 3 = PBKDF2-HMAC-Whirlpool",
690 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
691 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
692 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
693 " Y = 3 = XTS 1536 bit (Ciphers: All)",
694 " 8800 = Android FDE < v4.3",
695 " 12900 = Android FDE (Samsung DEK)",
696 " 12200 = eCryptfs",
697 "",
698 "[[ Documents ]]",
699 "",
700 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
701 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
702 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
703 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
704 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
705 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
706 " 9400 = MS Office 2007",
707 " 9500 = MS Office 2010",
708 " 9600 = MS Office 2013",
709 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
710 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
711 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
712 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
713 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
714 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
715 "",
716 "[[ Password Managers ]]",
717 "",
718 " 9000 = Password Safe v2",
719 " 5200 = Password Safe v3",
720 " 6800 = Lastpass",
721 " 6600 = 1Password, agilekeychain",
722 " 8200 = 1Password, cloudkeychain",
723 " 11300 = Bitcoin/Litecoin wallet.dat",
724 " 12700 = Blockchain, My Wallet",
725 "",
726 NULL
727 };
728
729 /**
730 * oclHashcat specific functions
731 */
732
733 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
734 {
735 int exec_pos = (int) device_param->exec_pos - last_num_entries;
736
737 if (exec_pos < 0) exec_pos += EXEC_CACHE;
738
739 double exec_ms_sum = 0;
740
741 int exec_ms_cnt = 0;
742
743 for (int i = 0; i < last_num_entries; i++)
744 {
745 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
746
747 if (exec_ms)
748 {
749 exec_ms_sum += exec_ms;
750
751 exec_ms_cnt++;
752 }
753 }
754
755 if (exec_ms_cnt == 0) return 0;
756
757 return exec_ms_sum / exec_ms_cnt;
758 }
759
760 void status_display_automat ()
761 {
762 FILE *out = stdout;
763
764 fprintf (out, "STATUS\t%u\t", data.devices_status);
765
766 /**
767 * speed new
768 */
769
770 fprintf (out, "SPEED\t");
771
772 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
773 {
774 hc_device_param_t *device_param = &data.devices_param[device_id];
775
776 if (device_param->skipped) continue;
777
778 u64 speed_cnt = 0;
779 float speed_ms = 0;
780
781 for (int i = 0; i < SPEED_CACHE; i++)
782 {
783 float rec_ms;
784
785 hc_timer_get (device_param->speed_rec[i], rec_ms);
786
787 if (rec_ms > SPEED_MAXAGE) continue;
788
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 uint salts_left = data.salts_cnt - data.salts_done;
829
830 if (salts_left == 0) salts_left = 1;
831
832 u64 progress_total = data.words_cnt * salts_left;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 if (salts_left > 1)
841 {
842 // otherwise the final cracked status shows 0/XXX progress
843
844 if (data.salts_shown[salt_pos] == 1) continue;
845 }
846
847 all_done += data.words_progress_done[salt_pos];
848 all_rejected += data.words_progress_rejected[salt_pos];
849 all_restored += data.words_progress_restored[salt_pos];
850 }
851
852 u64 progress_cur = all_restored + all_done + all_rejected;
853 u64 progress_end = progress_total;
854
855 u64 progress_skip = 0;
856
857 if (data.skip)
858 {
859 progress_skip = MIN (data.skip, data.words_base) * salts_left;
860
861 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
862 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
863 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
864 }
865
866 if (data.limit)
867 {
868 progress_end = MIN (data.limit, data.words_base) * salts_left;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
873 }
874
875 u64 progress_cur_relative_skip = progress_cur - progress_skip;
876 u64 progress_end_relative_skip = progress_end - progress_skip;
877
878 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
879
880 /**
881 * cracks
882 */
883
884 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
885 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
886
887 /**
888 * temperature
889 */
890
891 #ifdef HAVE_HWMON
892 if (data.gpu_temp_disable == 0)
893 {
894 fprintf (out, "TEMP\t");
895
896 hc_thread_mutex_lock (mux_adl);
897
898 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
899 {
900 hc_device_param_t *device_param = &data.devices_param[device_id];
901
902 if (device_param->skipped) continue;
903
904 int temp = hm_get_temperature_with_device_id (device_id);
905
906 fprintf (out, "%d\t", temp);
907 }
908
909 hc_thread_mutex_unlock (mux_adl);
910 }
911 #endif // HAVE_HWMON
912
913 /**
914 * flush
915 */
916
917 #ifdef _WIN
918 fputc ('\r', out);
919 fputc ('\n', out);
920 #endif
921
922 #ifdef _POSIX
923 fputc ('\n', out);
924 #endif
925
926 fflush (out);
927 }
928
929 void status_display ()
930 {
931 if (data.devices_status == STATUS_INIT) return;
932 if (data.devices_status == STATUS_STARTING) return;
933 if (data.devices_status == STATUS_BYPASS) return;
934
935 if (data.status_automat == 1)
936 {
937 status_display_automat ();
938
939 return;
940 }
941
942 char tmp_buf[1000] = { 0 };
943
944 uint tmp_len = 0;
945
946 log_info ("Session.Name...: %s", data.session);
947
948 char *status_type = strstatus (data.devices_status);
949
950 uint hash_mode = data.hash_mode;
951
952 char *hash_type = strhashtype (hash_mode); // not a bug
953
954 log_info ("Status.........: %s", status_type);
955
956 /**
957 * show rules
958 */
959
960 if (data.rp_files_cnt)
961 {
962 uint i;
963
964 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
965 {
966 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
967 }
968
969 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
970
971 log_info ("Rules.Type.....: %s", tmp_buf);
972
973 tmp_len = 0;
974 }
975
976 if (data.rp_gen)
977 {
978 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
979
980 if (data.rp_gen_seed)
981 {
982 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
983 }
984 }
985
986 /**
987 * show input
988 */
989
990 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
991 {
992 if (data.wordlist_mode == WL_MODE_FILE)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
995 }
996 else if (data.wordlist_mode == WL_MODE_STDIN)
997 {
998 log_info ("Input.Mode.....: Pipe");
999 }
1000 }
1001 else if (data.attack_mode == ATTACK_MODE_COMBI)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1004 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_BF)
1007 {
1008 char *mask = data.mask;
1009
1010 if (mask != NULL)
1011 {
1012 uint mask_len = data.css_cnt;
1013
1014 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1015
1016 if (mask_len > 0)
1017 {
1018 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1019 {
1020 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1021 {
1022 mask_len -= data.salts_buf[0].salt_len;
1023 }
1024 }
1025
1026 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1029 }
1030
1031 if (data.maskcnt > 1)
1032 {
1033 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1034
1035 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1036 }
1037
1038 log_info ("Input.Mode.....: %s", tmp_buf);
1039 }
1040
1041 tmp_len = 0;
1042 }
1043 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1044 {
1045 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1046 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1049 {
1050 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1052 }
1053
1054 if (data.digests_cnt == 1)
1055 {
1056 if (data.hash_mode == 2500)
1057 {
1058 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1059
1060 uint pke[25] = { 0 };
1061
1062 char *pke_ptr = (char *) pke;
1063
1064 for (uint i = 0; i < 25; i++)
1065 {
1066 pke[i] = byte_swap_32 (wpa->pke[i]);
1067 }
1068
1069 char mac1[6] = { 0 };
1070 char mac2[6] = { 0 };
1071
1072 memcpy (mac1, pke_ptr + 23, 6);
1073 memcpy (mac2, pke_ptr + 29, 6);
1074
1075 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1076 (char *) data.salts_buf[0].salt_buf,
1077 mac1[0] & 0xff,
1078 mac1[1] & 0xff,
1079 mac1[2] & 0xff,
1080 mac1[3] & 0xff,
1081 mac1[4] & 0xff,
1082 mac1[5] & 0xff,
1083 mac2[0] & 0xff,
1084 mac2[1] & 0xff,
1085 mac2[2] & 0xff,
1086 mac2[3] & 0xff,
1087 mac2[4] & 0xff,
1088 mac2[5] & 0xff);
1089 }
1090 else if (data.hash_mode == 5200)
1091 {
1092 log_info ("Hash.Target....: File (%s)", data.hashfile);
1093 }
1094 else if (data.hash_mode == 9000)
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1099 {
1100 log_info ("Hash.Target....: File (%s)", data.hashfile);
1101 }
1102 else
1103 {
1104 char out_buf[4096] = { 0 };
1105
1106 ascii_digest (out_buf, 0, 0);
1107
1108 // limit length
1109 if (strlen (out_buf) > 40)
1110 {
1111 out_buf[41] = '.';
1112 out_buf[42] = '.';
1113 out_buf[43] = '.';
1114 out_buf[44] = 0;
1115 }
1116
1117 log_info ("Hash.Target....: %s", out_buf);
1118 }
1119 }
1120 else
1121 {
1122 if (data.hash_mode == 3000)
1123 {
1124 char out_buf1[4096] = { 0 };
1125 char out_buf2[4096] = { 0 };
1126
1127 ascii_digest (out_buf1, 0, 0);
1128 ascii_digest (out_buf2, 0, 1);
1129
1130 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1131 }
1132 else
1133 {
1134 log_info ("Hash.Target....: File (%s)", data.hashfile);
1135 }
1136 }
1137
1138 log_info ("Hash.Type......: %s", hash_type);
1139
1140 /**
1141 * speed new
1142 */
1143
1144 u64 speed_cnt[DEVICES_MAX] = { 0 };
1145 float speed_ms[DEVICES_MAX] = { 0 };
1146
1147 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1148 {
1149 hc_device_param_t *device_param = &data.devices_param[device_id];
1150
1151 if (device_param->skipped) continue;
1152
1153 // we need to clear values (set to 0) because in case the device does
1154 // not get new candidates it idles around but speed display would
1155 // show it as working.
1156 // if we instantly set it to 0 after reading it happens that the
1157 // speed can be shown as zero if the users refreshes too fast.
1158 // therefore, we add a timestamp when a stat was recorded and if its
1159 // too old we will not use it
1160
1161 speed_cnt[device_id] = 0;
1162 speed_ms[device_id] = 0;
1163
1164 for (int i = 0; i < SPEED_CACHE; i++)
1165 {
1166 float rec_ms;
1167
1168 hc_timer_get (device_param->speed_rec[i], rec_ms);
1169
1170 if (rec_ms > SPEED_MAXAGE) continue;
1171
1172 speed_cnt[device_id] += device_param->speed_cnt[i];
1173 speed_ms[device_id] += device_param->speed_ms[i];
1174 }
1175
1176 speed_cnt[device_id] /= SPEED_CACHE;
1177 speed_ms[device_id] /= SPEED_CACHE;
1178 }
1179
1180 float hashes_all_ms = 0;
1181
1182 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1183
1184 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1185 {
1186 hc_device_param_t *device_param = &data.devices_param[device_id];
1187
1188 if (device_param->skipped) continue;
1189
1190 hashes_dev_ms[device_id] = 0;
1191
1192 if (speed_ms[device_id])
1193 {
1194 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1195
1196 hashes_all_ms += hashes_dev_ms[device_id];
1197 }
1198 }
1199
1200 /**
1201 * exec time
1202 */
1203
1204 double exec_all_ms[DEVICES_MAX] = { 0 };
1205
1206 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1207 {
1208 hc_device_param_t *device_param = &data.devices_param[device_id];
1209
1210 if (device_param->skipped) continue;
1211
1212 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1213
1214 exec_all_ms[device_id] = exec_ms_avg;
1215 }
1216
1217 /**
1218 * timers
1219 */
1220
1221 float ms_running = 0;
1222
1223 hc_timer_get (data.timer_running, ms_running);
1224
1225 float ms_paused = data.ms_paused;
1226
1227 if (data.devices_status == STATUS_PAUSED)
1228 {
1229 float ms_paused_tmp = 0;
1230
1231 hc_timer_get (data.timer_paused, ms_paused_tmp);
1232
1233 ms_paused += ms_paused_tmp;
1234 }
1235
1236 #ifdef WIN
1237
1238 __time64_t sec_run = ms_running / 1000;
1239
1240 #else
1241
1242 time_t sec_run = ms_running / 1000;
1243
1244 #endif
1245
1246 if (sec_run)
1247 {
1248 char display_run[32] = { 0 };
1249
1250 struct tm tm_run;
1251
1252 struct tm *tmp = NULL;
1253
1254 #ifdef WIN
1255
1256 tmp = _gmtime64 (&sec_run);
1257
1258 #else
1259
1260 tmp = gmtime (&sec_run);
1261
1262 #endif
1263
1264 if (tmp != NULL)
1265 {
1266 memset (&tm_run, 0, sizeof (tm_run));
1267
1268 memcpy (&tm_run, tmp, sizeof (tm_run));
1269
1270 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1271
1272 char *start = ctime (&data.proc_start);
1273
1274 size_t start_len = strlen (start);
1275
1276 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1277 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1278
1279 log_info ("Time.Started...: %s (%s)", start, display_run);
1280 }
1281 }
1282 else
1283 {
1284 log_info ("Time.Started...: 0 secs");
1285 }
1286
1287 /**
1288 * counters
1289 */
1290
1291 uint salts_left = data.salts_cnt - data.salts_done;
1292
1293 if (salts_left == 0) salts_left = 1;
1294
1295 u64 progress_total = data.words_cnt * salts_left;
1296
1297 u64 all_done = 0;
1298 u64 all_rejected = 0;
1299 u64 all_restored = 0;
1300
1301 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1302 {
1303 if (salts_left > 1)
1304 {
1305 // otherwise the final cracked status shows 0/XXX progress
1306
1307 if (data.salts_shown[salt_pos] == 1) continue;
1308 }
1309
1310 all_done += data.words_progress_done[salt_pos];
1311 all_rejected += data.words_progress_rejected[salt_pos];
1312 all_restored += data.words_progress_restored[salt_pos];
1313 }
1314
1315 u64 progress_cur = all_restored + all_done + all_rejected;
1316 u64 progress_end = progress_total;
1317
1318 u64 progress_skip = 0;
1319
1320 if (data.skip)
1321 {
1322 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1323
1324 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1325 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1326 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1327 }
1328
1329 if (data.limit)
1330 {
1331 progress_end = MIN (data.limit, data.words_base) * salts_left;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1336 }
1337
1338 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1339 u64 progress_end_relative_skip = progress_end - progress_skip;
1340
1341 float speed_ms_real = ms_running - ms_paused;
1342 u64 speed_plains_real = all_done;
1343
1344 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1345 {
1346 if (data.devices_status != STATUS_CRACKED)
1347 {
1348 u64 words_per_ms = 0;
1349
1350 if (speed_plains_real && speed_ms_real)
1351 {
1352 words_per_ms = speed_plains_real / speed_ms_real;
1353 }
1354
1355 #ifdef WIN
1356 __time64_t sec_etc = 0;
1357 #else
1358 time_t sec_etc = 0;
1359 #endif
1360
1361 if (words_per_ms)
1362 {
1363 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1364
1365 u64 ms_left = progress_left_relative_skip / words_per_ms;
1366
1367 sec_etc = ms_left / 1000;
1368 }
1369
1370 if (sec_etc == 0)
1371 {
1372 log_info ("Time.Estimated.: 0 secs");
1373 }
1374 else if ((u64) sec_etc > ETC_MAX)
1375 {
1376 log_info ("Time.Estimated.: > 10 Years");
1377 }
1378 else
1379 {
1380 char display_etc[32] = { 0 };
1381
1382 struct tm tm_etc;
1383
1384 struct tm *tmp = NULL;
1385
1386 #ifdef WIN
1387
1388 tmp = _gmtime64 (&sec_etc);
1389
1390 #else
1391
1392 tmp = gmtime (&sec_etc);
1393
1394 #endif
1395
1396 if (tmp != NULL)
1397 {
1398 memset (&tm_etc, 0, sizeof (tm_etc));
1399
1400 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1401
1402 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1403
1404 time_t now;
1405
1406 time (&now);
1407
1408 now += sec_etc;
1409
1410 char *etc = ctime (&now);
1411
1412 size_t etc_len = strlen (etc);
1413
1414 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1415 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1416
1417 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1418 }
1419 }
1420 }
1421 }
1422
1423 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1424 {
1425 hc_device_param_t *device_param = &data.devices_param[device_id];
1426
1427 if (device_param->skipped) continue;
1428
1429 char display_dev_cur[16] = { 0 };
1430
1431 strncpy (display_dev_cur, "0.00", 4);
1432
1433 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1434
1435 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1436 }
1437
1438 char display_all_cur[16] = { 0 };
1439
1440 strncpy (display_all_cur, "0.00", 4);
1441
1442 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1443
1444 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1445
1446 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1447 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1448
1449 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);
1450
1451 // crack-per-time
1452
1453 if (data.digests_cnt > 100)
1454 {
1455 time_t now = time (NULL);
1456
1457 int cpt_cur_min = 0;
1458 int cpt_cur_hour = 0;
1459 int cpt_cur_day = 0;
1460
1461 for (int i = 0; i < CPT_BUF; i++)
1462 {
1463 const uint cracked = data.cpt_buf[i].cracked;
1464 const time_t timestamp = data.cpt_buf[i].timestamp;
1465
1466 if ((timestamp + 60) > now)
1467 {
1468 cpt_cur_min += cracked;
1469 }
1470
1471 if ((timestamp + 3600) > now)
1472 {
1473 cpt_cur_hour += cracked;
1474 }
1475
1476 if ((timestamp + 86400) > now)
1477 {
1478 cpt_cur_day += cracked;
1479 }
1480 }
1481
1482 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1483 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1484 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1485
1486 if ((data.cpt_start + 86400) < now)
1487 {
1488 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1489 cpt_cur_min,
1490 cpt_cur_hour,
1491 cpt_cur_day,
1492 cpt_avg_min,
1493 cpt_avg_hour,
1494 cpt_avg_day);
1495 }
1496 else if ((data.cpt_start + 3600) < now)
1497 {
1498 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1499 cpt_cur_min,
1500 cpt_cur_hour,
1501 cpt_avg_min,
1502 cpt_avg_hour,
1503 cpt_avg_day);
1504 }
1505 else if ((data.cpt_start + 60) < now)
1506 {
1507 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1508 cpt_cur_min,
1509 cpt_avg_min,
1510 cpt_avg_hour,
1511 cpt_avg_day);
1512 }
1513 else
1514 {
1515 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1516 cpt_avg_min,
1517 cpt_avg_hour,
1518 cpt_avg_day);
1519 }
1520 }
1521
1522 // Restore point
1523
1524 u64 restore_point = get_lowest_words_done ();
1525
1526 u64 restore_total = data.words_base;
1527
1528 float percent_restore = 0;
1529
1530 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1531
1532 if (progress_end_relative_skip)
1533 {
1534 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1535 {
1536 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1537 float percent_rejected = 0.0;
1538
1539 if (progress_cur)
1540 {
1541 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1542 }
1543
1544 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);
1545 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1546
1547 if (data.restore_disable == 0)
1548 {
1549 if (percent_finished != 1)
1550 {
1551 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1552 }
1553 }
1554 }
1555 }
1556 else
1557 {
1558 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1559 {
1560 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562
1563 if (data.restore_disable == 0)
1564 {
1565 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 }
1567 }
1568 else
1569 {
1570 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1571 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1572
1573 // --restore not allowed if stdin is used -- really? why?
1574
1575 //if (data.restore_disable == 0)
1576 //{
1577 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1578 //}
1579 }
1580 }
1581
1582 #ifdef HAVE_HWMON
1583 if (data.gpu_temp_disable == 0)
1584 {
1585 hc_thread_mutex_lock (mux_adl);
1586
1587 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1588 {
1589 hc_device_param_t *device_param = &data.devices_param[device_id];
1590
1591 if (device_param->skipped) continue;
1592
1593 #define HM_STR_BUF_SIZE 255
1594
1595 if (data.hm_device[device_id].fan_supported == 1)
1596 {
1597 char utilization[HM_STR_BUF_SIZE] = { 0 };
1598 char temperature[HM_STR_BUF_SIZE] = { 0 };
1599 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1600
1601 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1602 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1603
1604 if (device_param->vendor_id == VENDOR_ID_AMD)
1605 {
1606 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1607 }
1608 else if (device_param->vendor_id == VENDOR_ID_NV)
1609 {
1610 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1611 }
1612
1613 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1614 }
1615 else
1616 {
1617 char utilization[HM_STR_BUF_SIZE] = { 0 };
1618 char temperature[HM_STR_BUF_SIZE] = { 0 };
1619
1620 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1621 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1622
1623 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1624 }
1625 }
1626
1627 hc_thread_mutex_unlock (mux_adl);
1628 }
1629 #endif // HAVE_HWMON
1630 }
1631
1632 static void status_benchmark ()
1633 {
1634 if (data.devices_status == STATUS_INIT) return;
1635 if (data.devices_status == STATUS_STARTING) return;
1636
1637 if (data.words_cnt == 0) return;
1638
1639 u64 speed_cnt[DEVICES_MAX] = { 0 };
1640 float speed_ms[DEVICES_MAX] = { 0 };
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 speed_cnt[device_id] = 0;
1649 speed_ms[device_id] = 0;
1650
1651 for (int i = 0; i < SPEED_CACHE; i++)
1652 {
1653 speed_cnt[device_id] += device_param->speed_cnt[i];
1654 speed_ms[device_id] += device_param->speed_ms[i];
1655 }
1656
1657 speed_cnt[device_id] /= SPEED_CACHE;
1658 speed_ms[device_id] /= SPEED_CACHE;
1659 }
1660
1661 float hashes_all_ms = 0;
1662
1663 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 hashes_dev_ms[device_id] = 0;
1672
1673 if (speed_ms[device_id])
1674 {
1675 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1676
1677 hashes_all_ms += hashes_dev_ms[device_id];
1678 }
1679 }
1680
1681 /**
1682 * exec time
1683 */
1684
1685 double exec_all_ms[DEVICES_MAX] = { 0 };
1686
1687 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1688 {
1689 hc_device_param_t *device_param = &data.devices_param[device_id];
1690
1691 if (device_param->skipped) continue;
1692
1693 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1694
1695 exec_all_ms[device_id] = exec_ms_avg;
1696 }
1697
1698 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1699 {
1700 hc_device_param_t *device_param = &data.devices_param[device_id];
1701
1702 if (device_param->skipped) continue;
1703
1704 char display_dev_cur[16] = { 0 };
1705
1706 strncpy (display_dev_cur, "0.00", 4);
1707
1708 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1709
1710 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1711 }
1712
1713 char display_all_cur[16] = { 0 };
1714
1715 strncpy (display_all_cur, "0.00", 4);
1716
1717 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1718
1719 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1720 }
1721
1722 /**
1723 * oclHashcat -only- functions
1724 */
1725
1726 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1727 {
1728 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1729 {
1730 if (attack_kern == ATTACK_KERN_STRAIGHT)
1731 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1732 else if (attack_kern == ATTACK_KERN_COMBI)
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1734 else if (attack_kern == ATTACK_KERN_BF)
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1736 }
1737 else
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1739 }
1740
1741 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)
1742 {
1743 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1744 {
1745 if (attack_kern == ATTACK_KERN_STRAIGHT)
1746 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1747 else if (attack_kern == ATTACK_KERN_COMBI)
1748 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 else if (attack_kern == ATTACK_KERN_BF)
1750 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1751 }
1752 else
1753 {
1754 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1755 }
1756 }
1757
1758 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1759 {
1760 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1761 {
1762 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1763 }
1764 else
1765 {
1766 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1767 }
1768 }
1769
1770 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)
1771 {
1772 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1773 {
1774 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1775 }
1776 else
1777 {
1778 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1779 }
1780 }
1781
1782 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1783 {
1784 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1785 }
1786
1787 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1790 }
1791
1792 static uint convert_from_hex (char *line_buf, const uint line_len)
1793 {
1794 if (line_len & 1) return (line_len); // not in hex
1795
1796 if (data.hex_wordlist == 1)
1797 {
1798 uint i;
1799 uint j;
1800
1801 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1802 {
1803 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1804 }
1805
1806 memset (line_buf + i, 0, line_len - i);
1807
1808 return (i);
1809 }
1810 else if (line_len >= 6) // $HEX[] = 6
1811 {
1812 if (line_buf[0] != '$') return (line_len);
1813 if (line_buf[1] != 'H') return (line_len);
1814 if (line_buf[2] != 'E') return (line_len);
1815 if (line_buf[3] != 'X') return (line_len);
1816 if (line_buf[4] != '[') return (line_len);
1817 if (line_buf[line_len - 1] != ']') return (line_len);
1818
1819 uint i;
1820 uint j;
1821
1822 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1823 {
1824 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1825 }
1826
1827 memset (line_buf + i, 0, line_len - i);
1828
1829 return (i);
1830 }
1831
1832 return (line_len);
1833 }
1834
1835 static void clear_prompt ()
1836 {
1837 fputc ('\r', stdout);
1838
1839 for (size_t i = 0; i < strlen (PROMPT); i++)
1840 {
1841 fputc (' ', stdout);
1842 }
1843
1844 fputc ('\r', stdout);
1845
1846 fflush (stdout);
1847 }
1848
1849 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1850 {
1851 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);
1852 }
1853
1854 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1855 {
1856 char *outfile = data.outfile;
1857 uint quiet = data.quiet;
1858 FILE *pot_fp = data.pot_fp;
1859 uint loopback = data.loopback;
1860 uint debug_mode = data.debug_mode;
1861 char *debug_file = data.debug_file;
1862
1863 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1864 int debug_rule_len = 0; // -1 error
1865 uint debug_plain_len = 0;
1866
1867 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1868
1869 // hash
1870
1871 char out_buf[4096] = { 0 };
1872
1873 ascii_digest (out_buf, salt_pos, digest_pos);
1874
1875 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1876
1877 // plain
1878
1879 plain_t plain;
1880
1881 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);
1882
1883 uint gidvid = plain.gidvid;
1884 uint il_pos = plain.il_pos;
1885
1886 u64 crackpos = device_param->words_off;
1887
1888 uint plain_buf[16] = { 0 };
1889
1890 u8 *plain_ptr = (u8 *) plain_buf;
1891 unsigned int plain_len = 0;
1892
1893 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1894 {
1895 u64 gidd = gidvid;
1896 u64 gidm = 0;
1897
1898 pw_t pw;
1899
1900 gidd_to_pw_t (device_param, gidd, &pw);
1901
1902 for (int i = 0, j = gidm; i < 16; i++, j++)
1903 {
1904 plain_buf[i] = pw.h.hi1[0][j];
1905 }
1906
1907 plain_len = pw.pw_len;
1908
1909 const uint off = device_param->innerloop_pos + il_pos;
1910
1911 if (debug_mode > 0)
1912 {
1913 debug_rule_len = 0;
1914
1915 // save rule
1916 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1917 {
1918 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1919
1920 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1921 }
1922
1923 // save plain
1924 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1925 {
1926 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1927
1928 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1929
1930 debug_plain_len = plain_len;
1931 }
1932 }
1933
1934 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1935
1936 crackpos += gidvid;
1937 crackpos *= data.kernel_rules_cnt;
1938 crackpos += device_param->innerloop_pos + il_pos;
1939
1940 if (plain_len > data.pw_max) plain_len = data.pw_max;
1941 }
1942 else if (data.attack_mode == ATTACK_MODE_COMBI)
1943 {
1944 u64 gidd = gidvid;
1945 u64 gidm = 0;
1946
1947 pw_t pw;
1948
1949 gidd_to_pw_t (device_param, gidd, &pw);
1950
1951 for (int i = 0, j = gidm; i < 16; i++, j++)
1952 {
1953 plain_buf[i] = pw.h.hi1[0][j];
1954 }
1955
1956 plain_len = pw.pw_len;
1957
1958 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1959 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1960
1961 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1962 {
1963 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1964 }
1965 else
1966 {
1967 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1968
1969 memcpy (plain_ptr, comb_buf, comb_len);
1970 }
1971
1972 plain_len += comb_len;
1973
1974 crackpos += gidvid;
1975 crackpos *= data.combs_cnt;
1976 crackpos += device_param->innerloop_pos + il_pos;
1977
1978 if (data.pw_max != PW_DICTMAX1)
1979 {
1980 if (plain_len > data.pw_max) plain_len = data.pw_max;
1981 }
1982 }
1983 else if (data.attack_mode == ATTACK_MODE_BF)
1984 {
1985 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1986 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1987
1988 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1989 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1990
1991 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1992 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1993
1994 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1995 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1996
1997 plain_len = data.css_cnt;
1998
1999 crackpos += gidvid;
2000 crackpos *= data.bfs_cnt;
2001 crackpos += device_param->innerloop_pos + il_pos;
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2004 {
2005 u64 gidd = gidvid;
2006 u64 gidm = 0;
2007
2008 pw_t pw;
2009
2010 gidd_to_pw_t (device_param, gidd, &pw);
2011
2012 for (int i = 0, j = gidm; i < 16; i++, j++)
2013 {
2014 plain_buf[i] = pw.h.hi1[0][j];
2015 }
2016
2017 plain_len = pw.pw_len;
2018
2019 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2020
2021 uint start = 0;
2022 uint stop = device_param->kernel_params_mp_buf32[4];
2023
2024 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2025
2026 plain_len += start + stop;
2027
2028 crackpos += gidvid;
2029 crackpos *= data.combs_cnt;
2030 crackpos += device_param->innerloop_pos + il_pos;
2031
2032 if (data.pw_max != PW_DICTMAX1)
2033 {
2034 if (plain_len > data.pw_max) plain_len = data.pw_max;
2035 }
2036 }
2037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2038 {
2039 u64 gidd = gidvid;
2040 u64 gidm = 0;
2041
2042 pw_t pw;
2043
2044 gidd_to_pw_t (device_param, gidd, &pw);
2045
2046 for (int i = 0, j = gidm; i < 16; i++, j++)
2047 {
2048 plain_buf[i] = pw.h.hi1[0][j];
2049 }
2050
2051 plain_len = pw.pw_len;
2052
2053 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2054
2055 uint start = 0;
2056 uint stop = device_param->kernel_params_mp_buf32[4];
2057
2058 memmove (plain_ptr + stop, plain_ptr, plain_len);
2059
2060 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2061
2062 plain_len += start + stop;
2063
2064 crackpos += gidvid;
2065 crackpos *= data.combs_cnt;
2066 crackpos += device_param->innerloop_pos + il_pos;
2067
2068 if (data.pw_max != PW_DICTMAX1)
2069 {
2070 if (plain_len > data.pw_max) plain_len = data.pw_max;
2071 }
2072 }
2073
2074 if (data.attack_mode == ATTACK_MODE_BF)
2075 {
2076 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2077 {
2078 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2079 {
2080 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2081 {
2082 plain_len = plain_len - data.salts_buf[0].salt_len;
2083 }
2084 }
2085
2086 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2087 {
2088 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2089 {
2090 plain_ptr[j] = plain_ptr[i];
2091 }
2092
2093 plain_len = plain_len / 2;
2094 }
2095 }
2096 }
2097
2098 // if enabled, update also the potfile
2099
2100 if (pot_fp)
2101 {
2102 lock_file (pot_fp);
2103
2104 fprintf (pot_fp, "%s:", out_buf);
2105
2106 format_plain (pot_fp, plain_ptr, plain_len, 1);
2107
2108 fputc ('\n', pot_fp);
2109
2110 fflush (pot_fp);
2111
2112 unlock_file (pot_fp);
2113 }
2114
2115 // outfile
2116
2117 FILE *out_fp = NULL;
2118
2119 if (outfile != NULL)
2120 {
2121 if ((out_fp = fopen (outfile, "ab")) == NULL)
2122 {
2123 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2124
2125 out_fp = stdout;
2126 }
2127 lock_file (out_fp);
2128 }
2129 else
2130 {
2131 out_fp = stdout;
2132
2133 if (quiet == 0) clear_prompt ();
2134 }
2135
2136 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2137
2138 if (outfile != NULL)
2139 {
2140 if (out_fp != stdout)
2141 {
2142 fclose (out_fp);
2143 }
2144 }
2145 else
2146 {
2147 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2148 {
2149 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2150 {
2151 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2152 if (quiet == 0) fflush (stdout);
2153 }
2154 }
2155 }
2156
2157 // loopback
2158
2159 if (loopback)
2160 {
2161 char *loopback_file = data.loopback_file;
2162
2163 FILE *fb_fp = NULL;
2164
2165 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2166 {
2167 lock_file (fb_fp);
2168
2169 format_plain (fb_fp, plain_ptr, plain_len, 1);
2170
2171 fputc ('\n', fb_fp);
2172
2173 fclose (fb_fp);
2174 }
2175 }
2176
2177 // (rule) debug mode
2178
2179 // the next check implies that:
2180 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2181 // - debug_mode > 0
2182
2183 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2184 {
2185 if (debug_rule_len < 0) debug_rule_len = 0;
2186
2187 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2188
2189 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2190
2191 if ((quiet == 0) && (debug_file == NULL))
2192 {
2193 fprintf (stdout, "%s", PROMPT);
2194 fflush (stdout);
2195 }
2196 }
2197 }
2198
2199 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2200 {
2201 salt_t *salt_buf = &data.salts_buf[salt_pos];
2202
2203 int found = 0;
2204
2205 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);
2206
2207 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2208
2209 if (found == 1)
2210 {
2211 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2212
2213 log_info_nn ("");
2214
2215 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);
2216
2217 uint cpt_cracked = 0;
2218
2219 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2220 {
2221 uint idx = salt_buf->digests_offset + digest_pos;
2222
2223 if (data.digests_shown_tmp[idx] == 0) continue;
2224
2225 if (data.digests_shown[idx] == 1) continue;
2226
2227 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2228 {
2229 data.digests_shown[idx] = 1;
2230
2231 data.digests_done++;
2232
2233 cpt_cracked++;
2234
2235 salt_buf->digests_done++;
2236
2237 if (salt_buf->digests_done == salt_buf->digests_cnt)
2238 {
2239 data.salts_shown[salt_pos] = 1;
2240
2241 data.salts_done++;
2242 }
2243 }
2244
2245 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2246
2247 check_hash (device_param, salt_pos, digest_pos);
2248 }
2249
2250 if (cpt_cracked > 0)
2251 {
2252 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2253 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2254
2255 data.cpt_pos++;
2256
2257 data.cpt_total += cpt_cracked;
2258
2259 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2260 }
2261
2262 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2263 {
2264 // we need to reset cracked state on the device
2265 // otherwise host thinks again and again the hash was cracked
2266 // and returns invalid password each time
2267
2268 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2269
2270 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);
2271 }
2272
2273 memset (device_param->result, 0, device_param->size_results);
2274
2275 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);
2276 }
2277 }
2278
2279 static void save_hash ()
2280 {
2281 char *hashfile = data.hashfile;
2282
2283 char new_hashfile[256] = { 0 };
2284 char old_hashfile[256] = { 0 };
2285
2286 snprintf (new_hashfile, 255, "%s.new", hashfile);
2287 snprintf (old_hashfile, 255, "%s.old", hashfile);
2288
2289 unlink (new_hashfile);
2290
2291 char separator = data.separator;
2292
2293 FILE *fp = fopen (new_hashfile, "wb");
2294
2295 if (fp == NULL)
2296 {
2297 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2298
2299 exit (-1);
2300 }
2301
2302 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2303 {
2304 if (data.salts_shown[salt_pos] == 1) continue;
2305
2306 salt_t *salt_buf = &data.salts_buf[salt_pos];
2307
2308 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2309 {
2310 uint idx = salt_buf->digests_offset + digest_pos;
2311
2312 if (data.digests_shown[idx] == 1) continue;
2313
2314 if (data.hash_mode != 2500)
2315 {
2316 char out_buf[4096] = { 0 };
2317
2318 if (data.username == 1)
2319 {
2320 user_t *user = data.hash_info[idx]->user;
2321
2322 uint i;
2323
2324 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2325
2326 fputc (separator, fp);
2327 }
2328
2329 ascii_digest (out_buf, salt_pos, digest_pos);
2330
2331 fputs (out_buf, fp);
2332
2333 log_out (fp, "");
2334 }
2335 else
2336 {
2337 hccap_t hccap;
2338
2339 to_hccap_t (&hccap, salt_pos, digest_pos);
2340
2341 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2342 }
2343 }
2344 }
2345
2346 fflush (fp);
2347
2348 fclose (fp);
2349
2350 unlink (old_hashfile);
2351
2352 if (rename (hashfile, old_hashfile) != 0)
2353 {
2354 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2355
2356 exit (-1);
2357 }
2358
2359 unlink (hashfile);
2360
2361 if (rename (new_hashfile, hashfile) != 0)
2362 {
2363 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2364
2365 exit (-1);
2366 }
2367
2368 unlink (old_hashfile);
2369 }
2370
2371 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2372 {
2373 // function called only in case kernel_power_all > words_left
2374
2375 float kernel_power_div = (float) (total_left) / kernel_power_all;
2376
2377 kernel_power_div += kernel_power_div / 100;
2378
2379 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2380
2381 while (kernel_power_new < total_left)
2382 {
2383 kernel_power_div += kernel_power_div / 100;
2384
2385 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2386 }
2387
2388 if (data.quiet == 0)
2389 {
2390 clear_prompt ();
2391
2392 log_info ("");
2393
2394 log_info ("INFO: approaching final keyspace, workload adjusted");
2395
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2450 }
2451 else
2452 {
2453 const size_t global_work_size[3] = { num_elements, 1, 1 };
2454 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2455
2456 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2457
2458 if (rc != CL_SUCCESS)
2459 {
2460 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2461
2462 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2463 }
2464 }
2465
2466 hc_clFlush (data.ocl, device_param->command_queue);
2467
2468 hc_clWaitForEvents (data.ocl, 1, &event);
2469
2470 if (event_update)
2471 {
2472 cl_ulong time_start;
2473 cl_ulong time_end;
2474
2475 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2476 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2477
2478 const double exec_time = (time_end - time_start) / 1000000.0;
2479
2480 uint exec_pos = device_param->exec_pos;
2481
2482 device_param->exec_ms[exec_pos] = exec_time;
2483
2484 exec_pos++;
2485
2486 if (exec_pos == EXEC_CACHE)
2487 {
2488 exec_pos = 0;
2489 }
2490
2491 device_param->exec_pos = exec_pos;
2492 }
2493
2494 hc_clReleaseEvent (data.ocl, event);
2495
2496 hc_clFinish (data.ocl, device_param->command_queue);
2497 }
2498
2499 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2500 {
2501 uint num_elements = num;
2502
2503 switch (kern_run)
2504 {
2505 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2506 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2507 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2508 }
2509
2510 // causes problems with special threads like in bcrypt
2511 // const uint kernel_threads = device_param->kernel_threads;
2512
2513 const uint kernel_threads = KERNEL_THREADS;
2514
2515 while (num_elements % kernel_threads) num_elements++;
2516
2517 cl_kernel kernel = NULL;
2518
2519 switch (kern_run)
2520 {
2521 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2522 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2523 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2524 }
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2529 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2530 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2531 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2532 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2533 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2534 break;
2535 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2536 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2537 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2538 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2539 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2540 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2541 break;
2542 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2543 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2544 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2545 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2546 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2547 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2548 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2549 break;
2550 }
2551
2552 const size_t global_work_size[3] = { num_elements, 1, 1 };
2553 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2554
2555 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2556
2557 if (rc != CL_SUCCESS)
2558 {
2559 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2562 }
2563
2564 hc_clFlush (data.ocl, device_param->command_queue);
2565
2566 hc_clFinish (data.ocl, device_param->command_queue);
2567 }
2568
2569 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2570 {
2571 uint num_elements = num;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_tb;
2578
2579 const size_t global_work_size[3] = { num_elements, 1, 1 };
2580 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2581
2582 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2583
2584 if (rc != CL_SUCCESS)
2585 {
2586 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2587
2588 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2589 }
2590
2591 hc_clFlush (data.ocl, device_param->command_queue);
2592
2593 hc_clFinish (data.ocl, device_param->command_queue);
2594 }
2595
2596 static void run_kernel_tm (hc_device_param_t *device_param)
2597 {
2598 const uint num_elements = 1024; // fixed
2599
2600 const uint kernel_threads = 32;
2601
2602 cl_kernel kernel = device_param->kernel_tm;
2603
2604 const size_t global_work_size[3] = { num_elements, 1, 1 };
2605 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2606
2607 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2608
2609 if (rc != CL_SUCCESS)
2610 {
2611 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2612
2613 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2614 }
2615
2616 hc_clFlush (data.ocl, device_param->command_queue);
2617
2618 hc_clFinish (data.ocl, device_param->command_queue);
2619 }
2620
2621 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2622 {
2623 uint num_elements = num;
2624
2625 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2626 device_param->kernel_params_amp_buf32[6] = num_elements;
2627
2628 // causes problems with special threads like in bcrypt
2629 // const uint kernel_threads = device_param->kernel_threads;
2630
2631 const uint kernel_threads = KERNEL_THREADS;
2632
2633 while (num_elements % kernel_threads) num_elements++;
2634
2635 cl_kernel kernel = device_param->kernel_amp;
2636
2637 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2638 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2639
2640 const size_t global_work_size[3] = { num_elements, 1, 1 };
2641 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2642
2643 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2644
2645 if (rc != CL_SUCCESS)
2646 {
2647 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2648
2649 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2650 }
2651
2652 hc_clFlush (data.ocl, device_param->command_queue);
2653
2654 hc_clFinish (data.ocl, device_param->command_queue);
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2658 {
2659 int rc = -1;
2660
2661 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2662 {
2663 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2664
2665 const cl_uchar zero = 0;
2666
2667 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2668 }
2669
2670 if (rc != 0)
2671 {
2672 // NOTE: clEnqueueFillBuffer () always fails with -59
2673 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2674 // How's that possible, OpenCL 1.2 support is advertised??
2675 // We need to workaround...
2676
2677 #define FILLSZ 0x100000
2678
2679 char *tmp = (char *) mymalloc (FILLSZ);
2680
2681 for (uint i = 0; i < size; i += FILLSZ)
2682 {
2683 const int left = size - i;
2684
2685 const int fillsz = MIN (FILLSZ, left);
2686
2687 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2688 }
2689
2690 myfree (tmp);
2691 }
2692 }
2693
2694 static int run_rule_engine (const int rule_len, const char *rule_buf)
2695 {
2696 if (rule_len == 0)
2697 {
2698 return 0;
2699 }
2700 else if (rule_len == 1)
2701 {
2702 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2703 }
2704
2705 return 1;
2706 }
2707
2708 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2709 {
2710 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2711 {
2712 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);
2713 }
2714 else if (data.attack_kern == ATTACK_KERN_COMBI)
2715 {
2716 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);
2717 }
2718 else if (data.attack_kern == ATTACK_KERN_BF)
2719 {
2720 const u64 off = device_param->words_off;
2721
2722 device_param->kernel_params_mp_l_buf64[3] = off;
2723
2724 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2725 }
2726 }
2727
2728 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2729 {
2730 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2731
2732 device_param->kernel_params_buf32[26] = kernel_loops;
2733 device_param->kernel_params_buf32[27] = kernel_loops;
2734
2735 // caching run
2736
2737 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2738 {
2739 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2740 }
2741 else
2742 {
2743 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2744 }
2745
2746 // now user repeats
2747
2748 for (int i = 0; i < repeat; i++)
2749 {
2750 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2751 {
2752 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2753 }
2754 else
2755 {
2756 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2757 }
2758 }
2759
2760 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2761
2762 return exec_ms_prev;
2763 }
2764
2765 static void autotune (hc_device_param_t *device_param)
2766 {
2767 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2768
2769 u32 kernel_loops_min = device_param->kernel_loops_min;
2770 u32 kernel_loops_max = device_param->kernel_loops_max;
2771
2772 u32 kernel_accel_min = device_param->kernel_accel_min;
2773 u32 kernel_accel_max = device_param->kernel_accel_max;
2774
2775 u32 kernel_loops = kernel_loops_min;
2776 u32 kernel_accel = kernel_accel_min;
2777
2778 // init some fake words
2779
2780 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
2781
2782 for (u32 i = 0; i < kernel_power_max; i++)
2783 {
2784 device_param->pws_buf[i].pw_len = 8;
2785 }
2786
2787 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2788 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2789
2790 // steps for loops
2791
2792 #define STEPS_LOOPS_CNT 15
2793
2794 u32 steps_loops[STEPS_LOOPS_CNT];
2795
2796 steps_loops[ 0] = 1;
2797 steps_loops[ 1] = 2;
2798 steps_loops[ 2] = 4;
2799 steps_loops[ 3] = 8;
2800 steps_loops[ 4] = 16;
2801 steps_loops[ 5] = 32;
2802 steps_loops[ 6] = 64;
2803 steps_loops[ 7] = 100;
2804 steps_loops[ 8] = 128;
2805 steps_loops[ 9] = 200;
2806 steps_loops[10] = 256;
2807 steps_loops[11] = 500;
2808 steps_loops[12] = 512;
2809 steps_loops[13] = 1000;
2810 steps_loops[14] = 1024;
2811
2812 // steps for accel
2813
2814 #define STEPS_ACCEL_CNT 13
2815
2816 u32 steps_accel[STEPS_ACCEL_CNT];
2817
2818 steps_accel[ 0] = 1;
2819 steps_accel[ 1] = 2;
2820 steps_accel[ 2] = 4;
2821 steps_accel[ 3] = 8;
2822 steps_accel[ 4] = 16;
2823 steps_accel[ 5] = 32;
2824 steps_accel[ 6] = 64;
2825 steps_accel[ 7] = 128;
2826 steps_accel[ 8] = 256;
2827 steps_accel[ 9] = 384;
2828 steps_accel[10] = 512;
2829 steps_accel[11] = 768;
2830 steps_accel[12] = 1024;
2831
2832 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2833
2834 u32 kernel_loops_tmp;
2835
2836 for (kernel_loops_tmp = MIN (kernel_loops_max, 200); kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2837 {
2838 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2839
2840 if (exec_ms < target_ms) break;
2841
2842 if (kernel_loops_tmp == kernel_loops_min) break;
2843 }
2844
2845 // kernel-accel
2846
2847 double e_best = 0;
2848
2849 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2850 {
2851 const u32 kernel_accel_try = steps_accel[i];
2852
2853 if (kernel_accel_try < kernel_accel_min) continue;
2854 if (kernel_accel_try > kernel_accel_max) break;
2855
2856 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2857
2858 if (exec_ms > target_ms) break;
2859
2860 const double e = kernel_accel_try / exec_ms;
2861
2862 if (e > e_best)
2863 {
2864 kernel_accel = kernel_accel_try;
2865
2866 e_best = e;
2867 }
2868 }
2869
2870 // kernel-loops final
2871
2872 e_best = 0;
2873
2874 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2875 {
2876 const u32 kernel_loops_try = steps_loops[i];
2877
2878 if (kernel_loops_try < kernel_loops_min) continue;
2879 if (kernel_loops_try > kernel_loops_max) break;
2880
2881 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2882
2883 if (exec_ms > target_ms) break;
2884
2885 const double e = kernel_loops_try / exec_ms;
2886
2887 if (e > e_best)
2888 {
2889 kernel_loops = kernel_loops_try;
2890
2891 e_best = e;
2892 }
2893 }
2894
2895 // final balance
2896
2897 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2898
2899 e_best = exec_ms;
2900
2901 u32 kernel_accel_try = kernel_accel;
2902 u32 kernel_loops_try = kernel_loops;
2903
2904 for (int i = 0; i < 2; i++)
2905 {
2906 kernel_accel_try >>= 1;
2907 kernel_loops_try <<= 1;
2908
2909 if (kernel_accel_try < kernel_accel_min) break;
2910 if (kernel_loops_try > kernel_loops_max) break;
2911
2912 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2913
2914 if (exec_ms > e_best) break;
2915
2916 kernel_accel = kernel_accel_try;
2917 kernel_loops = kernel_loops_try;
2918
2919 e_best = exec_ms;
2920 }
2921
2922 kernel_accel_try = kernel_accel;
2923 kernel_loops_try = kernel_loops;
2924
2925 for (int i = 0; i < 2; i++)
2926 {
2927 kernel_accel_try <<= 1;
2928 kernel_loops_try >>= 1;
2929
2930 if (kernel_accel_try > kernel_accel_max) break;
2931 if (kernel_loops_try < kernel_loops_min) break;
2932
2933 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2934
2935 if (exec_ms > e_best) break;
2936
2937 kernel_accel = kernel_accel_try;
2938 kernel_loops = kernel_loops_try;
2939
2940 e_best = exec_ms;
2941 }
2942
2943 // reset timer
2944
2945 device_param->exec_pos = 0;
2946
2947 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2948
2949 // reset fake words
2950
2951 for (u32 i = 0; i < kernel_power_max; i++)
2952 {
2953 device_param->pws_buf[i].pw_len = 0;
2954 }
2955
2956 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2957 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2958
2959 // store
2960
2961 device_param->kernel_loops = kernel_loops;
2962 device_param->kernel_accel = kernel_accel;
2963
2964 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2965
2966 device_param->kernel_power = kernel_power;
2967
2968 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
2969 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
2970 log_info ("");
2971 }
2972
2973 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2974 {
2975 // init speed timer
2976
2977 uint speed_pos = device_param->speed_pos;
2978
2979 #ifdef _POSIX
2980 if (device_param->timer_speed.tv_sec == 0)
2981 {
2982 hc_timer_set (&device_param->timer_speed);
2983 }
2984 #endif
2985
2986 #ifdef _WIN
2987 if (device_param->timer_speed.QuadPart == 0)
2988 {
2989 hc_timer_set (&device_param->timer_speed);
2990 }
2991 #endif
2992
2993 // find higest password length, this is for optimization stuff
2994
2995 uint highest_pw_len = 0;
2996
2997 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2998 {
2999 }
3000 else if (data.attack_kern == ATTACK_KERN_COMBI)
3001 {
3002 }
3003 else if (data.attack_kern == ATTACK_KERN_BF)
3004 {
3005 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3006 + device_param->kernel_params_mp_l_buf32[5];
3007 }
3008
3009 // bitslice optimization stuff
3010
3011 if (data.attack_mode == ATTACK_MODE_BF)
3012 {
3013 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3014 {
3015 run_kernel_tb (device_param, pws_cnt);
3016 }
3017 }
3018
3019 // iteration type
3020
3021 uint innerloop_step = 0;
3022 uint innerloop_cnt = 0;
3023
3024 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3025 else innerloop_step = 1;
3026
3027 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3028 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3029 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3030
3031 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3032
3033 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3034 {
3035 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3036
3037 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3038
3039 if (data.devices_status == STATUS_CRACKED) break;
3040 if (data.devices_status == STATUS_ABORTED) break;
3041 if (data.devices_status == STATUS_QUIT) break;
3042 if (data.devices_status == STATUS_BYPASS) break;
3043
3044 if (data.salts_shown[salt_pos] == 1) continue;
3045
3046 salt_t *salt_buf = &data.salts_buf[salt_pos];
3047
3048 device_param->kernel_params_buf32[24] = salt_pos;
3049 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3050 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3051
3052 FILE *combs_fp = device_param->combs_fp;
3053
3054 if (data.attack_mode == ATTACK_MODE_COMBI)
3055 {
3056 rewind (combs_fp);
3057 }
3058
3059 // innerloops
3060
3061 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3062 {
3063 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3064
3065 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3066
3067 if (data.devices_status == STATUS_CRACKED) break;
3068 if (data.devices_status == STATUS_ABORTED) break;
3069 if (data.devices_status == STATUS_QUIT) break;
3070 if (data.devices_status == STATUS_BYPASS) break;
3071
3072 uint innerloop_left = innerloop_cnt - innerloop_pos;
3073
3074 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3075
3076 device_param->innerloop_pos = innerloop_pos;
3077 device_param->innerloop_left = innerloop_left;
3078
3079 device_param->kernel_params_buf32[27] = innerloop_left;
3080
3081 // i think we can get rid of this
3082 if (innerloop_left == 0)
3083 {
3084 puts ("bug, how should this happen????\n");
3085
3086 continue;
3087 }
3088
3089 // initialize amplifiers
3090
3091 if (data.attack_mode == ATTACK_MODE_COMBI)
3092 {
3093 char line_buf[BUFSIZ] = { 0 };
3094
3095 uint i = 0;
3096
3097 while (i < innerloop_left)
3098 {
3099 if (feof (combs_fp)) break;
3100
3101 int line_len = fgetl (combs_fp, line_buf);
3102
3103 if (line_len >= PW_MAX1) continue;
3104
3105 line_len = convert_from_hex (line_buf, line_len);
3106
3107 char *line_buf_new = line_buf;
3108
3109 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3110 {
3111 char rule_buf_out[BLOCK_SIZE] = { 0 };
3112
3113 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3114
3115 if (rule_len_out < 0)
3116 {
3117 data.words_progress_rejected[salt_pos] += pw_cnt;
3118
3119 continue;
3120 }
3121
3122 line_len = rule_len_out;
3123
3124 line_buf_new = rule_buf_out;
3125 }
3126
3127 line_len = MIN (line_len, PW_DICTMAX);
3128
3129 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3130
3131 memcpy (ptr, line_buf_new, line_len);
3132
3133 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3134
3135 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3136 {
3137 uppercase (ptr, line_len);
3138 }
3139
3140 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3141 {
3142 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3143 {
3144 ptr[line_len] = 0x80;
3145 }
3146
3147 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3148 {
3149 ptr[line_len] = 0x01;
3150 }
3151 }
3152
3153 device_param->combs_buf[i].pw_len = line_len;
3154
3155 i++;
3156 }
3157
3158 for (uint j = i; j < innerloop_left; j++)
3159 {
3160 device_param->combs_buf[j].i[0] = 0;
3161 device_param->combs_buf[j].i[1] = 0;
3162 device_param->combs_buf[j].i[2] = 0;
3163 device_param->combs_buf[j].i[3] = 0;
3164 device_param->combs_buf[j].i[4] = 0;
3165 device_param->combs_buf[j].i[5] = 0;
3166 device_param->combs_buf[j].i[6] = 0;
3167 device_param->combs_buf[j].i[7] = 0;
3168
3169 device_param->combs_buf[j].pw_len = 0;
3170 }
3171
3172 innerloop_left = i;
3173 }
3174 else if (data.attack_mode == ATTACK_MODE_BF)
3175 {
3176 u64 off = innerloop_pos;
3177
3178 device_param->kernel_params_mp_r_buf64[3] = off;
3179
3180 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3181 }
3182 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3183 {
3184 u64 off = innerloop_pos;
3185
3186 device_param->kernel_params_mp_buf64[3] = off;
3187
3188 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3189 }
3190 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3191 {
3192 u64 off = innerloop_pos;
3193
3194 device_param->kernel_params_mp_buf64[3] = off;
3195
3196 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3197 }
3198
3199 // copy amplifiers
3200
3201 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3202 {
3203 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);
3204 }
3205 else if (data.attack_mode == ATTACK_MODE_COMBI)
3206 {
3207 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);
3208 }
3209 else if (data.attack_mode == ATTACK_MODE_BF)
3210 {
3211 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);
3212 }
3213 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3214 {
3215 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);
3216 }
3217 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3218 {
3219 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);
3220 }
3221
3222 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3223 {
3224 if (data.attack_mode == ATTACK_MODE_BF)
3225 {
3226 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3227 {
3228 const uint size_tm = 32 * sizeof (bs_word_t);
3229
3230 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3231
3232 run_kernel_tm (device_param);
3233
3234 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);
3235 }
3236 }
3237
3238 if (highest_pw_len < 16)
3239 {
3240 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3241 }
3242 else if (highest_pw_len < 32)
3243 {
3244 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3245 }
3246 else
3247 {
3248 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3249 }
3250 }
3251 else
3252 {
3253 run_kernel_amp (device_param, pws_cnt);
3254
3255 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3256
3257 if (data.opts_type & OPTS_TYPE_HOOK12)
3258 {
3259 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3260 }
3261
3262 uint iter = salt_buf->salt_iter;
3263
3264 uint loop_step = device_param->kernel_loops;
3265
3266 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
3267 {
3268 uint loop_left = iter - loop_pos;
3269
3270 loop_left = MIN (loop_left, loop_step);
3271
3272 device_param->kernel_params_buf32[25] = loop_pos;
3273 device_param->kernel_params_buf32[26] = loop_left;
3274
3275 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3276
3277 if (data.devices_status == STATUS_CRACKED) break;
3278 if (data.devices_status == STATUS_ABORTED) break;
3279 if (data.devices_status == STATUS_QUIT) break;
3280 }
3281
3282 if (data.opts_type & OPTS_TYPE_HOOK23)
3283 {
3284 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3285
3286 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);
3287
3288 // do something with data
3289
3290 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);
3291 }
3292
3293 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3294 }
3295
3296 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3297
3298 if (data.devices_status == STATUS_CRACKED) break;
3299 if (data.devices_status == STATUS_ABORTED) break;
3300 if (data.devices_status == STATUS_QUIT) break;
3301
3302 /**
3303 * result
3304 */
3305
3306 hc_thread_mutex_lock (mux_display);
3307
3308 check_cracked (device_param, salt_pos);
3309
3310 hc_thread_mutex_unlock (mux_display);
3311
3312 /**
3313 * progress
3314 */
3315
3316 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3317
3318 hc_thread_mutex_lock (mux_counter);
3319
3320 data.words_progress_done[salt_pos] += perf_sum_all;
3321
3322 hc_thread_mutex_unlock (mux_counter);
3323
3324 /**
3325 * speed
3326 */
3327
3328 float speed_ms;
3329
3330 hc_timer_get (device_param->timer_speed, speed_ms);
3331
3332 hc_timer_set (&device_param->timer_speed);
3333
3334 hc_thread_mutex_lock (mux_display);
3335
3336 device_param->speed_cnt[speed_pos] = perf_sum_all;
3337
3338 device_param->speed_ms[speed_pos] = speed_ms;
3339
3340 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3341
3342 hc_thread_mutex_unlock (mux_display);
3343
3344 speed_pos++;
3345
3346 if (speed_pos == SPEED_CACHE)
3347 {
3348 speed_pos = 0;
3349 }
3350
3351 /**
3352 * benchmark
3353 */
3354
3355 if (data.benchmark == 1)
3356 {
3357 data.devices_status = STATUS_BYPASS;
3358 };
3359 }
3360 }
3361
3362 device_param->speed_pos = speed_pos;
3363 }
3364
3365 static void load_segment (wl_data_t *wl_data, FILE *fd)
3366 {
3367 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3368
3369 wl_data->pos = 0;
3370
3371 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3372
3373 wl_data->buf[wl_data->cnt] = 0;
3374
3375 if (wl_data->cnt == 0) return;
3376
3377 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3378
3379 while (!feof (fd))
3380 {
3381 if (wl_data->cnt == wl_data->avail)
3382 {
3383 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3384
3385 wl_data->avail += wl_data->incr;
3386 }
3387
3388 const int c = fgetc (fd);
3389
3390 if (c == EOF) break;
3391
3392 wl_data->buf[wl_data->cnt] = (char) c;
3393
3394 wl_data->cnt++;
3395
3396 if (c == '\n') break;
3397 }
3398
3399 // ensure stream ends with a newline
3400
3401 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3402 {
3403 wl_data->cnt++;
3404
3405 wl_data->buf[wl_data->cnt - 1] = '\n';
3406 }
3407
3408 return;
3409 }
3410
3411 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3412 {
3413 char *ptr = buf;
3414
3415 for (u32 i = 0; i < sz; i++, ptr++)
3416 {
3417 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3418
3419 if (i == 7)
3420 {
3421 *off = i;
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 if (*ptr != '\n') continue;
3428
3429 *off = i + 1;
3430
3431 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3432
3433 *len = i;
3434
3435 return;
3436 }
3437
3438 *off = sz;
3439 *len = sz;
3440 }
3441
3442 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3443 {
3444 char *ptr = buf;
3445
3446 for (u32 i = 0; i < sz; i++, ptr++)
3447 {
3448 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3449
3450 if (*ptr != '\n') continue;
3451
3452 *off = i + 1;
3453
3454 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3455
3456 *len = i;
3457
3458 return;
3459 }
3460
3461 *off = sz;
3462 *len = sz;
3463 }
3464
3465 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3466 {
3467 char *ptr = buf;
3468
3469 for (u32 i = 0; i < sz; i++, ptr++)
3470 {
3471 if (*ptr != '\n') continue;
3472
3473 *off = i + 1;
3474
3475 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3476
3477 *len = i;
3478
3479 return;
3480 }
3481
3482 *off = sz;
3483 *len = sz;
3484 }
3485
3486 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3487 {
3488 while (wl_data->pos < wl_data->cnt)
3489 {
3490 uint off;
3491 uint len;
3492
3493 char *ptr = wl_data->buf + wl_data->pos;
3494
3495 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3496
3497 wl_data->pos += off;
3498
3499 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3500 {
3501 char rule_buf_out[BLOCK_SIZE] = { 0 };
3502
3503 int rule_len_out = -1;
3504
3505 if (len < BLOCK_SIZE)
3506 {
3507 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3508 }
3509
3510 if (rule_len_out < 0)
3511 {
3512 continue;
3513 }
3514
3515 if (rule_len_out > PW_MAX)
3516 {
3517 continue;
3518 }
3519 }
3520 else
3521 {
3522 if (len > PW_MAX)
3523 {
3524 continue;
3525 }
3526 }
3527
3528 *out_buf = ptr;
3529 *out_len = len;
3530
3531 return;
3532 }
3533
3534 if (feof (fd))
3535 {
3536 fprintf (stderr, "bug!!\n");
3537
3538 return;
3539 }
3540
3541 load_segment (wl_data, fd);
3542
3543 get_next_word (wl_data, fd, out_buf, out_len);
3544 }
3545
3546 #ifdef _POSIX
3547 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3548 #endif
3549
3550 #ifdef _WIN
3551 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3552 #endif
3553 {
3554 hc_signal (NULL);
3555
3556 dictstat_t d;
3557
3558 d.cnt = 0;
3559
3560 #ifdef _POSIX
3561 fstat (fileno (fd), &d.stat);
3562 #endif
3563
3564 #ifdef _WIN
3565 _fstat64 (fileno (fd), &d.stat);
3566 #endif
3567
3568 d.stat.st_mode = 0;
3569 d.stat.st_nlink = 0;
3570 d.stat.st_uid = 0;
3571 d.stat.st_gid = 0;
3572 d.stat.st_rdev = 0;
3573 d.stat.st_atime = 0;
3574
3575 #ifdef _POSIX
3576 d.stat.st_blksize = 0;
3577 d.stat.st_blocks = 0;
3578 #endif
3579
3580 if (d.stat.st_size == 0) return 0;
3581
3582 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3583
3584 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3585 {
3586 if (d_cache)
3587 {
3588 u64 cnt = d_cache->cnt;
3589
3590 u64 keyspace = cnt;
3591
3592 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3593 {
3594 keyspace *= data.kernel_rules_cnt;
3595 }
3596 else if (data.attack_kern == ATTACK_KERN_COMBI)
3597 {
3598 keyspace *= data.combs_cnt;
3599 }
3600
3601 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);
3602 if (data.quiet == 0) log_info ("");
3603
3604 hc_signal (sigHandler_default);
3605
3606 return (keyspace);
3607 }
3608 }
3609
3610 time_t now = 0;
3611 time_t prev = 0;
3612
3613 u64 comp = 0;
3614 u64 cnt = 0;
3615 u64 cnt2 = 0;
3616
3617 while (!feof (fd))
3618 {
3619 load_segment (wl_data, fd);
3620
3621 comp += wl_data->cnt;
3622
3623 u32 i = 0;
3624
3625 while (i < wl_data->cnt)
3626 {
3627 u32 len;
3628 u32 off;
3629
3630 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3631
3632 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3633 {
3634 char rule_buf_out[BLOCK_SIZE] = { 0 };
3635
3636 int rule_len_out = -1;
3637
3638 if (len < BLOCK_SIZE)
3639 {
3640 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3641 }
3642
3643 if (rule_len_out < 0)
3644 {
3645 len = PW_MAX1;
3646 }
3647 else
3648 {
3649 len = rule_len_out;
3650 }
3651 }
3652
3653 if (len < PW_MAX1)
3654 {
3655 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3656 {
3657 cnt += data.kernel_rules_cnt;
3658 }
3659 else if (data.attack_kern == ATTACK_KERN_COMBI)
3660 {
3661 cnt += data.combs_cnt;
3662 }
3663
3664 d.cnt++;
3665 }
3666
3667 i += off;
3668
3669 cnt2++;
3670 }
3671
3672 time (&now);
3673
3674 if ((now - prev) == 0) continue;
3675
3676 float percent = (float) comp / (float) d.stat.st_size;
3677
3678 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);
3679
3680 time (&prev);
3681 }
3682
3683 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);
3684 if (data.quiet == 0) log_info ("");
3685
3686 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3687
3688 hc_signal (sigHandler_default);
3689
3690 return (cnt);
3691 }
3692
3693 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3694 {
3695 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3696 }
3697
3698 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3699 {
3700 if (data.devices_status == STATUS_BYPASS) return 0;
3701
3702 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3703
3704 uint cache_cnt = pw_cache->cnt;
3705
3706 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3707
3708 memcpy (pw_hc1, pw_buf, pw_len);
3709
3710 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3711
3712 uint pws_cnt = device_param->pws_cnt;
3713
3714 cache_cnt++;
3715
3716 pw_t *pw = device_param->pws_buf + pws_cnt;
3717
3718 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3719
3720 pw->pw_len = pw_len;
3721
3722 pws_cnt++;
3723
3724 device_param->pws_cnt = pws_cnt;
3725 device_param->pw_cnt = pws_cnt * 1;
3726
3727 cache_cnt = 0;
3728
3729 pw_cache->cnt = cache_cnt;
3730
3731 return pws_cnt;
3732 }
3733
3734 static void *thread_monitor (void *p)
3735 {
3736 uint runtime_check = 0;
3737 uint remove_check = 0;
3738 uint status_check = 0;
3739 uint restore_check = 0;
3740
3741 uint restore_left = data.restore_timer;
3742 uint remove_left = data.remove_timer;
3743 uint status_left = data.status_timer;
3744
3745 #ifdef HAVE_HWMON
3746 uint hwmon_check = 0;
3747
3748 // these variables are mainly used for fan control (AMD only)
3749
3750 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3751
3752 // temperature controller "loopback" values
3753
3754 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3755 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756
3757 #ifdef HAVE_ADL
3758 int temp_threshold = 1; // degrees celcius
3759
3760 int fan_speed_min = 15; // in percentage
3761 int fan_speed_max = 100;
3762 #endif // HAVE_ADL
3763
3764 time_t last_temp_check_time;
3765 #endif // HAVE_HWMON
3766
3767 uint sleep_time = 1;
3768
3769 if (data.runtime)
3770 {
3771 runtime_check = 1;
3772 }
3773
3774 if (data.restore_timer)
3775 {
3776 restore_check = 1;
3777 }
3778
3779 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3780 {
3781 remove_check = 1;
3782 }
3783
3784 if (data.status == 1)
3785 {
3786 status_check = 1;
3787 }
3788
3789 #ifdef HAVE_HWMON
3790 if (data.gpu_temp_disable == 0)
3791 {
3792 time (&last_temp_check_time);
3793
3794 hwmon_check = 1;
3795 }
3796 #endif
3797
3798 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3799 {
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 0)
3802 #endif
3803 return (p);
3804 }
3805
3806 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3807 {
3808 hc_sleep (sleep_time);
3809
3810 if (data.devices_status != STATUS_RUNNING) continue;
3811
3812 #ifdef HAVE_HWMON
3813 if (hwmon_check == 1)
3814 {
3815 hc_thread_mutex_lock (mux_adl);
3816
3817 time_t temp_check_time;
3818
3819 time (&temp_check_time);
3820
3821 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3822
3823 if (Ta == 0) Ta = 1;
3824
3825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3826 {
3827 hc_device_param_t *device_param = &data.devices_param[device_id];
3828
3829 if (device_param->skipped) continue;
3830
3831 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3832
3833 const int temperature = hm_get_temperature_with_device_id (device_id);
3834
3835 if (temperature > (int) data.gpu_temp_abort)
3836 {
3837 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3838
3839 if (data.devices_status != STATUS_QUIT) myabort ();
3840
3841 break;
3842 }
3843
3844 #ifdef HAVE_ADL
3845 const int gpu_temp_retain = data.gpu_temp_retain;
3846
3847 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3848 {
3849 if (data.hm_device[device_id].fan_supported == 1)
3850 {
3851 int temp_cur = temperature;
3852
3853 int temp_diff_new = gpu_temp_retain - temp_cur;
3854
3855 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3856
3857 // calculate Ta value (time difference in seconds between the last check and this check)
3858
3859 last_temp_check_time = temp_check_time;
3860
3861 float Kp = 1.8;
3862 float Ki = 0.005;
3863 float Kd = 6;
3864
3865 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3866
3867 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3868
3869 if (abs (fan_diff_required) >= temp_threshold)
3870 {
3871 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3872
3873 int fan_speed_level = fan_speed_cur;
3874
3875 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3876
3877 int fan_speed_new = fan_speed_level - fan_diff_required;
3878
3879 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3880 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3881
3882 if (fan_speed_new != fan_speed_cur)
3883 {
3884 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3885 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3886
3887 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3888 {
3889 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3890
3891 fan_speed_chgd[device_id] = 1;
3892 }
3893
3894 temp_diff_old[device_id] = temp_diff_new;
3895 }
3896 }
3897 }
3898 }
3899 #endif // HAVE_ADL
3900 }
3901
3902 hc_thread_mutex_unlock (mux_adl);
3903 }
3904 #endif // HAVE_HWMON
3905
3906 if (restore_check == 1)
3907 {
3908 restore_left--;
3909
3910 if (restore_left == 0)
3911 {
3912 if (data.restore_disable == 0) cycle_restore ();
3913
3914 restore_left = data.restore_timer;
3915 }
3916 }
3917
3918 if ((runtime_check == 1) && (data.runtime_start > 0))
3919 {
3920 time_t runtime_cur;
3921
3922 time (&runtime_cur);
3923
3924 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3925
3926 if (runtime_left <= 0)
3927 {
3928 if (data.benchmark == 0)
3929 {
3930 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3931 }
3932
3933 if (data.devices_status != STATUS_QUIT) myabort ();
3934 }
3935 }
3936
3937 if (remove_check == 1)
3938 {
3939 remove_left--;
3940
3941 if (remove_left == 0)
3942 {
3943 if (data.digests_saved != data.digests_done)
3944 {
3945 data.digests_saved = data.digests_done;
3946
3947 save_hash ();
3948 }
3949
3950 remove_left = data.remove_timer;
3951 }
3952 }
3953
3954 if (status_check == 1)
3955 {
3956 status_left--;
3957
3958 if (status_left == 0)
3959 {
3960 hc_thread_mutex_lock (mux_display);
3961
3962 if (data.quiet == 0) clear_prompt ();
3963
3964 if (data.quiet == 0) log_info ("");
3965
3966 status_display ();
3967
3968 if (data.quiet == 0) log_info ("");
3969
3970 hc_thread_mutex_unlock (mux_display);
3971
3972 status_left = data.status_timer;
3973 }
3974 }
3975 }
3976
3977 #ifdef HAVE_HWMON
3978 myfree (fan_speed_chgd);
3979
3980 myfree (temp_diff_old);
3981 myfree (temp_diff_sum);
3982 #endif
3983
3984 p = NULL;
3985
3986 return (p);
3987 }
3988
3989 static void *thread_outfile_remove (void *p)
3990 {
3991 // some hash-dependent constants
3992 char *outfile_dir = data.outfile_check_directory;
3993 uint dgst_size = data.dgst_size;
3994 uint isSalted = data.isSalted;
3995 uint esalt_size = data.esalt_size;
3996 uint hash_mode = data.hash_mode;
3997
3998 uint outfile_check_timer = data.outfile_check_timer;
3999
4000 char separator = data.separator;
4001
4002 // some hash-dependent functions
4003 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4004 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4005
4006 // buffers
4007 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4008
4009 hash_buf.digest = mymalloc (dgst_size);
4010
4011 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4012
4013 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4014
4015 uint digest_buf[64] = { 0 };
4016
4017 outfile_data_t *out_info = NULL;
4018
4019 char **out_files = NULL;
4020
4021 time_t folder_mtime = 0;
4022
4023 int out_cnt = 0;
4024
4025 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4026
4027 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4028 {
4029 hc_sleep (1);
4030
4031 if (data.devices_status != STATUS_RUNNING) continue;
4032
4033 check_left--;
4034
4035 if (check_left == 0)
4036 {
4037 struct stat outfile_check_stat;
4038
4039 if (stat (outfile_dir, &outfile_check_stat) == 0)
4040 {
4041 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4042
4043 if (is_dir == 1)
4044 {
4045 if (outfile_check_stat.st_mtime > folder_mtime)
4046 {
4047 char **out_files_new = scan_directory (outfile_dir);
4048
4049 int out_cnt_new = count_dictionaries (out_files_new);
4050
4051 outfile_data_t *out_info_new = NULL;
4052
4053 if (out_cnt_new > 0)
4054 {
4055 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4056
4057 for (int i = 0; i < out_cnt_new; i++)
4058 {
4059 out_info_new[i].file_name = out_files_new[i];
4060
4061 // check if there are files that we have seen/checked before (and not changed)
4062
4063 for (int j = 0; j < out_cnt; j++)
4064 {
4065 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4066 {
4067 struct stat outfile_stat;
4068
4069 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4070 {
4071 if (outfile_stat.st_ctime == out_info[j].ctime)
4072 {
4073 out_info_new[i].ctime = out_info[j].ctime;
4074 out_info_new[i].seek = out_info[j].seek;
4075 }
4076 }
4077 }
4078 }
4079 }
4080 }
4081
4082 local_free (out_info);
4083 local_free (out_files);
4084
4085 out_files = out_files_new;
4086 out_cnt = out_cnt_new;
4087 out_info = out_info_new;
4088
4089 folder_mtime = outfile_check_stat.st_mtime;
4090 }
4091
4092 for (int j = 0; j < out_cnt; j++)
4093 {
4094 FILE *fp = fopen (out_info[j].file_name, "rb");
4095
4096 if (fp != NULL)
4097 {
4098 //hc_thread_mutex_lock (mux_display);
4099
4100 #ifdef _POSIX
4101 struct stat outfile_stat;
4102
4103 fstat (fileno (fp), &outfile_stat);
4104 #endif
4105
4106 #ifdef _WIN
4107 struct stat64 outfile_stat;
4108
4109 _fstat64 (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 if (outfile_stat.st_ctime > out_info[j].ctime)
4113 {
4114 out_info[j].ctime = outfile_stat.st_ctime;
4115 out_info[j].seek = 0;
4116 }
4117
4118 fseek (fp, out_info[j].seek, SEEK_SET);
4119
4120 while (!feof (fp))
4121 {
4122 char line_buf[BUFSIZ] = { 0 };
4123
4124 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4125
4126 if (ptr == NULL) break;
4127
4128 int line_len = strlen (line_buf);
4129
4130 if (line_len <= 0) continue;
4131
4132 int iter = MAX_CUT_TRIES;
4133
4134 for (uint i = line_len - 1; i && iter; i--, line_len--)
4135 {
4136 if (line_buf[i] != separator) continue;
4137
4138 int parser_status = PARSER_OK;
4139
4140 if ((hash_mode != 2500) && (hash_mode != 6800))
4141 {
4142 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4143 }
4144
4145 uint found = 0;
4146
4147 if (parser_status == PARSER_OK)
4148 {
4149 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4150 {
4151 if (data.salts_shown[salt_pos] == 1) continue;
4152
4153 salt_t *salt_buf = &data.salts_buf[salt_pos];
4154
4155 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4156 {
4157 uint idx = salt_buf->digests_offset + digest_pos;
4158
4159 if (data.digests_shown[idx] == 1) continue;
4160
4161 uint cracked = 0;
4162
4163 if (hash_mode == 6800)
4164 {
4165 if (i == salt_buf->salt_len)
4166 {
4167 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4168 }
4169 }
4170 else if (hash_mode == 2500)
4171 {
4172 // BSSID : MAC1 : MAC2 (:plain)
4173 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4174 {
4175 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4176
4177 if (!cracked) continue;
4178
4179 // now compare MAC1 and MAC2 too, since we have this additional info
4180 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4181 char *mac2_pos = mac1_pos + 12 + 1;
4182
4183 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4184 wpa_t *wpa = &wpas[salt_pos];
4185
4186 uint pke[25] = { 0 };
4187
4188 char *pke_ptr = (char *) pke;
4189
4190 for (uint i = 0; i < 25; i++)
4191 {
4192 pke[i] = byte_swap_32 (wpa->pke[i]);
4193 }
4194
4195 u8 mac1[6] = { 0 };
4196 u8 mac2[6] = { 0 };
4197
4198 memcpy (mac1, pke_ptr + 23, 6);
4199 memcpy (mac2, pke_ptr + 29, 6);
4200
4201 // compare hex string(s) vs binary MAC address(es)
4202
4203 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4204 {
4205 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4206 {
4207 cracked = 0;
4208 break;
4209 }
4210 }
4211
4212 // early skip ;)
4213 if (!cracked) continue;
4214
4215 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4216 {
4217 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4218 {
4219 cracked = 0;
4220 break;
4221 }
4222 }
4223 }
4224 }
4225 else
4226 {
4227 char *digests_buf_ptr = (char *) data.digests_buf;
4228
4229 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4230
4231 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4232 }
4233
4234 if (cracked == 1)
4235 {
4236 found = 1;
4237
4238 data.digests_shown[idx] = 1;
4239
4240 data.digests_done++;
4241
4242 salt_buf->digests_done++;
4243
4244 if (salt_buf->digests_done == salt_buf->digests_cnt)
4245 {
4246 data.salts_shown[salt_pos] = 1;
4247
4248 data.salts_done++;
4249
4250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4251 }
4252 }
4253 }
4254
4255 if (data.devices_status == STATUS_CRACKED) break;
4256 }
4257 }
4258
4259 if (found) break;
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262
4263 iter--;
4264 }
4265
4266 if (data.devices_status == STATUS_CRACKED) break;
4267 }
4268
4269 out_info[j].seek = ftell (fp);
4270
4271 //hc_thread_mutex_unlock (mux_display);
4272
4273 fclose (fp);
4274 }
4275 }
4276 }
4277 }
4278
4279 check_left = outfile_check_timer;
4280 }
4281 }
4282
4283 if (esalt_size) local_free (hash_buf.esalt);
4284
4285 if (isSalted) local_free (hash_buf.salt);
4286
4287 local_free (hash_buf.digest);
4288
4289 local_free (out_info);
4290
4291 local_free (out_files);
4292
4293 p = NULL;
4294
4295 return (p);
4296 }
4297
4298 static uint get_work (hc_device_param_t *device_param, const u64 max)
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 const u64 words_cur = data.words_cur;
4303 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4304
4305 device_param->words_off = words_cur;
4306
4307 const u64 words_left = words_base - words_cur;
4308
4309 if (data.kernel_power_all > words_left)
4310 {
4311 if (data.kernel_power_div == 0)
4312 {
4313 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4314 }
4315 }
4316
4317 if (data.kernel_power_div)
4318 {
4319 if (device_param->kernel_power == device_param->kernel_power_user)
4320 {
4321 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4322
4323 if (kernel_power_new < device_param->kernel_power)
4324 {
4325 device_param->kernel_power = kernel_power_new;
4326 }
4327 }
4328 }
4329
4330 const uint kernel_power = device_param->kernel_power;
4331
4332 uint work = MIN (words_left, kernel_power);
4333
4334 work = MIN (work, max);
4335
4336 data.words_cur += work;
4337
4338 hc_thread_mutex_unlock (mux_dispatcher);
4339
4340 return work;
4341 }
4342
4343 static void *thread_calc_stdin (void *p)
4344 {
4345 hc_device_param_t *device_param = (hc_device_param_t *) p;
4346
4347 if (device_param->skipped) return NULL;
4348
4349 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4350 {
4351 autotune (device_param);
4352 }
4353
4354 const uint attack_kern = data.attack_kern;
4355
4356 const uint kernel_power = device_param->kernel_power;
4357
4358 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4359 {
4360 hc_thread_mutex_lock (mux_dispatcher);
4361
4362 if (feof (stdin) != 0)
4363 {
4364 hc_thread_mutex_unlock (mux_dispatcher);
4365
4366 break;
4367 }
4368
4369 uint words_cur = 0;
4370
4371 while (words_cur < kernel_power)
4372 {
4373 char buf[BUFSIZ] = { 0 };
4374
4375 char *line_buf = fgets (buf, sizeof (buf), stdin);
4376
4377 if (line_buf == NULL) break;
4378
4379 uint line_len = in_superchop (line_buf);
4380
4381 line_len = convert_from_hex (line_buf, line_len);
4382
4383 // post-process rule engine
4384
4385 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4386 {
4387 char rule_buf_out[BLOCK_SIZE] = { 0 };
4388
4389 int rule_len_out = -1;
4390
4391 if (line_len < BLOCK_SIZE)
4392 {
4393 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4394 }
4395
4396 if (rule_len_out < 0) continue;
4397
4398 line_buf = rule_buf_out;
4399 line_len = rule_len_out;
4400 }
4401
4402 if (line_len > PW_MAX)
4403 {
4404 continue;
4405 }
4406
4407 if (attack_kern == ATTACK_KERN_STRAIGHT)
4408 {
4409 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4410 {
4411 hc_thread_mutex_lock (mux_counter);
4412
4413 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4414 {
4415 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4416 }
4417
4418 hc_thread_mutex_unlock (mux_counter);
4419
4420 continue;
4421 }
4422 }
4423 else if (attack_kern == ATTACK_KERN_COMBI)
4424 {
4425 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4426 // since we still need to combine the plains
4427
4428 if (line_len > data.pw_max)
4429 {
4430 hc_thread_mutex_lock (mux_counter);
4431
4432 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4433 {
4434 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4435 }
4436
4437 hc_thread_mutex_unlock (mux_counter);
4438
4439 continue;
4440 }
4441 }
4442
4443 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4444
4445 words_cur++;
4446
4447 if (data.devices_status == STATUS_CRACKED) break;
4448 if (data.devices_status == STATUS_ABORTED) break;
4449 if (data.devices_status == STATUS_QUIT) break;
4450 if (data.devices_status == STATUS_BYPASS) break;
4451 }
4452
4453 hc_thread_mutex_unlock (mux_dispatcher);
4454
4455 if (data.devices_status == STATUS_CRACKED) break;
4456 if (data.devices_status == STATUS_ABORTED) break;
4457 if (data.devices_status == STATUS_QUIT) break;
4458 if (data.devices_status == STATUS_BYPASS) break;
4459
4460 // we need 2 flushing because we have two independant caches and it can occur
4461 // that one buffer is already at threshold plus for that length also exists
4462 // more data in the 2nd buffer so it would overflow
4463
4464 // flush session 1
4465
4466 {
4467 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4468 {
4469 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4470
4471 const uint pw_cache_cnt = pw_cache->cnt;
4472
4473 if (pw_cache_cnt == 0) continue;
4474
4475 pw_cache->cnt = 0;
4476
4477 uint pws_cnt = device_param->pws_cnt;
4478
4479 pw_t *pw = device_param->pws_buf + pws_cnt;
4480
4481 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4482
4483 pw->pw_len = pw_len;
4484
4485 uint pw_cnt = device_param->pw_cnt;
4486
4487 pw_cnt += pw_cache_cnt;
4488
4489 device_param->pw_cnt = pw_cnt;
4490
4491 pws_cnt++;
4492
4493 device_param->pws_cnt = pws_cnt;
4494
4495 if (pws_cnt == device_param->kernel_power_user) break;
4496 }
4497
4498 const uint pw_cnt = device_param->pw_cnt;
4499 const uint pws_cnt = device_param->pws_cnt;
4500
4501 if (pws_cnt)
4502 {
4503 run_copy (device_param, pws_cnt);
4504
4505 run_cracker (device_param, pw_cnt, pws_cnt);
4506
4507 device_param->pw_cnt = 0;
4508 device_param->pws_cnt = 0;
4509 }
4510 }
4511
4512 // flush session 2
4513
4514 {
4515 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4516 {
4517 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4518
4519 const uint pw_cache_cnt = pw_cache->cnt;
4520
4521 if (pw_cache_cnt == 0) continue;
4522
4523 pw_cache->cnt = 0;
4524
4525 uint pws_cnt = device_param->pws_cnt;
4526
4527 pw_t *pw = device_param->pws_buf + pws_cnt;
4528
4529 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4530
4531 pw->pw_len = pw_len;
4532
4533 uint pw_cnt = device_param->pw_cnt;
4534
4535 pw_cnt += pw_cache_cnt;
4536
4537 device_param->pw_cnt = pw_cnt;
4538
4539 pws_cnt++;
4540
4541 device_param->pws_cnt = pws_cnt;
4542 }
4543
4544 const uint pw_cnt = device_param->pw_cnt;
4545 const uint pws_cnt = device_param->pws_cnt;
4546
4547 if (pws_cnt)
4548 {
4549 run_copy (device_param, pws_cnt);
4550
4551 run_cracker (device_param, pw_cnt, pws_cnt);
4552
4553 device_param->pw_cnt = 0;
4554 device_param->pws_cnt = 0;
4555 }
4556 }
4557 }
4558
4559 return NULL;
4560 }
4561
4562 static void *thread_calc (void *p)
4563 {
4564 hc_device_param_t *device_param = (hc_device_param_t *) p;
4565
4566 if (device_param->skipped) return NULL;
4567
4568 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4569 {
4570 autotune (device_param);
4571 }
4572
4573 const uint attack_mode = data.attack_mode;
4574 const uint attack_kern = data.attack_kern;
4575
4576 if (attack_mode == ATTACK_MODE_BF)
4577 {
4578 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4579 {
4580 const uint work = get_work (device_param, -1);
4581
4582 if (work == 0) break;
4583
4584 const u64 words_off = device_param->words_off;
4585 const u64 words_fin = words_off + work;
4586
4587 const uint pw_cnt = work;
4588 const uint pws_cnt = work;
4589
4590 device_param->pw_cnt = pw_cnt;
4591 device_param->pws_cnt = pws_cnt;
4592
4593 if (pws_cnt)
4594 {
4595 run_copy (device_param, pws_cnt);
4596
4597 run_cracker (device_param, pw_cnt, pws_cnt);
4598
4599 device_param->pw_cnt = 0;
4600 device_param->pws_cnt = 0;
4601 }
4602
4603 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4604
4605 if (data.devices_status == STATUS_CRACKED) break;
4606 if (data.devices_status == STATUS_ABORTED) break;
4607 if (data.devices_status == STATUS_QUIT) break;
4608 if (data.devices_status == STATUS_BYPASS) break;
4609
4610 device_param->words_done = words_fin;
4611 }
4612 }
4613 else
4614 {
4615 const uint segment_size = data.segment_size;
4616
4617 char *dictfile = data.dictfile;
4618
4619 if (attack_mode == ATTACK_MODE_COMBI)
4620 {
4621 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4622 {
4623 dictfile = data.dictfile2;
4624 }
4625 }
4626
4627 FILE *fd = fopen (dictfile, "rb");
4628
4629 if (fd == NULL)
4630 {
4631 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4632
4633 return NULL;
4634 }
4635
4636 if (attack_mode == ATTACK_MODE_COMBI)
4637 {
4638 const uint combs_mode = data.combs_mode;
4639
4640 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4641 {
4642 const char *dictfilec = data.dictfile2;
4643
4644 FILE *combs_fp = fopen (dictfilec, "rb");
4645
4646 if (combs_fp == NULL)
4647 {
4648 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4649
4650 fclose (fd);
4651
4652 return NULL;
4653 }
4654
4655 device_param->combs_fp = combs_fp;
4656 }
4657 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4658 {
4659 const char *dictfilec = data.dictfile;
4660
4661 FILE *combs_fp = fopen (dictfilec, "rb");
4662
4663 if (combs_fp == NULL)
4664 {
4665 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4666
4667 fclose (fd);
4668
4669 return NULL;
4670 }
4671
4672 device_param->combs_fp = combs_fp;
4673 }
4674 }
4675
4676 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4677
4678 wl_data->buf = (char *) mymalloc (segment_size);
4679 wl_data->avail = segment_size;
4680 wl_data->incr = segment_size;
4681 wl_data->cnt = 0;
4682 wl_data->pos = 0;
4683
4684 u64 words_cur = 0;
4685
4686 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4687 {
4688 u64 words_off = 0;
4689 u64 words_fin = 0;
4690
4691 u64 max = -1;
4692
4693 while (max)
4694 {
4695 const uint work = get_work (device_param, max);
4696
4697 if (work == 0) break;
4698
4699 words_off = device_param->words_off;
4700 words_fin = words_off + work;
4701
4702 char *line_buf;
4703 uint line_len;
4704
4705 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4706
4707 max = 0;
4708
4709 for ( ; words_cur < words_fin; words_cur++)
4710 {
4711 get_next_word (wl_data, fd, &line_buf, &line_len);
4712
4713 line_len = convert_from_hex (line_buf, line_len);
4714
4715 // post-process rule engine
4716
4717 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4718 {
4719 char rule_buf_out[BLOCK_SIZE] = { 0 };
4720
4721 int rule_len_out = -1;
4722
4723 if (line_len < BLOCK_SIZE)
4724 {
4725 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4726 }
4727
4728 if (rule_len_out < 0) continue;
4729
4730 line_buf = rule_buf_out;
4731 line_len = rule_len_out;
4732 }
4733
4734 if (attack_kern == ATTACK_KERN_STRAIGHT)
4735 {
4736 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4737 {
4738 max++;
4739
4740 hc_thread_mutex_lock (mux_counter);
4741
4742 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4743 {
4744 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4745 }
4746
4747 hc_thread_mutex_unlock (mux_counter);
4748
4749 continue;
4750 }
4751 }
4752 else if (attack_kern == ATTACK_KERN_COMBI)
4753 {
4754 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4755 // since we still need to combine the plains
4756
4757 if (line_len > data.pw_max)
4758 {
4759 max++;
4760
4761 hc_thread_mutex_lock (mux_counter);
4762
4763 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4764 {
4765 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4766 }
4767
4768 hc_thread_mutex_unlock (mux_counter);
4769
4770 continue;
4771 }
4772 }
4773
4774 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4775
4776 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4777
4778 if (data.devices_status == STATUS_CRACKED) break;
4779 if (data.devices_status == STATUS_ABORTED) break;
4780 if (data.devices_status == STATUS_QUIT) break;
4781 if (data.devices_status == STATUS_BYPASS) break;
4782 }
4783
4784 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4785
4786 if (data.devices_status == STATUS_CRACKED) break;
4787 if (data.devices_status == STATUS_ABORTED) break;
4788 if (data.devices_status == STATUS_QUIT) break;
4789 if (data.devices_status == STATUS_BYPASS) break;
4790 }
4791
4792 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4793
4794 if (data.devices_status == STATUS_CRACKED) break;
4795 if (data.devices_status == STATUS_ABORTED) break;
4796 if (data.devices_status == STATUS_QUIT) break;
4797 if (data.devices_status == STATUS_BYPASS) break;
4798
4799 // we need 2 flushing because we have two independant caches and it can occur
4800 // that one buffer is already at threshold plus for that length also exists
4801 // more data in the 2nd buffer so it would overflow
4802
4803 //
4804 // flush session 1
4805 //
4806
4807 {
4808 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4809 {
4810 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4811
4812 const uint pw_cache_cnt = pw_cache->cnt;
4813
4814 if (pw_cache_cnt == 0) continue;
4815
4816 pw_cache->cnt = 0;
4817
4818 uint pws_cnt = device_param->pws_cnt;
4819
4820 pw_t *pw = device_param->pws_buf + pws_cnt;
4821
4822 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4823
4824 pw->pw_len = pw_len;
4825
4826 uint pw_cnt = device_param->pw_cnt;
4827
4828 pw_cnt += pw_cache_cnt;
4829
4830 device_param->pw_cnt = pw_cnt;
4831
4832 pws_cnt++;
4833
4834 device_param->pws_cnt = pws_cnt;
4835
4836 if (pws_cnt == device_param->kernel_power_user) break;
4837 }
4838
4839 const uint pw_cnt = device_param->pw_cnt;
4840 const uint pws_cnt = device_param->pws_cnt;
4841
4842 if (pws_cnt)
4843 {
4844 run_copy (device_param, pws_cnt);
4845
4846 run_cracker (device_param, pw_cnt, pws_cnt);
4847
4848 device_param->pw_cnt = 0;
4849 device_param->pws_cnt = 0;
4850 }
4851
4852 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4853
4854 if (data.devices_status == STATUS_CRACKED) break;
4855 if (data.devices_status == STATUS_ABORTED) break;
4856 if (data.devices_status == STATUS_QUIT) break;
4857 if (data.devices_status == STATUS_BYPASS) break;
4858 }
4859
4860 //
4861 // flush session 2
4862 //
4863
4864 {
4865 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4866 {
4867 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4868
4869 const uint pw_cache_cnt = pw_cache->cnt;
4870
4871 if (pw_cache_cnt == 0) continue;
4872
4873 pw_cache->cnt = 0;
4874
4875 uint pws_cnt = device_param->pws_cnt;
4876
4877 pw_t *pw = device_param->pws_buf + pws_cnt;
4878
4879 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4880
4881 pw->pw_len = pw_len;
4882
4883 uint pw_cnt = device_param->pw_cnt;
4884
4885 pw_cnt += pw_cache_cnt;
4886
4887 device_param->pw_cnt = pw_cnt;
4888
4889 pws_cnt++;
4890
4891 device_param->pws_cnt = pws_cnt;
4892 }
4893
4894 const uint pw_cnt = device_param->pw_cnt;
4895 const uint pws_cnt = device_param->pws_cnt;
4896
4897 if (pws_cnt)
4898 {
4899 run_copy (device_param, pws_cnt);
4900
4901 run_cracker (device_param, pw_cnt, pws_cnt);
4902
4903 device_param->pw_cnt = 0;
4904 device_param->pws_cnt = 0;
4905 }
4906
4907 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4908
4909 if (data.devices_status == STATUS_CRACKED) break;
4910 if (data.devices_status == STATUS_ABORTED) break;
4911 if (data.devices_status == STATUS_QUIT) break;
4912 if (data.devices_status == STATUS_BYPASS) break;
4913 }
4914
4915 if (words_fin == 0) break;
4916
4917 device_param->words_done = words_fin;
4918 }
4919
4920 if (attack_mode == ATTACK_MODE_COMBI)
4921 {
4922 fclose (device_param->combs_fp);
4923 }
4924
4925 free (wl_data->buf);
4926 free (wl_data);
4927
4928 fclose (fd);
4929 }
4930
4931 return NULL;
4932 }
4933
4934 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4935 {
4936 if (!device_param)
4937 {
4938 log_error ("ERROR: %s : Invalid argument", __func__);
4939
4940 exit (-1);
4941 }
4942
4943 salt_t *salt_buf = &data.salts_buf[salt_pos];
4944
4945 device_param->kernel_params_buf32[24] = salt_pos;
4946 device_param->kernel_params_buf32[27] = 1;
4947 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4948 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4949 device_param->kernel_params_buf32[30] = 0;
4950 device_param->kernel_params_buf32[31] = 1;
4951
4952 char *dictfile_old = data.dictfile;
4953
4954 const char *weak_hash_check = "weak-hash-check";
4955
4956 data.dictfile = (char *) weak_hash_check;
4957
4958 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4959
4960 data.kernel_rules_buf[0].cmds[0] = 0;
4961
4962 /**
4963 * run the kernel
4964 */
4965
4966 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4967 {
4968 run_kernel (KERN_RUN_1, device_param, 1, false);
4969 }
4970 else
4971 {
4972 run_kernel (KERN_RUN_1, device_param, 1, false);
4973
4974 uint loop_step = 16;
4975
4976 const uint iter = salt_buf->salt_iter;
4977
4978 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4979 {
4980 uint loop_left = iter - loop_pos;
4981
4982 loop_left = MIN (loop_left, loop_step);
4983
4984 device_param->kernel_params_buf32[25] = loop_pos;
4985 device_param->kernel_params_buf32[26] = loop_left;
4986
4987 run_kernel (KERN_RUN_2, device_param, 1, false);
4988 }
4989
4990 run_kernel (KERN_RUN_3, device_param, 1, false);
4991 }
4992
4993 /**
4994 * result
4995 */
4996
4997 check_cracked (device_param, salt_pos);
4998
4999 /**
5000 * cleanup
5001 */
5002
5003 device_param->kernel_params_buf32[24] = 0;
5004 device_param->kernel_params_buf32[25] = 0;
5005 device_param->kernel_params_buf32[26] = 0;
5006 device_param->kernel_params_buf32[27] = 0;
5007 device_param->kernel_params_buf32[28] = 0;
5008 device_param->kernel_params_buf32[29] = 0;
5009 device_param->kernel_params_buf32[30] = 0;
5010 device_param->kernel_params_buf32[31] = 0;
5011
5012 data.dictfile = dictfile_old;
5013
5014 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5015 }
5016
5017 // hlfmt hashcat
5018
5019 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5020 {
5021 if (data.username == 0)
5022 {
5023 *hashbuf_pos = line_buf;
5024 *hashbuf_len = line_len;
5025 }
5026 else
5027 {
5028 char *pos = line_buf;
5029 int len = line_len;
5030
5031 for (int i = 0; i < line_len; i++, pos++, len--)
5032 {
5033 if (line_buf[i] == data.separator)
5034 {
5035 pos++;
5036
5037 len--;
5038
5039 break;
5040 }
5041 }
5042
5043 *hashbuf_pos = pos;
5044 *hashbuf_len = len;
5045 }
5046 }
5047
5048 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5049 {
5050 char *pos = NULL;
5051 int len = 0;
5052
5053 int sep_cnt = 0;
5054
5055 for (int i = 0; i < line_len; i++)
5056 {
5057 if (line_buf[i] == data.separator)
5058 {
5059 sep_cnt++;
5060
5061 continue;
5062 }
5063
5064 if (sep_cnt == 0)
5065 {
5066 if (pos == NULL) pos = line_buf + i;
5067
5068 len++;
5069 }
5070 }
5071
5072 *userbuf_pos = pos;
5073 *userbuf_len = len;
5074 }
5075
5076 // hlfmt pwdump
5077
5078 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5079 {
5080 int sep_cnt = 0;
5081
5082 int sep2_len = 0;
5083 int sep3_len = 0;
5084
5085 for (int i = 0; i < line_len; i++)
5086 {
5087 if (line_buf[i] == ':')
5088 {
5089 sep_cnt++;
5090
5091 continue;
5092 }
5093
5094 if (sep_cnt == 2) sep2_len++;
5095 if (sep_cnt == 3) sep3_len++;
5096 }
5097
5098 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5099
5100 return 0;
5101 }
5102
5103 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5104 {
5105 char *pos = NULL;
5106 int len = 0;
5107
5108 int sep_cnt = 0;
5109
5110 for (int i = 0; i < line_len; i++)
5111 {
5112 if (line_buf[i] == ':')
5113 {
5114 sep_cnt++;
5115
5116 continue;
5117 }
5118
5119 if (data.hash_mode == 1000)
5120 {
5121 if (sep_cnt == 3)
5122 {
5123 if (pos == NULL) pos = line_buf + i;
5124
5125 len++;
5126 }
5127 }
5128 else if (data.hash_mode == 3000)
5129 {
5130 if (sep_cnt == 2)
5131 {
5132 if (pos == NULL) pos = line_buf + i;
5133
5134 len++;
5135 }
5136 }
5137 }
5138
5139 *hashbuf_pos = pos;
5140 *hashbuf_len = len;
5141 }
5142
5143 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5144 {
5145 char *pos = NULL;
5146 int len = 0;
5147
5148 int sep_cnt = 0;
5149
5150 for (int i = 0; i < line_len; i++)
5151 {
5152 if (line_buf[i] == ':')
5153 {
5154 sep_cnt++;
5155
5156 continue;
5157 }
5158
5159 if (sep_cnt == 0)
5160 {
5161 if (pos == NULL) pos = line_buf + i;
5162
5163 len++;
5164 }
5165 }
5166
5167 *userbuf_pos = pos;
5168 *userbuf_len = len;
5169 }
5170
5171 // hlfmt passwd
5172
5173 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5174 {
5175 int sep_cnt = 0;
5176
5177 char sep5_first = 0;
5178 char sep6_first = 0;
5179
5180 for (int i = 0; i < line_len; i++)
5181 {
5182 if (line_buf[i] == ':')
5183 {
5184 sep_cnt++;
5185
5186 continue;
5187 }
5188
5189 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5190 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5191 }
5192
5193 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5194
5195 return 0;
5196 }
5197
5198 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5199 {
5200 char *pos = NULL;
5201 int len = 0;
5202
5203 int sep_cnt = 0;
5204
5205 for (int i = 0; i < line_len; i++)
5206 {
5207 if (line_buf[i] == ':')
5208 {
5209 sep_cnt++;
5210
5211 continue;
5212 }
5213
5214 if (sep_cnt == 1)
5215 {
5216 if (pos == NULL) pos = line_buf + i;
5217
5218 len++;
5219 }
5220 }
5221
5222 *hashbuf_pos = pos;
5223 *hashbuf_len = len;
5224 }
5225
5226 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5227 {
5228 char *pos = NULL;
5229 int len = 0;
5230
5231 int sep_cnt = 0;
5232
5233 for (int i = 0; i < line_len; i++)
5234 {
5235 if (line_buf[i] == ':')
5236 {
5237 sep_cnt++;
5238
5239 continue;
5240 }
5241
5242 if (sep_cnt == 0)
5243 {
5244 if (pos == NULL) pos = line_buf + i;
5245
5246 len++;
5247 }
5248 }
5249
5250 *userbuf_pos = pos;
5251 *userbuf_len = len;
5252 }
5253
5254 // hlfmt shadow
5255
5256 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5257 {
5258 int sep_cnt = 0;
5259
5260 for (int i = 0; i < line_len; i++)
5261 {
5262 if (line_buf[i] == ':') sep_cnt++;
5263 }
5264
5265 if (sep_cnt == 8) return 1;
5266
5267 return 0;
5268 }
5269
5270 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5271 {
5272 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5273 }
5274
5275 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5276 {
5277 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5278 }
5279
5280 // hlfmt main
5281
5282 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5283 {
5284 switch (hashfile_format)
5285 {
5286 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5287 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5288 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5289 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5290 }
5291 }
5292
5293 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5294 {
5295 switch (hashfile_format)
5296 {
5297 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5298 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5299 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5300 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5301 }
5302 }
5303
5304 static uint hlfmt_detect (FILE *fp, uint max_check)
5305 {
5306 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5307
5308 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5309 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5310
5311 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5312
5313 uint num_check = 0;
5314
5315 while (!feof (fp))
5316 {
5317 char line_buf[BUFSIZ] = { 0 };
5318
5319 int line_len = fgetl (fp, line_buf);
5320
5321 if (line_len == 0) continue;
5322
5323 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5324 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5325 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5326
5327 if (num_check == max_check) break;
5328
5329 num_check++;
5330 }
5331
5332 uint hashlist_format = HLFMT_HASHCAT;
5333
5334 for (int i = 1; i < HLFMTS_CNT; i++)
5335 {
5336 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5337
5338 hashlist_format = i;
5339 }
5340
5341 free (formats_cnt);
5342
5343 return hashlist_format;
5344 }
5345
5346 /**
5347 * some further helper function
5348 */
5349
5350 // wrapper around mymalloc for ADL
5351
5352 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5353 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5354 {
5355 return mymalloc (iSize);
5356 }
5357 #endif
5358
5359 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)
5360 {
5361 u64 collisions = 0;
5362
5363 const uint dgst_pos0 = data.dgst_pos0;
5364 const uint dgst_pos1 = data.dgst_pos1;
5365 const uint dgst_pos2 = data.dgst_pos2;
5366 const uint dgst_pos3 = data.dgst_pos3;
5367
5368 memset (bitmap_a, 0, bitmap_size);
5369 memset (bitmap_b, 0, bitmap_size);
5370 memset (bitmap_c, 0, bitmap_size);
5371 memset (bitmap_d, 0, bitmap_size);
5372
5373 for (uint i = 0; i < digests_cnt; i++)
5374 {
5375 uint *digest_ptr = (uint *) digests_buf_ptr;
5376
5377 digests_buf_ptr += dgst_size;
5378
5379 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5380 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5381 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5382 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5383
5384 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5385 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5386 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5387 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5388
5389 if (bitmap_a[idx0] & val0) collisions++;
5390 if (bitmap_b[idx1] & val1) collisions++;
5391 if (bitmap_c[idx2] & val2) collisions++;
5392 if (bitmap_d[idx3] & val3) collisions++;
5393
5394 bitmap_a[idx0] |= val0;
5395 bitmap_b[idx1] |= val1;
5396 bitmap_c[idx2] |= val2;
5397 bitmap_d[idx3] |= val3;
5398
5399 if (collisions >= collisions_max) return 0x7fffffff;
5400 }
5401
5402 return collisions;
5403 }
5404
5405 /**
5406 * main
5407 */
5408
5409 int main (int argc, char **argv)
5410 {
5411 /**
5412 * To help users a bit
5413 */
5414
5415 char *compute = getenv ("COMPUTE");
5416
5417 if (compute)
5418 {
5419 static char display[100];
5420
5421 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5422
5423 putenv (display);
5424 }
5425 else
5426 {
5427 if (getenv ("DISPLAY") == NULL)
5428 putenv ((char *) "DISPLAY=:0");
5429 }
5430
5431 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5432 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5433
5434 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5435 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5436
5437 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5438 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5439
5440 /**
5441 * Real init
5442 */
5443
5444 memset (&data, 0, sizeof (hc_global_data_t));
5445
5446 time_t proc_start;
5447
5448 time (&proc_start);
5449
5450 data.proc_start = proc_start;
5451
5452 int myargc = argc;
5453 char **myargv = argv;
5454
5455 hc_thread_mutex_init (mux_dispatcher);
5456 hc_thread_mutex_init (mux_counter);
5457 hc_thread_mutex_init (mux_display);
5458 hc_thread_mutex_init (mux_adl);
5459
5460 /**
5461 * commandline parameters
5462 */
5463
5464 uint usage = USAGE;
5465 uint version = VERSION;
5466 uint quiet = QUIET;
5467 uint benchmark = BENCHMARK;
5468 uint show = SHOW;
5469 uint left = LEFT;
5470 uint username = USERNAME;
5471 uint remove = REMOVE;
5472 uint remove_timer = REMOVE_TIMER;
5473 u64 skip = SKIP;
5474 u64 limit = LIMIT;
5475 uint keyspace = KEYSPACE;
5476 uint potfile_disable = POTFILE_DISABLE;
5477 uint debug_mode = DEBUG_MODE;
5478 char *debug_file = NULL;
5479 char *induction_dir = NULL;
5480 char *outfile_check_dir = NULL;
5481 uint force = FORCE;
5482 uint runtime = RUNTIME;
5483 uint hash_mode = HASH_MODE;
5484 uint attack_mode = ATTACK_MODE;
5485 uint markov_disable = MARKOV_DISABLE;
5486 uint markov_classic = MARKOV_CLASSIC;
5487 uint markov_threshold = MARKOV_THRESHOLD;
5488 char *markov_hcstat = NULL;
5489 char *outfile = NULL;
5490 uint outfile_format = OUTFILE_FORMAT;
5491 uint outfile_autohex = OUTFILE_AUTOHEX;
5492 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5493 uint restore = RESTORE;
5494 uint restore_timer = RESTORE_TIMER;
5495 uint restore_disable = RESTORE_DISABLE;
5496 uint status = STATUS;
5497 uint status_timer = STATUS_TIMER;
5498 uint status_automat = STATUS_AUTOMAT;
5499 uint loopback = LOOPBACK;
5500 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5501 char *session = NULL;
5502 uint hex_charset = HEX_CHARSET;
5503 uint hex_salt = HEX_SALT;
5504 uint hex_wordlist = HEX_WORDLIST;
5505 uint rp_gen = RP_GEN;
5506 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5507 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5508 uint rp_gen_seed = RP_GEN_SEED;
5509 char *rule_buf_l = (char *) RULE_BUF_L;
5510 char *rule_buf_r = (char *) RULE_BUF_R;
5511 uint increment = INCREMENT;
5512 uint increment_min = INCREMENT_MIN;
5513 uint increment_max = INCREMENT_MAX;
5514 char *cpu_affinity = NULL;
5515 OCL_PTR *ocl = NULL;
5516 char *opencl_devices = NULL;
5517 char *opencl_platforms = NULL;
5518 char *opencl_device_types = NULL;
5519 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5520 char *truecrypt_keyfiles = NULL;
5521 uint workload_profile = WORKLOAD_PROFILE;
5522 uint kernel_accel = KERNEL_ACCEL;
5523 uint kernel_loops = KERNEL_LOOPS;
5524 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5525 #ifdef HAVE_HWMON
5526 uint gpu_temp_abort = GPU_TEMP_ABORT;
5527 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5528 #ifdef HAVE_ADL
5529 uint powertune_enable = POWERTUNE_ENABLE;
5530 #endif
5531 #endif
5532 uint logfile_disable = LOGFILE_DISABLE;
5533 uint segment_size = SEGMENT_SIZE;
5534 uint scrypt_tmto = SCRYPT_TMTO;
5535 char separator = SEPARATOR;
5536 uint bitmap_min = BITMAP_MIN;
5537 uint bitmap_max = BITMAP_MAX;
5538 char *custom_charset_1 = NULL;
5539 char *custom_charset_2 = NULL;
5540 char *custom_charset_3 = NULL;
5541 char *custom_charset_4 = NULL;
5542
5543 #define IDX_HELP 'h'
5544 #define IDX_VERSION 'V'
5545 #define IDX_VERSION_LOWER 'v'
5546 #define IDX_QUIET 0xff02
5547 #define IDX_SHOW 0xff03
5548 #define IDX_LEFT 0xff04
5549 #define IDX_REMOVE 0xff05
5550 #define IDX_REMOVE_TIMER 0xff37
5551 #define IDX_SKIP 's'
5552 #define IDX_LIMIT 'l'
5553 #define IDX_KEYSPACE 0xff35
5554 #define IDX_POTFILE_DISABLE 0xff06
5555 #define IDX_DEBUG_MODE 0xff43
5556 #define IDX_DEBUG_FILE 0xff44
5557 #define IDX_INDUCTION_DIR 0xff46
5558 #define IDX_OUTFILE_CHECK_DIR 0xff47
5559 #define IDX_USERNAME 0xff07
5560 #define IDX_FORCE 0xff08
5561 #define IDX_RUNTIME 0xff09
5562 #define IDX_BENCHMARK 'b'
5563 #define IDX_HASH_MODE 'm'
5564 #define IDX_ATTACK_MODE 'a'
5565 #define IDX_RP_FILE 'r'
5566 #define IDX_RP_GEN 'g'
5567 #define IDX_RP_GEN_FUNC_MIN 0xff10
5568 #define IDX_RP_GEN_FUNC_MAX 0xff11
5569 #define IDX_RP_GEN_SEED 0xff34
5570 #define IDX_RULE_BUF_L 'j'
5571 #define IDX_RULE_BUF_R 'k'
5572 #define IDX_INCREMENT 'i'
5573 #define IDX_INCREMENT_MIN 0xff12
5574 #define IDX_INCREMENT_MAX 0xff13
5575 #define IDX_OUTFILE 'o'
5576 #define IDX_OUTFILE_FORMAT 0xff14
5577 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5578 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5579 #define IDX_RESTORE 0xff15
5580 #define IDX_RESTORE_DISABLE 0xff27
5581 #define IDX_STATUS 0xff17
5582 #define IDX_STATUS_TIMER 0xff18
5583 #define IDX_STATUS_AUTOMAT 0xff50
5584 #define IDX_LOOPBACK 0xff38
5585 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5586 #define IDX_SESSION 0xff19
5587 #define IDX_HEX_CHARSET 0xff20
5588 #define IDX_HEX_SALT 0xff21
5589 #define IDX_HEX_WORDLIST 0xff40
5590 #define IDX_MARKOV_DISABLE 0xff22
5591 #define IDX_MARKOV_CLASSIC 0xff23
5592 #define IDX_MARKOV_THRESHOLD 't'
5593 #define IDX_MARKOV_HCSTAT 0xff24
5594 #define IDX_CPU_AFFINITY 0xff25
5595 #define IDX_OPENCL_DEVICES 'd'
5596 #define IDX_OPENCL_PLATFORMS 0xff72
5597 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5598 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5599 #define IDX_WORKLOAD_PROFILE 'w'
5600 #define IDX_KERNEL_ACCEL 'n'
5601 #define IDX_KERNEL_LOOPS 'u'
5602 #define IDX_GPU_TEMP_DISABLE 0xff29
5603 #define IDX_GPU_TEMP_ABORT 0xff30
5604 #define IDX_GPU_TEMP_RETAIN 0xff31
5605 #define IDX_POWERTUNE_ENABLE 0xff41
5606 #define IDX_LOGFILE_DISABLE 0xff51
5607 #define IDX_TRUECRYPT_KEYFILES 0xff52
5608 #define IDX_SCRYPT_TMTO 0xff61
5609 #define IDX_SEGMENT_SIZE 'c'
5610 #define IDX_SEPARATOR 'p'
5611 #define IDX_BITMAP_MIN 0xff70
5612 #define IDX_BITMAP_MAX 0xff71
5613 #define IDX_CUSTOM_CHARSET_1 '1'
5614 #define IDX_CUSTOM_CHARSET_2 '2'
5615 #define IDX_CUSTOM_CHARSET_3 '3'
5616 #define IDX_CUSTOM_CHARSET_4 '4'
5617
5618 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5619
5620 struct option long_options[] =
5621 {
5622 {"help", no_argument, 0, IDX_HELP},
5623 {"version", no_argument, 0, IDX_VERSION},
5624 {"quiet", no_argument, 0, IDX_QUIET},
5625 {"show", no_argument, 0, IDX_SHOW},
5626 {"left", no_argument, 0, IDX_LEFT},
5627 {"username", no_argument, 0, IDX_USERNAME},
5628 {"remove", no_argument, 0, IDX_REMOVE},
5629 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5630 {"skip", required_argument, 0, IDX_SKIP},
5631 {"limit", required_argument, 0, IDX_LIMIT},
5632 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5633 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5634 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5635 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5636 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5637 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5638 {"force", no_argument, 0, IDX_FORCE},
5639 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5640 {"restore", no_argument, 0, IDX_RESTORE},
5641 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5642 {"status", no_argument, 0, IDX_STATUS},
5643 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5644 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5645 {"loopback", no_argument, 0, IDX_LOOPBACK},
5646 {"weak-hash-threshold",
5647 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5648 {"session", required_argument, 0, IDX_SESSION},
5649 {"runtime", required_argument, 0, IDX_RUNTIME},
5650 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5651 {"generate-rules-func-min",
5652 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5653 {"generate-rules-func-max",
5654 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5655 {"generate-rules-seed",
5656 required_argument, 0, IDX_RP_GEN_SEED},
5657 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5658 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5659 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5660 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5661 {"rules-file", required_argument, 0, IDX_RP_FILE},
5662 {"outfile", required_argument, 0, IDX_OUTFILE},
5663 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5664 {"outfile-autohex-disable",
5665 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5666 {"outfile-check-timer",
5667 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5668 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5669 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5670 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5671 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5672 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5673 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5674 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5675 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5676 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5677 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5678 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5679 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5680 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5681 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5682 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5683 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5684 #ifdef HAVE_HWMON
5685 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5686 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5687 #ifdef HAVE_ADL
5688 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5689 #endif
5690 #endif // HAVE_HWMON
5691 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5692 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5693 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5694 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5695 // deprecated
5696 {"seperator", required_argument, 0, IDX_SEPARATOR},
5697 {"separator", required_argument, 0, IDX_SEPARATOR},
5698 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5699 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5700 {"increment", no_argument, 0, IDX_INCREMENT},
5701 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5702 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5703 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5704 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5705 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5706 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5707
5708 {0, 0, 0, 0}
5709 };
5710
5711 uint rp_files_cnt = 0;
5712
5713 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5714
5715 int option_index = 0;
5716 int c = -1;
5717
5718 optind = 1;
5719 optopt = 0;
5720
5721 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5722 {
5723 switch (c)
5724 {
5725 case IDX_HELP: usage = 1; break;
5726 case IDX_VERSION:
5727 case IDX_VERSION_LOWER: version = 1; break;
5728 case IDX_RESTORE: restore = 1; break;
5729 case IDX_SESSION: session = optarg; break;
5730 case IDX_SHOW: show = 1; break;
5731 case IDX_LEFT: left = 1; break;
5732 case '?': return (-1);
5733 }
5734 }
5735
5736 if (optopt != 0)
5737 {
5738 log_error ("ERROR: Invalid argument specified");
5739
5740 return (-1);
5741 }
5742
5743 /**
5744 * exit functions
5745 */
5746
5747 if (version)
5748 {
5749 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5750
5751 return (0);
5752 }
5753
5754 if (usage)
5755 {
5756 usage_big_print (PROGNAME);
5757
5758 return (0);
5759 }
5760
5761 /**
5762 * session needs to be set, always!
5763 */
5764
5765 if (session == NULL) session = (char *) PROGNAME;
5766
5767 /**
5768 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5769 */
5770
5771 char *exec_path = get_exec_path ();
5772
5773 #ifdef LINUX
5774
5775 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5776 char *resolved_exec_path = realpath (exec_path, NULL);
5777
5778 char *install_dir = get_install_dir (resolved_exec_path);
5779 char *profile_dir = NULL;
5780 char *session_dir = NULL;
5781 char *shared_dir = NULL;
5782
5783 if (strcmp (install_dir, resolved_install_folder) == 0)
5784 {
5785 struct passwd *pw = getpwuid (getuid ());
5786
5787 const char *homedir = pw->pw_dir;
5788
5789 profile_dir = get_profile_dir (homedir);
5790 session_dir = get_session_dir (profile_dir);
5791 shared_dir = strdup (SHARED_FOLDER);
5792
5793 mkdir (profile_dir, 0700);
5794 mkdir (session_dir, 0700);
5795 }
5796 else
5797 {
5798 profile_dir = install_dir;
5799 session_dir = install_dir;
5800 shared_dir = install_dir;
5801 }
5802
5803 myfree (resolved_install_folder);
5804 myfree (resolved_exec_path);
5805
5806 #else
5807
5808 char *install_dir = get_install_dir (exec_path);
5809 char *profile_dir = install_dir;
5810 char *session_dir = install_dir;
5811 char *shared_dir = install_dir;
5812
5813 #endif
5814
5815 data.install_dir = install_dir;
5816 data.profile_dir = profile_dir;
5817 data.session_dir = session_dir;
5818 data.shared_dir = shared_dir;
5819
5820 myfree (exec_path);
5821
5822 /**
5823 * kernel cache, we need to make sure folder exist
5824 */
5825
5826 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5827
5828 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5829
5830 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5831
5832 mkdir (kernels_folder, 0700);
5833
5834 myfree (kernels_folder);
5835
5836 /**
5837 * session
5838 */
5839
5840 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5841
5842 data.session = session;
5843
5844 char *eff_restore_file = (char *) mymalloc (session_size);
5845 char *new_restore_file = (char *) mymalloc (session_size);
5846
5847 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5848 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5849
5850 data.eff_restore_file = eff_restore_file;
5851 data.new_restore_file = new_restore_file;
5852
5853 if (((show == 1) || (left == 1)) && (restore == 1))
5854 {
5855 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5856 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5857
5858 return (-1);
5859 }
5860
5861 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5862 if ((show == 1) || (left == 1))
5863 {
5864 restore_disable = 1;
5865
5866 restore = 0;
5867 }
5868
5869 data.restore_disable = restore_disable;
5870
5871 restore_data_t *rd = init_restore (argc, argv);
5872
5873 data.rd = rd;
5874
5875 /**
5876 * restore file
5877 */
5878
5879 if (restore == 1)
5880 {
5881 read_restore (eff_restore_file, rd);
5882
5883 if (rd->version_bin < RESTORE_MIN)
5884 {
5885 log_error ("ERROR: Incompatible restore-file version");
5886
5887 return (-1);
5888 }
5889
5890 myargc = rd->argc;
5891 myargv = rd->argv;
5892
5893 #ifdef _POSIX
5894 rd->pid = getpid ();
5895 #elif _WIN
5896 rd->pid = GetCurrentProcessId ();
5897 #endif
5898 }
5899
5900 uint hash_mode_chgd = 0;
5901 uint runtime_chgd = 0;
5902 uint kernel_loops_chgd = 0;
5903 uint kernel_accel_chgd = 0;
5904 uint attack_mode_chgd = 0;
5905 uint outfile_format_chgd = 0;
5906 uint rp_gen_seed_chgd = 0;
5907 uint remove_timer_chgd = 0;
5908 uint increment_min_chgd = 0;
5909 uint increment_max_chgd = 0;
5910 uint workload_profile_chgd = 0;
5911 uint opencl_vector_width_chgd = 0;
5912
5913 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5914 uint gpu_temp_retain_chgd = 0;
5915 uint gpu_temp_abort_chgd = 0;
5916 #endif
5917
5918 optind = 1;
5919 optopt = 0;
5920 option_index = 0;
5921
5922 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5923 {
5924 switch (c)
5925 {
5926 //case IDX_HELP: usage = 1; break;
5927 //case IDX_VERSION: version = 1; break;
5928 //case IDX_RESTORE: restore = 1; break;
5929 case IDX_QUIET: quiet = 1; break;
5930 //case IDX_SHOW: show = 1; break;
5931 case IDX_SHOW: break;
5932 //case IDX_LEFT: left = 1; break;
5933 case IDX_LEFT: break;
5934 case IDX_USERNAME: username = 1; break;
5935 case IDX_REMOVE: remove = 1; break;
5936 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5937 remove_timer_chgd = 1; break;
5938 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5939 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5940 case IDX_DEBUG_FILE: debug_file = optarg; break;
5941 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5942 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5943 case IDX_FORCE: force = 1; break;
5944 case IDX_SKIP: skip = atoll (optarg); break;
5945 case IDX_LIMIT: limit = atoll (optarg); break;
5946 case IDX_KEYSPACE: keyspace = 1; break;
5947 case IDX_BENCHMARK: benchmark = 1; break;
5948 case IDX_RESTORE: break;
5949 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5950 case IDX_STATUS: status = 1; break;
5951 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5952 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5953 case IDX_LOOPBACK: loopback = 1; break;
5954 case IDX_WEAK_HASH_THRESHOLD:
5955 weak_hash_threshold = atoi (optarg); break;
5956 //case IDX_SESSION: session = optarg; break;
5957 case IDX_SESSION: break;
5958 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5959 hash_mode_chgd = 1; break;
5960 case IDX_RUNTIME: runtime = atoi (optarg);
5961 runtime_chgd = 1; break;
5962 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5963 attack_mode_chgd = 1; break;
5964 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5965 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5966 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5967 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5968 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5969 rp_gen_seed_chgd = 1; break;
5970 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5971 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5972 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5973 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5974 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5975 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5976 case IDX_OUTFILE: outfile = optarg; break;
5977 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5978 outfile_format_chgd = 1; break;
5979 case IDX_OUTFILE_AUTOHEX_DISABLE:
5980 outfile_autohex = 0; break;
5981 case IDX_OUTFILE_CHECK_TIMER:
5982 outfile_check_timer = atoi (optarg); break;
5983 case IDX_HEX_CHARSET: hex_charset = 1; break;
5984 case IDX_HEX_SALT: hex_salt = 1; break;
5985 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5986 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5987 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5988 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5989 case IDX_OPENCL_DEVICE_TYPES:
5990 opencl_device_types = optarg; break;
5991 case IDX_OPENCL_VECTOR_WIDTH:
5992 opencl_vector_width = atoi (optarg);
5993 opencl_vector_width_chgd = 1; break;
5994 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5995 workload_profile_chgd = 1; break;
5996 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5997 kernel_accel_chgd = 1; break;
5998 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5999 kernel_loops_chgd = 1; break;
6000 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6001 #ifdef HAVE_HWMON
6002 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6003 #ifdef HAVE_ADL
6004 gpu_temp_abort_chgd = 1;
6005 #endif
6006 break;
6007 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6008 #ifdef HAVE_ADL
6009 gpu_temp_retain_chgd = 1;
6010 #endif
6011 break;
6012 #ifdef HAVE_ADL
6013 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6014 #endif
6015 #endif // HAVE_HWMON
6016 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6017 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6018 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6019 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6020 case IDX_SEPARATOR: separator = optarg[0]; break;
6021 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6022 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6023 case IDX_INCREMENT: increment = 1; break;
6024 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6025 increment_min_chgd = 1; break;
6026 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6027 increment_max_chgd = 1; break;
6028 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6029 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6030 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6031 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6032
6033 default:
6034 log_error ("ERROR: Invalid argument specified");
6035 return (-1);
6036 }
6037 }
6038
6039 if (optopt != 0)
6040 {
6041 log_error ("ERROR: Invalid argument specified");
6042
6043 return (-1);
6044 }
6045
6046 /**
6047 * Inform user things getting started,
6048 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6049 * - we do not need to check algorithm_pos
6050 */
6051
6052 if (quiet == 0)
6053 {
6054 if (benchmark == 1)
6055 {
6056 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6057
6058 log_info ("");
6059 }
6060 else if (restore == 1)
6061 {
6062 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6063
6064 log_info ("");
6065 }
6066 else
6067 {
6068 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6069
6070 log_info ("");
6071 }
6072 }
6073
6074 /**
6075 * sanity check
6076 */
6077
6078 if (attack_mode > 7)
6079 {
6080 log_error ("ERROR: Invalid attack-mode specified");
6081
6082 return (-1);
6083 }
6084
6085 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6086 {
6087 log_error ("ERROR: Invalid runtime specified");
6088
6089 return (-1);
6090 }
6091
6092 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
6093 {
6094 log_error ("ERROR: Invalid hash-type specified");
6095
6096 return (-1);
6097 }
6098
6099 // renamed hash modes
6100
6101 if (hash_mode_chgd)
6102 {
6103 int n = -1;
6104
6105 switch (hash_mode)
6106 {
6107 case 123: n = 124;
6108 break;
6109 }
6110
6111 if (n >= 0)
6112 {
6113 log_error ("Old -m specified, use -m %d instead", n);
6114
6115 return (-1);
6116 }
6117 }
6118
6119 if (username == 1)
6120 {
6121 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6122 {
6123 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6124
6125 return (-1);
6126 }
6127 }
6128
6129 if (outfile_format > 16)
6130 {
6131 log_error ("ERROR: Invalid outfile-format specified");
6132
6133 return (-1);
6134 }
6135
6136 if (left == 1)
6137 {
6138 if (outfile_format_chgd == 1)
6139 {
6140 if (outfile_format > 1)
6141 {
6142 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6143
6144 return (-1);
6145 }
6146 }
6147 else
6148 {
6149 outfile_format = OUTFILE_FMT_HASH;
6150 }
6151 }
6152
6153 if (show == 1)
6154 {
6155 if (outfile_format_chgd == 1)
6156 {
6157 if ((outfile_format > 7) && (outfile_format < 16))
6158 {
6159 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6160
6161 return (-1);
6162 }
6163 }
6164 }
6165
6166 if (increment_min < INCREMENT_MIN)
6167 {
6168 log_error ("ERROR: Invalid increment-min specified");
6169
6170 return (-1);
6171 }
6172
6173 if (increment_max > INCREMENT_MAX)
6174 {
6175 log_error ("ERROR: Invalid increment-max specified");
6176
6177 return (-1);
6178 }
6179
6180 if (increment_min > increment_max)
6181 {
6182 log_error ("ERROR: Invalid increment-min specified");
6183
6184 return (-1);
6185 }
6186
6187 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6188 {
6189 log_error ("ERROR: increment is not allowed in attack-mode 0");
6190
6191 return (-1);
6192 }
6193
6194 if ((increment == 0) && (increment_min_chgd == 1))
6195 {
6196 log_error ("ERROR: increment-min is only supported together with increment switch");
6197
6198 return (-1);
6199 }
6200
6201 if ((increment == 0) && (increment_max_chgd == 1))
6202 {
6203 log_error ("ERROR: increment-max is only supported together with increment switch");
6204
6205 return (-1);
6206 }
6207
6208 if (rp_files_cnt && rp_gen)
6209 {
6210 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6211
6212 return (-1);
6213 }
6214
6215 if (rp_files_cnt || rp_gen)
6216 {
6217 if (attack_mode != ATTACK_MODE_STRAIGHT)
6218 {
6219 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6220
6221 return (-1);
6222 }
6223 }
6224
6225 if (rp_gen_func_min > rp_gen_func_max)
6226 {
6227 log_error ("ERROR: Invalid rp-gen-func-min specified");
6228
6229 return (-1);
6230 }
6231
6232 if (kernel_accel_chgd == 1 && kernel_loops_chgd == 0)
6233 {
6234 log_error ("ERROR: If kernel-accel is specified, kernel-loops need to be specified as well");
6235
6236 return (-1);
6237 }
6238
6239 if (kernel_loops_chgd == 1 && kernel_accel_chgd == 0)
6240 {
6241 log_error ("ERROR: If kernel-loops is specified, kernel-accel need to be specified as well");
6242
6243 return (-1);
6244 }
6245
6246 if (kernel_accel_chgd == 1)
6247 {
6248 if (kernel_accel < 1)
6249 {
6250 log_error ("ERROR: Invalid kernel-accel specified");
6251
6252 return (-1);
6253 }
6254
6255 if (kernel_accel > 1024)
6256 {
6257 log_error ("ERROR: Invalid kernel-accel specified");
6258
6259 return (-1);
6260 }
6261 }
6262
6263 if (kernel_loops_chgd == 1)
6264 {
6265 if (kernel_loops < 1)
6266 {
6267 log_error ("ERROR: Invalid kernel-loops specified");
6268
6269 return (-1);
6270 }
6271
6272 if (kernel_loops > 1024)
6273 {
6274 log_error ("ERROR: Invalid kernel-loops specified");
6275
6276 return (-1);
6277 }
6278 }
6279
6280 if ((workload_profile < 1) || (workload_profile > 3))
6281 {
6282 log_error ("ERROR: workload-profile %i not available", workload_profile);
6283
6284 return (-1);
6285 }
6286
6287 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6288 {
6289 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6290
6291 return (-1);
6292 }
6293
6294 if (show == 1 || left == 1)
6295 {
6296 attack_mode = ATTACK_MODE_NONE;
6297
6298 if (remove == 1)
6299 {
6300 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6301
6302 return (-1);
6303 }
6304
6305 if (potfile_disable == 1)
6306 {
6307 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6308
6309 return (-1);
6310 }
6311 }
6312
6313 uint attack_kern = ATTACK_KERN_NONE;
6314
6315 switch (attack_mode)
6316 {
6317 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6318 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6319 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6320 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6321 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6322 }
6323
6324 if (benchmark == 0)
6325 {
6326 if (keyspace == 1)
6327 {
6328 int num_additional_params = 1;
6329
6330 if (attack_kern == ATTACK_KERN_COMBI)
6331 {
6332 num_additional_params = 2;
6333 }
6334
6335 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6336
6337 if (keyspace_wordlist_specified == 0) optind--;
6338 }
6339
6340 if (attack_kern == ATTACK_KERN_NONE)
6341 {
6342 if ((optind + 1) != myargc)
6343 {
6344 usage_mini_print (myargv[0]);
6345
6346 return (-1);
6347 }
6348 }
6349 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6350 {
6351 if ((optind + 1) > myargc)
6352 {
6353 usage_mini_print (myargv[0]);
6354
6355 return (-1);
6356 }
6357 }
6358 else if (attack_kern == ATTACK_KERN_COMBI)
6359 {
6360 if ((optind + 3) != myargc)
6361 {
6362 usage_mini_print (myargv[0]);
6363
6364 return (-1);
6365 }
6366 }
6367 else if (attack_kern == ATTACK_KERN_BF)
6368 {
6369 if ((optind + 1) > myargc)
6370 {
6371 usage_mini_print (myargv[0]);
6372
6373 return (-1);
6374 }
6375 }
6376 else
6377 {
6378 usage_mini_print (myargv[0]);
6379
6380 return (-1);
6381 }
6382 }
6383 else
6384 {
6385 if (myargv[optind] != 0)
6386 {
6387 log_error ("ERROR: Invalid argument for benchmark mode specified");
6388
6389 return (-1);
6390 }
6391
6392 if (attack_mode_chgd == 1)
6393 {
6394 if (attack_mode != ATTACK_MODE_BF)
6395 {
6396 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6397
6398 return (-1);
6399 }
6400 }
6401 }
6402
6403 if (skip != 0 && limit != 0)
6404 {
6405 limit += skip;
6406 }
6407
6408 if (keyspace == 1)
6409 {
6410 if (show == 1)
6411 {
6412 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6413
6414 return (-1);
6415 }
6416 else if (left == 1)
6417 {
6418 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6419
6420 return (-1);
6421 }
6422
6423 potfile_disable = 1;
6424
6425 restore_disable = 1;
6426
6427 restore = 0;
6428
6429 weak_hash_threshold = 0;
6430
6431 quiet = 1;
6432 }
6433
6434 if (remove_timer_chgd == 1)
6435 {
6436 if (remove == 0)
6437 {
6438 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6439
6440 return (-1);
6441 }
6442
6443 if (remove_timer < 1)
6444 {
6445 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6446
6447 return (-1);
6448 }
6449 }
6450
6451 if (loopback == 1)
6452 {
6453 if (attack_mode == ATTACK_MODE_BF)
6454 {
6455 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6456
6457 return (-1);
6458 }
6459 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6460 {
6461 if ((rp_files_cnt == 0) && (rp_gen == 0))
6462 {
6463 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6464
6465 return (-1);
6466 }
6467 }
6468 }
6469
6470 if (debug_mode > 0)
6471 {
6472 if (attack_mode != ATTACK_MODE_STRAIGHT)
6473 {
6474 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6475
6476 return (-1);
6477 }
6478
6479 if ((rp_files_cnt == 0) && (rp_gen == 0))
6480 {
6481 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6482
6483 return (-1);
6484 }
6485 }
6486
6487 if (debug_mode > 4)
6488 {
6489 log_error ("ERROR: Invalid debug-mode specified");
6490
6491 return (-1);
6492 }
6493
6494 if (debug_file != NULL)
6495 {
6496 if (debug_mode < 1)
6497 {
6498 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6499
6500 return (-1);
6501 }
6502 }
6503
6504 if (induction_dir != NULL)
6505 {
6506 if (attack_mode == ATTACK_MODE_BF)
6507 {
6508 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6509
6510 return (-1);
6511 }
6512 }
6513
6514 if (attack_mode != ATTACK_MODE_STRAIGHT)
6515 {
6516 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6517 {
6518 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6519
6520 return (-1);
6521 }
6522
6523 weak_hash_threshold = 0;
6524 }
6525
6526 /**
6527 * induction directory
6528 */
6529
6530 char *induction_directory = NULL;
6531
6532 if (attack_mode != ATTACK_MODE_BF)
6533 {
6534 if (induction_dir == NULL)
6535 {
6536 induction_directory = (char *) mymalloc (session_size);
6537
6538 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6539
6540 // create induction folder if it does not already exist
6541
6542 if (keyspace == 0)
6543 {
6544 if (rmdir (induction_directory) == -1)
6545 {
6546 if (errno == ENOENT)
6547 {
6548 // good, we can ignore
6549 }
6550 else if (errno == ENOTEMPTY)
6551 {
6552 char *induction_directory_mv = (char *) mymalloc (session_size);
6553
6554 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6555
6556 if (rename (induction_directory, induction_directory_mv) != 0)
6557 {
6558 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6559
6560 return (-1);
6561 }
6562 }
6563 else
6564 {
6565 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6566
6567 return (-1);
6568 }
6569 }
6570
6571 if (mkdir (induction_directory, 0700) == -1)
6572 {
6573 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6574
6575 return (-1);
6576 }
6577 }
6578 }
6579 else
6580 {
6581 induction_directory = induction_dir;
6582 }
6583 }
6584
6585 data.induction_directory = induction_directory;
6586
6587 /**
6588 * loopback
6589 */
6590
6591 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6592
6593 char *loopback_file = (char *) mymalloc (loopback_size);
6594
6595 /**
6596 * tuning db
6597 */
6598
6599 char tuning_db_file[256] = { 0 };
6600
6601 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6602
6603 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6604
6605 /**
6606 * outfile-check directory
6607 */
6608
6609 char *outfile_check_directory = NULL;
6610
6611 if (outfile_check_dir == NULL)
6612 {
6613 outfile_check_directory = (char *) mymalloc (session_size);
6614
6615 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6616 }
6617 else
6618 {
6619 outfile_check_directory = outfile_check_dir;
6620 }
6621
6622 data.outfile_check_directory = outfile_check_directory;
6623
6624 if (keyspace == 0)
6625 {
6626 struct stat outfile_check_stat;
6627
6628 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6629 {
6630 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6631
6632 if (is_dir == 0)
6633 {
6634 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6635
6636 return (-1);
6637 }
6638 }
6639 else if (outfile_check_dir == NULL)
6640 {
6641 if (mkdir (outfile_check_directory, 0700) == -1)
6642 {
6643 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6644
6645 return (-1);
6646 }
6647 }
6648 }
6649
6650 /**
6651 * special other stuff
6652 */
6653
6654 if (hash_mode == 9710)
6655 {
6656 outfile_format = 5;
6657 outfile_format_chgd = 1;
6658 }
6659
6660 if (hash_mode == 9810)
6661 {
6662 outfile_format = 5;
6663 outfile_format_chgd = 1;
6664 }
6665
6666 if (hash_mode == 10410)
6667 {
6668 outfile_format = 5;
6669 outfile_format_chgd = 1;
6670 }
6671
6672 /**
6673 * store stuff
6674 */
6675
6676 data.hash_mode = hash_mode;
6677 data.restore = restore;
6678 data.restore_timer = restore_timer;
6679 data.restore_disable = restore_disable;
6680 data.status = status;
6681 data.status_timer = status_timer;
6682 data.status_automat = status_automat;
6683 data.loopback = loopback;
6684 data.runtime = runtime;
6685 data.remove = remove;
6686 data.remove_timer = remove_timer;
6687 data.debug_mode = debug_mode;
6688 data.debug_file = debug_file;
6689 data.username = username;
6690 data.quiet = quiet;
6691 data.outfile = outfile;
6692 data.outfile_format = outfile_format;
6693 data.outfile_autohex = outfile_autohex;
6694 data.hex_charset = hex_charset;
6695 data.hex_salt = hex_salt;
6696 data.hex_wordlist = hex_wordlist;
6697 data.separator = separator;
6698 data.rp_files = rp_files;
6699 data.rp_files_cnt = rp_files_cnt;
6700 data.rp_gen = rp_gen;
6701 data.rp_gen_seed = rp_gen_seed;
6702 data.force = force;
6703 data.benchmark = benchmark;
6704 data.skip = skip;
6705 data.limit = limit;
6706 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6707 data.powertune_enable = powertune_enable;
6708 #endif
6709 data.logfile_disable = logfile_disable;
6710 data.truecrypt_keyfiles = truecrypt_keyfiles;
6711 data.scrypt_tmto = scrypt_tmto;
6712 data.workload_profile = workload_profile;
6713
6714 /**
6715 * cpu affinity
6716 */
6717
6718 if (cpu_affinity)
6719 {
6720 set_cpu_affinity (cpu_affinity);
6721 }
6722
6723 if (rp_gen_seed_chgd == 0)
6724 {
6725 srand (proc_start);
6726 }
6727 else
6728 {
6729 srand (rp_gen_seed);
6730 }
6731
6732 /**
6733 * logfile init
6734 */
6735
6736 if (logfile_disable == 0)
6737 {
6738 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6739
6740 char *logfile = (char *) mymalloc (logfile_size);
6741
6742 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6743
6744 data.logfile = logfile;
6745
6746 char *topid = logfile_generate_topid ();
6747
6748 data.topid = topid;
6749 }
6750
6751 // logfile_append() checks for logfile_disable internally to make it easier from here
6752
6753 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6754 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6755 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6756 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6757 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6758 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6759 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6760 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6761 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6762 #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));
6763
6764 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6765 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6766 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6767 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6768 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6769 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6770 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6771 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6772
6773 logfile_top_msg ("START");
6774
6775 logfile_top_uint (attack_mode);
6776 logfile_top_uint (attack_kern);
6777 logfile_top_uint (benchmark);
6778 logfile_top_uint (bitmap_min);
6779 logfile_top_uint (bitmap_max);
6780 logfile_top_uint (debug_mode);
6781 logfile_top_uint (force);
6782 logfile_top_uint (kernel_accel);
6783 logfile_top_uint (kernel_loops);
6784 logfile_top_uint (gpu_temp_disable);
6785 #ifdef HAVE_HWMON
6786 logfile_top_uint (gpu_temp_abort);
6787 logfile_top_uint (gpu_temp_retain);
6788 #endif
6789 logfile_top_uint (hash_mode);
6790 logfile_top_uint (hex_charset);
6791 logfile_top_uint (hex_salt);
6792 logfile_top_uint (hex_wordlist);
6793 logfile_top_uint (increment);
6794 logfile_top_uint (increment_max);
6795 logfile_top_uint (increment_min);
6796 logfile_top_uint (keyspace);
6797 logfile_top_uint (left);
6798 logfile_top_uint (logfile_disable);
6799 logfile_top_uint (loopback);
6800 logfile_top_uint (markov_classic);
6801 logfile_top_uint (markov_disable);
6802 logfile_top_uint (markov_threshold);
6803 logfile_top_uint (outfile_autohex);
6804 logfile_top_uint (outfile_check_timer);
6805 logfile_top_uint (outfile_format);
6806 logfile_top_uint (potfile_disable);
6807 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6808 logfile_top_uint (powertune_enable);
6809 #endif
6810 logfile_top_uint (scrypt_tmto);
6811 logfile_top_uint (quiet);
6812 logfile_top_uint (remove);
6813 logfile_top_uint (remove_timer);
6814 logfile_top_uint (restore);
6815 logfile_top_uint (restore_disable);
6816 logfile_top_uint (restore_timer);
6817 logfile_top_uint (rp_gen);
6818 logfile_top_uint (rp_gen_func_max);
6819 logfile_top_uint (rp_gen_func_min);
6820 logfile_top_uint (rp_gen_seed);
6821 logfile_top_uint (runtime);
6822 logfile_top_uint (segment_size);
6823 logfile_top_uint (show);
6824 logfile_top_uint (status);
6825 logfile_top_uint (status_automat);
6826 logfile_top_uint (status_timer);
6827 logfile_top_uint (usage);
6828 logfile_top_uint (username);
6829 logfile_top_uint (version);
6830 logfile_top_uint (weak_hash_threshold);
6831 logfile_top_uint (workload_profile);
6832 logfile_top_uint64 (limit);
6833 logfile_top_uint64 (skip);
6834 logfile_top_char (separator);
6835 logfile_top_string (cpu_affinity);
6836 logfile_top_string (custom_charset_1);
6837 logfile_top_string (custom_charset_2);
6838 logfile_top_string (custom_charset_3);
6839 logfile_top_string (custom_charset_4);
6840 logfile_top_string (debug_file);
6841 logfile_top_string (opencl_devices);
6842 logfile_top_string (opencl_platforms);
6843 logfile_top_string (opencl_device_types);
6844 logfile_top_uint (opencl_vector_width);
6845 logfile_top_string (induction_dir);
6846 logfile_top_string (markov_hcstat);
6847 logfile_top_string (outfile);
6848 logfile_top_string (outfile_check_dir);
6849 logfile_top_string (rule_buf_l);
6850 logfile_top_string (rule_buf_r);
6851 logfile_top_string (session);
6852 logfile_top_string (truecrypt_keyfiles);
6853
6854 /**
6855 * Init OpenCL library loader
6856 */
6857
6858 if (keyspace == 0)
6859 {
6860 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6861
6862 ocl_init (ocl);
6863
6864 data.ocl = ocl;
6865 }
6866
6867 /**
6868 * OpenCL platform selection
6869 */
6870
6871 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6872
6873 /**
6874 * OpenCL device selection
6875 */
6876
6877 u32 devices_filter = setup_devices_filter (opencl_devices);
6878
6879 /**
6880 * OpenCL device type selection
6881 */
6882
6883 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6884
6885 /**
6886 * benchmark
6887 */
6888
6889 if (benchmark == 1)
6890 {
6891 /**
6892 * disable useless stuff for benchmark
6893 */
6894
6895 status_timer = 0;
6896 restore_timer = 0;
6897 restore_disable = 1;
6898 potfile_disable = 1;
6899 weak_hash_threshold = 0;
6900 gpu_temp_disable = 1;
6901
6902 data.status_timer = status_timer;
6903 data.restore_timer = restore_timer;
6904 data.restore_disable = restore_disable;
6905
6906 /**
6907 * force attack mode to be bruteforce
6908 */
6909
6910 attack_mode = ATTACK_MODE_BF;
6911 attack_kern = ATTACK_KERN_BF;
6912
6913 if (workload_profile_chgd == 0)
6914 {
6915 workload_profile = 3;
6916
6917 data.workload_profile = workload_profile;
6918 }
6919 }
6920
6921 /**
6922 * config
6923 */
6924
6925 uint hash_type = 0;
6926 uint salt_type = 0;
6927 uint attack_exec = 0;
6928 uint opts_type = 0;
6929 uint kern_type = 0;
6930 uint dgst_size = 0;
6931 uint esalt_size = 0;
6932 uint opti_type = 0;
6933 uint dgst_pos0 = -1;
6934 uint dgst_pos1 = -1;
6935 uint dgst_pos2 = -1;
6936 uint dgst_pos3 = -1;
6937
6938 int (*parse_func) (char *, uint, hash_t *);
6939 int (*sort_by_digest) (const void *, const void *);
6940
6941 uint algorithm_pos = 0;
6942 uint algorithm_max = 1;
6943
6944 uint *algorithms = default_benchmark_algorithms;
6945
6946 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6947
6948 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6949 {
6950 /*
6951 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6952 * the following algos are skipped entirely
6953 */
6954
6955 if (algorithm_pos > 0)
6956 {
6957 local_free (rd);
6958
6959 rd = init_restore (argc, argv);
6960
6961 data.rd = rd;
6962 }
6963
6964 /**
6965 * update hash_mode in case of multihash benchmark
6966 */
6967
6968 if (benchmark == 1)
6969 {
6970 if (hash_mode_chgd == 0)
6971 {
6972 hash_mode = algorithms[algorithm_pos];
6973
6974 data.hash_mode = hash_mode;
6975 }
6976
6977 quiet = 1;
6978
6979 data.quiet = quiet;
6980 }
6981
6982 switch (hash_mode)
6983 {
6984 case 0: hash_type = HASH_TYPE_MD5;
6985 salt_type = SALT_TYPE_NONE;
6986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6987 opts_type = OPTS_TYPE_PT_GENERATE_LE
6988 | OPTS_TYPE_PT_ADD80
6989 | OPTS_TYPE_PT_ADDBITS14;
6990 kern_type = KERN_TYPE_MD5;
6991 dgst_size = DGST_SIZE_4_4;
6992 parse_func = md5_parse_hash;
6993 sort_by_digest = sort_by_digest_4_4;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_MEET_IN_MIDDLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_NOT_SALTED
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 0;
7003 dgst_pos1 = 3;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 10: hash_type = HASH_TYPE_MD5;
7009 salt_type = SALT_TYPE_INTERN;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_LE
7012 | OPTS_TYPE_ST_ADD80
7013 | OPTS_TYPE_ST_ADDBITS14;
7014 kern_type = KERN_TYPE_MD5_PWSLT;
7015 dgst_size = DGST_SIZE_4_4;
7016 parse_func = md5s_parse_hash;
7017 sort_by_digest = sort_by_digest_4_4;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_PRECOMPUTE_INIT
7020 | OPTI_TYPE_PRECOMPUTE_MERKLE
7021 | OPTI_TYPE_MEET_IN_MIDDLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_APPENDED_SALT
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 11: hash_type = HASH_TYPE_MD5;
7033 salt_type = SALT_TYPE_INTERN;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_LE
7036 | OPTS_TYPE_ST_ADD80
7037 | OPTS_TYPE_ST_ADDBITS14;
7038 kern_type = KERN_TYPE_MD5_PWSLT;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = joomla_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_MEET_IN_MIDDLE
7046 | OPTI_TYPE_EARLY_SKIP
7047 | OPTI_TYPE_NOT_ITERATED
7048 | OPTI_TYPE_APPENDED_SALT
7049 | OPTI_TYPE_RAW_HASH;
7050 dgst_pos0 = 0;
7051 dgst_pos1 = 3;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 1;
7054 break;
7055
7056 case 12: hash_type = HASH_TYPE_MD5;
7057 salt_type = SALT_TYPE_INTERN;
7058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7059 opts_type = OPTS_TYPE_PT_GENERATE_LE
7060 | OPTS_TYPE_ST_ADD80
7061 | OPTS_TYPE_ST_ADDBITS14;
7062 kern_type = KERN_TYPE_MD5_PWSLT;
7063 dgst_size = DGST_SIZE_4_4;
7064 parse_func = postgresql_parse_hash;
7065 sort_by_digest = sort_by_digest_4_4;
7066 opti_type = OPTI_TYPE_ZERO_BYTE
7067 | OPTI_TYPE_PRECOMPUTE_INIT
7068 | OPTI_TYPE_PRECOMPUTE_MERKLE
7069 | OPTI_TYPE_MEET_IN_MIDDLE
7070 | OPTI_TYPE_EARLY_SKIP
7071 | OPTI_TYPE_NOT_ITERATED
7072 | OPTI_TYPE_APPENDED_SALT
7073 | OPTI_TYPE_RAW_HASH;
7074 dgst_pos0 = 0;
7075 dgst_pos1 = 3;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 1;
7078 break;
7079
7080 case 20: hash_type = HASH_TYPE_MD5;
7081 salt_type = SALT_TYPE_INTERN;
7082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7083 opts_type = OPTS_TYPE_PT_GENERATE_LE
7084 | OPTS_TYPE_PT_ADD80
7085 | OPTS_TYPE_PT_ADDBITS14;
7086 kern_type = KERN_TYPE_MD5_SLTPW;
7087 dgst_size = DGST_SIZE_4_4;
7088 parse_func = md5s_parse_hash;
7089 sort_by_digest = sort_by_digest_4_4;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_PRECOMPUTE_INIT
7092 | OPTI_TYPE_PRECOMPUTE_MERKLE
7093 | OPTI_TYPE_EARLY_SKIP
7094 | OPTI_TYPE_NOT_ITERATED
7095 | OPTI_TYPE_PREPENDED_SALT
7096 | OPTI_TYPE_RAW_HASH;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 21: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS14;
7109 kern_type = KERN_TYPE_MD5_SLTPW;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = osc_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_PRECOMPUTE_INIT
7115 | OPTI_TYPE_PRECOMPUTE_MERKLE
7116 | OPTI_TYPE_EARLY_SKIP
7117 | OPTI_TYPE_NOT_ITERATED
7118 | OPTI_TYPE_PREPENDED_SALT
7119 | OPTI_TYPE_RAW_HASH;
7120 dgst_pos0 = 0;
7121 dgst_pos1 = 3;
7122 dgst_pos2 = 2;
7123 dgst_pos3 = 1;
7124 break;
7125
7126 case 22: hash_type = HASH_TYPE_MD5;
7127 salt_type = SALT_TYPE_EMBEDDED;
7128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7129 opts_type = OPTS_TYPE_PT_GENERATE_LE
7130 | OPTS_TYPE_PT_ADD80
7131 | OPTS_TYPE_PT_ADDBITS14;
7132 kern_type = KERN_TYPE_MD5_SLTPW;
7133 dgst_size = DGST_SIZE_4_4;
7134 parse_func = netscreen_parse_hash;
7135 sort_by_digest = sort_by_digest_4_4;
7136 opti_type = OPTI_TYPE_ZERO_BYTE
7137 | OPTI_TYPE_PRECOMPUTE_INIT
7138 | OPTI_TYPE_PRECOMPUTE_MERKLE
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_PREPENDED_SALT
7142 | OPTI_TYPE_RAW_HASH;
7143 dgst_pos0 = 0;
7144 dgst_pos1 = 3;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 23: hash_type = HASH_TYPE_MD5;
7150 salt_type = SALT_TYPE_EMBEDDED;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_LE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS14;
7155 kern_type = KERN_TYPE_MD5_SLTPW;
7156 dgst_size = DGST_SIZE_4_4;
7157 parse_func = skype_parse_hash;
7158 sort_by_digest = sort_by_digest_4_4;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_PREPENDED_SALT
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 0;
7167 dgst_pos1 = 3;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 30: hash_type = HASH_TYPE_MD5;
7173 salt_type = SALT_TYPE_INTERN;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_LE
7176 | OPTS_TYPE_PT_UNICODE
7177 | OPTS_TYPE_ST_ADD80
7178 | OPTS_TYPE_ST_ADDBITS14;
7179 kern_type = KERN_TYPE_MD5_PWUSLT;
7180 dgst_size = DGST_SIZE_4_4;
7181 parse_func = md5s_parse_hash;
7182 sort_by_digest = sort_by_digest_4_4;
7183 opti_type = OPTI_TYPE_ZERO_BYTE
7184 | OPTI_TYPE_PRECOMPUTE_INIT
7185 | OPTI_TYPE_PRECOMPUTE_MERKLE
7186 | OPTI_TYPE_MEET_IN_MIDDLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_APPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 0;
7192 dgst_pos1 = 3;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 40: hash_type = HASH_TYPE_MD5;
7198 salt_type = SALT_TYPE_INTERN;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_LE
7201 | OPTS_TYPE_PT_ADD80
7202 | OPTS_TYPE_PT_ADDBITS14
7203 | OPTS_TYPE_PT_UNICODE;
7204 kern_type = KERN_TYPE_MD5_SLTPWU;
7205 dgst_size = DGST_SIZE_4_4;
7206 parse_func = md5s_parse_hash;
7207 sort_by_digest = sort_by_digest_4_4;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_PREPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 3;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 50: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE
7225 | OPTS_TYPE_ST_ADD80
7226 | OPTS_TYPE_ST_ADDBITS14;
7227 kern_type = KERN_TYPE_HMACMD5_PW;
7228 dgst_size = DGST_SIZE_4_4;
7229 parse_func = hmacmd5_parse_hash;
7230 sort_by_digest = sort_by_digest_4_4;
7231 opti_type = OPTI_TYPE_ZERO_BYTE
7232 | OPTI_TYPE_NOT_ITERATED;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 3;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 1;
7237 break;
7238
7239 case 60: 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 kern_type = KERN_TYPE_HMACMD5_SLT;
7246 dgst_size = DGST_SIZE_4_4;
7247 parse_func = hmacmd5_parse_hash;
7248 sort_by_digest = sort_by_digest_4_4;
7249 opti_type = OPTI_TYPE_ZERO_BYTE
7250 | OPTI_TYPE_NOT_ITERATED;
7251 dgst_pos0 = 0;
7252 dgst_pos1 = 3;
7253 dgst_pos2 = 2;
7254 dgst_pos3 = 1;
7255 break;
7256
7257 case 100: hash_type = HASH_TYPE_SHA1;
7258 salt_type = SALT_TYPE_NONE;
7259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7260 opts_type = OPTS_TYPE_PT_GENERATE_BE
7261 | OPTS_TYPE_PT_ADD80
7262 | OPTS_TYPE_PT_ADDBITS15;
7263 kern_type = KERN_TYPE_SHA1;
7264 dgst_size = DGST_SIZE_4_5;
7265 parse_func = sha1_parse_hash;
7266 sort_by_digest = sort_by_digest_4_5;
7267 opti_type = OPTI_TYPE_ZERO_BYTE
7268 | OPTI_TYPE_PRECOMPUTE_INIT
7269 | OPTI_TYPE_PRECOMPUTE_MERKLE
7270 | OPTI_TYPE_EARLY_SKIP
7271 | OPTI_TYPE_NOT_ITERATED
7272 | OPTI_TYPE_NOT_SALTED
7273 | OPTI_TYPE_RAW_HASH;
7274 dgst_pos0 = 3;
7275 dgst_pos1 = 4;
7276 dgst_pos2 = 2;
7277 dgst_pos3 = 1;
7278 break;
7279
7280 case 101: hash_type = HASH_TYPE_SHA1;
7281 salt_type = SALT_TYPE_NONE;
7282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7283 opts_type = OPTS_TYPE_PT_GENERATE_BE
7284 | OPTS_TYPE_PT_ADD80
7285 | OPTS_TYPE_PT_ADDBITS15;
7286 kern_type = KERN_TYPE_SHA1;
7287 dgst_size = DGST_SIZE_4_5;
7288 parse_func = sha1b64_parse_hash;
7289 sort_by_digest = sort_by_digest_4_5;
7290 opti_type = OPTI_TYPE_ZERO_BYTE
7291 | OPTI_TYPE_PRECOMPUTE_INIT
7292 | OPTI_TYPE_PRECOMPUTE_MERKLE
7293 | OPTI_TYPE_EARLY_SKIP
7294 | OPTI_TYPE_NOT_ITERATED
7295 | OPTI_TYPE_NOT_SALTED
7296 | OPTI_TYPE_RAW_HASH;
7297 dgst_pos0 = 3;
7298 dgst_pos1 = 4;
7299 dgst_pos2 = 2;
7300 dgst_pos3 = 1;
7301 break;
7302
7303 case 110: hash_type = HASH_TYPE_SHA1;
7304 salt_type = SALT_TYPE_INTERN;
7305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7306 opts_type = OPTS_TYPE_PT_GENERATE_BE
7307 | OPTS_TYPE_ST_ADD80
7308 | OPTS_TYPE_ST_ADDBITS15;
7309 kern_type = KERN_TYPE_SHA1_PWSLT;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = sha1s_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_APPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 4;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 111: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_EMBEDDED;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_ST_ADD80
7331 | OPTS_TYPE_ST_ADDBITS15;
7332 kern_type = KERN_TYPE_SHA1_PWSLT;
7333 dgst_size = DGST_SIZE_4_5;
7334 parse_func = sha1b64s_parse_hash;
7335 sort_by_digest = sort_by_digest_4_5;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_APPENDED_SALT
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 4;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 1;
7347 break;
7348
7349 case 112: hash_type = HASH_TYPE_SHA1;
7350 salt_type = SALT_TYPE_INTERN;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_ST_ADD80
7354 | OPTS_TYPE_ST_ADDBITS15
7355 | OPTS_TYPE_ST_HEX;
7356 kern_type = KERN_TYPE_SHA1_PWSLT;
7357 dgst_size = DGST_SIZE_4_5;
7358 parse_func = oracles_parse_hash;
7359 sort_by_digest = sort_by_digest_4_5;
7360 opti_type = OPTI_TYPE_ZERO_BYTE
7361 | OPTI_TYPE_PRECOMPUTE_INIT
7362 | OPTI_TYPE_PRECOMPUTE_MERKLE
7363 | OPTI_TYPE_EARLY_SKIP
7364 | OPTI_TYPE_NOT_ITERATED
7365 | OPTI_TYPE_APPENDED_SALT
7366 | OPTI_TYPE_RAW_HASH;
7367 dgst_pos0 = 3;
7368 dgst_pos1 = 4;
7369 dgst_pos2 = 2;
7370 dgst_pos3 = 1;
7371 break;
7372
7373 case 120: hash_type = HASH_TYPE_SHA1;
7374 salt_type = SALT_TYPE_INTERN;
7375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7376 opts_type = OPTS_TYPE_PT_GENERATE_BE
7377 | OPTS_TYPE_PT_ADD80
7378 | OPTS_TYPE_PT_ADDBITS15;
7379 kern_type = KERN_TYPE_SHA1_SLTPW;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = sha1s_parse_hash;
7382 sort_by_digest = sort_by_digest_4_5;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_PREPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 4;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 121: hash_type = HASH_TYPE_SHA1;
7397 salt_type = SALT_TYPE_INTERN;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_ADD80
7401 | OPTS_TYPE_PT_ADDBITS15
7402 | OPTS_TYPE_ST_LOWER;
7403 kern_type = KERN_TYPE_SHA1_SLTPW;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = smf_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_PREPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 122: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_EMBEDDED;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_ADD80
7425 | OPTS_TYPE_PT_ADDBITS15
7426 | OPTS_TYPE_ST_HEX;
7427 kern_type = KERN_TYPE_SHA1_SLTPW;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = osx1_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_PREPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 124: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_EMBEDDED;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_PT_ADD80
7449 | OPTS_TYPE_PT_ADDBITS15;
7450 kern_type = KERN_TYPE_SHA1_SLTPW;
7451 dgst_size = DGST_SIZE_4_5;
7452 parse_func = djangosha1_parse_hash;
7453 sort_by_digest = sort_by_digest_4_5;
7454 opti_type = OPTI_TYPE_ZERO_BYTE
7455 | OPTI_TYPE_PRECOMPUTE_INIT
7456 | OPTI_TYPE_PRECOMPUTE_MERKLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_PREPENDED_SALT
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 3;
7462 dgst_pos1 = 4;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 130: hash_type = HASH_TYPE_SHA1;
7468 salt_type = SALT_TYPE_INTERN;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_BE
7471 | OPTS_TYPE_PT_UNICODE
7472 | OPTS_TYPE_ST_ADD80
7473 | OPTS_TYPE_ST_ADDBITS15;
7474 kern_type = KERN_TYPE_SHA1_PWUSLT;
7475 dgst_size = DGST_SIZE_4_5;
7476 parse_func = sha1s_parse_hash;
7477 sort_by_digest = sort_by_digest_4_5;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_EARLY_SKIP
7482 | OPTI_TYPE_NOT_ITERATED
7483 | OPTI_TYPE_APPENDED_SALT
7484 | OPTI_TYPE_RAW_HASH;
7485 dgst_pos0 = 3;
7486 dgst_pos1 = 4;
7487 dgst_pos2 = 2;
7488 dgst_pos3 = 1;
7489 break;
7490
7491 case 131: hash_type = HASH_TYPE_SHA1;
7492 salt_type = SALT_TYPE_EMBEDDED;
7493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7494 opts_type = OPTS_TYPE_PT_GENERATE_BE
7495 | OPTS_TYPE_PT_UNICODE
7496 | OPTS_TYPE_PT_UPPER
7497 | OPTS_TYPE_ST_ADD80
7498 | OPTS_TYPE_ST_ADDBITS15
7499 | OPTS_TYPE_ST_HEX;
7500 kern_type = KERN_TYPE_SHA1_PWUSLT;
7501 dgst_size = DGST_SIZE_4_5;
7502 parse_func = mssql2000_parse_hash;
7503 sort_by_digest = sort_by_digest_4_5;
7504 opti_type = OPTI_TYPE_ZERO_BYTE
7505 | OPTI_TYPE_PRECOMPUTE_INIT
7506 | OPTI_TYPE_PRECOMPUTE_MERKLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_APPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 3;
7512 dgst_pos1 = 4;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 132: hash_type = HASH_TYPE_SHA1;
7518 salt_type = SALT_TYPE_EMBEDDED;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_BE
7521 | OPTS_TYPE_PT_UNICODE
7522 | OPTS_TYPE_ST_ADD80
7523 | OPTS_TYPE_ST_ADDBITS15
7524 | OPTS_TYPE_ST_HEX;
7525 kern_type = KERN_TYPE_SHA1_PWUSLT;
7526 dgst_size = DGST_SIZE_4_5;
7527 parse_func = mssql2005_parse_hash;
7528 sort_by_digest = sort_by_digest_4_5;
7529 opti_type = OPTI_TYPE_ZERO_BYTE
7530 | OPTI_TYPE_PRECOMPUTE_INIT
7531 | OPTI_TYPE_PRECOMPUTE_MERKLE
7532 | OPTI_TYPE_EARLY_SKIP
7533 | OPTI_TYPE_NOT_ITERATED
7534 | OPTI_TYPE_APPENDED_SALT
7535 | OPTI_TYPE_RAW_HASH;
7536 dgst_pos0 = 3;
7537 dgst_pos1 = 4;
7538 dgst_pos2 = 2;
7539 dgst_pos3 = 1;
7540 break;
7541
7542 case 133: hash_type = HASH_TYPE_SHA1;
7543 salt_type = SALT_TYPE_EMBEDDED;
7544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7545 opts_type = OPTS_TYPE_PT_GENERATE_BE
7546 | OPTS_TYPE_PT_UNICODE
7547 | OPTS_TYPE_ST_ADD80
7548 | OPTS_TYPE_ST_ADDBITS15;
7549 kern_type = KERN_TYPE_SHA1_PWUSLT;
7550 dgst_size = DGST_SIZE_4_5;
7551 parse_func = peoplesoft_parse_hash;
7552 sort_by_digest = sort_by_digest_4_5;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_PRECOMPUTE_INIT
7555 | OPTI_TYPE_PRECOMPUTE_MERKLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_APPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 3;
7561 dgst_pos1 = 4;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 140: hash_type = HASH_TYPE_SHA1;
7567 salt_type = SALT_TYPE_INTERN;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_BE
7570 | OPTS_TYPE_PT_ADD80
7571 | OPTS_TYPE_PT_ADDBITS15
7572 | OPTS_TYPE_PT_UNICODE;
7573 kern_type = KERN_TYPE_SHA1_SLTPWU;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = sha1s_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_PREPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 3;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 141: hash_type = HASH_TYPE_SHA1;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_BE
7594 | OPTS_TYPE_PT_ADD80
7595 | OPTS_TYPE_PT_ADDBITS15
7596 | OPTS_TYPE_PT_UNICODE
7597 | OPTS_TYPE_ST_BASE64;
7598 kern_type = KERN_TYPE_SHA1_SLTPWU;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = episerver_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_PREPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 150: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_INTERN;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_ST_ADD80
7620 | OPTS_TYPE_ST_ADDBITS15;
7621 kern_type = KERN_TYPE_HMACSHA1_PW;
7622 dgst_size = DGST_SIZE_4_5;
7623 parse_func = hmacsha1_parse_hash;
7624 sort_by_digest = sort_by_digest_4_5;
7625 opti_type = OPTI_TYPE_ZERO_BYTE
7626 | OPTI_TYPE_NOT_ITERATED;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 4;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 160: hash_type = HASH_TYPE_SHA1;
7634 salt_type = SALT_TYPE_INTERN;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS15;
7639 kern_type = KERN_TYPE_HMACSHA1_SLT;
7640 dgst_size = DGST_SIZE_4_5;
7641 parse_func = hmacsha1_parse_hash;
7642 sort_by_digest = sort_by_digest_4_5;
7643 opti_type = OPTI_TYPE_ZERO_BYTE
7644 | OPTI_TYPE_NOT_ITERATED;
7645 dgst_pos0 = 3;
7646 dgst_pos1 = 4;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 1;
7649 break;
7650
7651 case 190: hash_type = HASH_TYPE_SHA1;
7652 salt_type = SALT_TYPE_NONE;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS15;
7657 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7658 dgst_size = DGST_SIZE_4_5;
7659 parse_func = sha1linkedin_parse_hash;
7660 sort_by_digest = sort_by_digest_4_5;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_EARLY_SKIP
7664 | OPTI_TYPE_NOT_ITERATED
7665 | OPTI_TYPE_NOT_SALTED;
7666 dgst_pos0 = 0;
7667 dgst_pos1 = 4;
7668 dgst_pos2 = 3;
7669 dgst_pos3 = 2;
7670 break;
7671
7672 case 200: hash_type = HASH_TYPE_MYSQL;
7673 salt_type = SALT_TYPE_NONE;
7674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7675 opts_type = 0;
7676 kern_type = KERN_TYPE_MYSQL;
7677 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7678 parse_func = mysql323_parse_hash;
7679 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7680 opti_type = OPTI_TYPE_ZERO_BYTE;
7681 dgst_pos0 = 0;
7682 dgst_pos1 = 1;
7683 dgst_pos2 = 2;
7684 dgst_pos3 = 3;
7685 break;
7686
7687 case 300: hash_type = HASH_TYPE_SHA1;
7688 salt_type = SALT_TYPE_NONE;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = OPTS_TYPE_PT_GENERATE_BE
7691 | OPTS_TYPE_PT_ADD80
7692 | OPTS_TYPE_PT_ADDBITS15;
7693 kern_type = KERN_TYPE_MYSQL41;
7694 dgst_size = DGST_SIZE_4_5;
7695 parse_func = sha1_parse_hash;
7696 sort_by_digest = sort_by_digest_4_5;
7697 opti_type = OPTI_TYPE_ZERO_BYTE
7698 | OPTI_TYPE_PRECOMPUTE_INIT
7699 | OPTI_TYPE_PRECOMPUTE_MERKLE
7700 | OPTI_TYPE_EARLY_SKIP
7701 | OPTI_TYPE_NOT_ITERATED
7702 | OPTI_TYPE_NOT_SALTED;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 4;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 400: hash_type = HASH_TYPE_MD5;
7710 salt_type = SALT_TYPE_EMBEDDED;
7711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7713 kern_type = KERN_TYPE_PHPASS;
7714 dgst_size = DGST_SIZE_4_4;
7715 parse_func = phpass_parse_hash;
7716 sort_by_digest = sort_by_digest_4_4;
7717 opti_type = OPTI_TYPE_ZERO_BYTE;
7718 dgst_pos0 = 0;
7719 dgst_pos1 = 1;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 3;
7722 break;
7723
7724 case 500: hash_type = HASH_TYPE_MD5;
7725 salt_type = SALT_TYPE_EMBEDDED;
7726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7728 kern_type = KERN_TYPE_MD5CRYPT;
7729 dgst_size = DGST_SIZE_4_4;
7730 parse_func = md5crypt_parse_hash;
7731 sort_by_digest = sort_by_digest_4_4;
7732 opti_type = OPTI_TYPE_ZERO_BYTE;
7733 dgst_pos0 = 0;
7734 dgst_pos1 = 1;
7735 dgst_pos2 = 2;
7736 dgst_pos3 = 3;
7737 break;
7738
7739 case 501: hash_type = HASH_TYPE_MD5;
7740 salt_type = SALT_TYPE_EMBEDDED;
7741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7742 opts_type = OPTS_TYPE_PT_GENERATE_LE
7743 | OPTS_TYPE_HASH_COPY;
7744 kern_type = KERN_TYPE_MD5CRYPT;
7745 dgst_size = DGST_SIZE_4_4;
7746 parse_func = juniper_parse_hash;
7747 sort_by_digest = sort_by_digest_4_4;
7748 opti_type = OPTI_TYPE_ZERO_BYTE;
7749 dgst_pos0 = 0;
7750 dgst_pos1 = 1;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 3;
7753 break;
7754
7755 case 900: hash_type = HASH_TYPE_MD4;
7756 salt_type = SALT_TYPE_NONE;
7757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_LE
7759 | OPTS_TYPE_PT_ADD80
7760 | OPTS_TYPE_PT_ADDBITS14;
7761 kern_type = KERN_TYPE_MD4;
7762 dgst_size = DGST_SIZE_4_4;
7763 parse_func = md4_parse_hash;
7764 sort_by_digest = sort_by_digest_4_4;
7765 opti_type = OPTI_TYPE_ZERO_BYTE
7766 | OPTI_TYPE_PRECOMPUTE_INIT
7767 | OPTI_TYPE_PRECOMPUTE_MERKLE
7768 | OPTI_TYPE_MEET_IN_MIDDLE
7769 | OPTI_TYPE_EARLY_SKIP
7770 | OPTI_TYPE_NOT_ITERATED
7771 | OPTI_TYPE_NOT_SALTED
7772 | OPTI_TYPE_RAW_HASH;
7773 dgst_pos0 = 0;
7774 dgst_pos1 = 3;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 1;
7777 break;
7778
7779 case 1000: hash_type = HASH_TYPE_MD4;
7780 salt_type = SALT_TYPE_NONE;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_LE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS14
7785 | OPTS_TYPE_PT_UNICODE;
7786 kern_type = KERN_TYPE_MD4_PWU;
7787 dgst_size = DGST_SIZE_4_4;
7788 parse_func = md4_parse_hash;
7789 sort_by_digest = sort_by_digest_4_4;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_MEET_IN_MIDDLE
7794 | OPTI_TYPE_EARLY_SKIP
7795 | OPTI_TYPE_NOT_ITERATED
7796 | OPTI_TYPE_NOT_SALTED
7797 | OPTI_TYPE_RAW_HASH;
7798 dgst_pos0 = 0;
7799 dgst_pos1 = 3;
7800 dgst_pos2 = 2;
7801 dgst_pos3 = 1;
7802 break;
7803
7804 case 1100: hash_type = HASH_TYPE_MD4;
7805 salt_type = SALT_TYPE_INTERN;
7806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_LE
7808 | OPTS_TYPE_PT_ADD80
7809 | OPTS_TYPE_PT_ADDBITS14
7810 | OPTS_TYPE_PT_UNICODE
7811 | OPTS_TYPE_ST_ADD80
7812 | OPTS_TYPE_ST_UNICODE
7813 | OPTS_TYPE_ST_LOWER;
7814 kern_type = KERN_TYPE_MD44_PWUSLT;
7815 dgst_size = DGST_SIZE_4_4;
7816 parse_func = dcc_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_EARLY_SKIP
7822 | OPTI_TYPE_NOT_ITERATED;
7823 dgst_pos0 = 0;
7824 dgst_pos1 = 3;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 1;
7827 break;
7828
7829 case 1400: hash_type = HASH_TYPE_SHA256;
7830 salt_type = SALT_TYPE_NONE;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_BE
7833 | OPTS_TYPE_PT_ADD80
7834 | OPTS_TYPE_PT_ADDBITS15;
7835 kern_type = KERN_TYPE_SHA256;
7836 dgst_size = DGST_SIZE_4_8;
7837 parse_func = sha256_parse_hash;
7838 sort_by_digest = sort_by_digest_4_8;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_PRECOMPUTE_MERKLE
7842 | OPTI_TYPE_EARLY_SKIP
7843 | OPTI_TYPE_NOT_ITERATED
7844 | OPTI_TYPE_NOT_SALTED
7845 | OPTI_TYPE_RAW_HASH;
7846 dgst_pos0 = 3;
7847 dgst_pos1 = 7;
7848 dgst_pos2 = 2;
7849 dgst_pos3 = 6;
7850 break;
7851
7852 case 1410: hash_type = HASH_TYPE_SHA256;
7853 salt_type = SALT_TYPE_INTERN;
7854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_BE
7856 | OPTS_TYPE_ST_ADD80
7857 | OPTS_TYPE_ST_ADDBITS15;
7858 kern_type = KERN_TYPE_SHA256_PWSLT;
7859 dgst_size = DGST_SIZE_4_8;
7860 parse_func = sha256s_parse_hash;
7861 sort_by_digest = sort_by_digest_4_8;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_APPENDED_SALT
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 7;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 6;
7873 break;
7874
7875 case 1420: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15;
7881 kern_type = KERN_TYPE_SHA256_SLTPW;
7882 dgst_size = DGST_SIZE_4_8;
7883 parse_func = sha256s_parse_hash;
7884 sort_by_digest = sort_by_digest_4_8;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_PRECOMPUTE_INIT
7887 | OPTI_TYPE_PRECOMPUTE_MERKLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_PREPENDED_SALT
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 3;
7893 dgst_pos1 = 7;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 6;
7896 break;
7897
7898 case 1421: hash_type = HASH_TYPE_SHA256;
7899 salt_type = SALT_TYPE_EMBEDDED;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_BE
7902 | OPTS_TYPE_PT_ADD80
7903 | OPTS_TYPE_PT_ADDBITS15;
7904 kern_type = KERN_TYPE_SHA256_SLTPW;
7905 dgst_size = DGST_SIZE_4_8;
7906 parse_func = hmailserver_parse_hash;
7907 sort_by_digest = sort_by_digest_4_8;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_PREPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 3;
7916 dgst_pos1 = 7;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 6;
7919 break;
7920
7921 case 1430: hash_type = HASH_TYPE_SHA256;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_UNICODE
7926 | OPTS_TYPE_ST_ADD80
7927 | OPTS_TYPE_ST_ADDBITS15;
7928 kern_type = KERN_TYPE_SHA256_PWUSLT;
7929 dgst_size = DGST_SIZE_4_8;
7930 parse_func = sha256s_parse_hash;
7931 sort_by_digest = sort_by_digest_4_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_APPENDED_SALT
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 3;
7940 dgst_pos1 = 7;
7941 dgst_pos2 = 2;
7942 dgst_pos3 = 6;
7943 break;
7944
7945 case 1440: hash_type = HASH_TYPE_SHA256;
7946 salt_type = SALT_TYPE_INTERN;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_BE
7949 | OPTS_TYPE_PT_ADD80
7950 | OPTS_TYPE_PT_ADDBITS15
7951 | OPTS_TYPE_PT_UNICODE;
7952 kern_type = KERN_TYPE_SHA256_SLTPWU;
7953 dgst_size = DGST_SIZE_4_8;
7954 parse_func = sha256s_parse_hash;
7955 sort_by_digest = sort_by_digest_4_8;
7956 opti_type = OPTI_TYPE_ZERO_BYTE
7957 | OPTI_TYPE_PRECOMPUTE_INIT
7958 | OPTI_TYPE_PRECOMPUTE_MERKLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_PREPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 3;
7964 dgst_pos1 = 7;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 6;
7967 break;
7968
7969 case 1441: hash_type = HASH_TYPE_SHA256;
7970 salt_type = SALT_TYPE_EMBEDDED;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15
7975 | OPTS_TYPE_PT_UNICODE
7976 | OPTS_TYPE_ST_BASE64;
7977 kern_type = KERN_TYPE_SHA256_SLTPWU;
7978 dgst_size = DGST_SIZE_4_8;
7979 parse_func = episerver4_parse_hash;
7980 sort_by_digest = sort_by_digest_4_8;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_PRECOMPUTE_MERKLE
7984 | OPTI_TYPE_EARLY_SKIP
7985 | OPTI_TYPE_NOT_ITERATED
7986 | OPTI_TYPE_PREPENDED_SALT
7987 | OPTI_TYPE_RAW_HASH;
7988 dgst_pos0 = 3;
7989 dgst_pos1 = 7;
7990 dgst_pos2 = 2;
7991 dgst_pos3 = 6;
7992 break;
7993
7994 case 1450: hash_type = HASH_TYPE_SHA256;
7995 salt_type = SALT_TYPE_INTERN;
7996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7997 opts_type = OPTS_TYPE_PT_GENERATE_BE
7998 | OPTS_TYPE_ST_ADD80;
7999 kern_type = KERN_TYPE_HMACSHA256_PW;
8000 dgst_size = DGST_SIZE_4_8;
8001 parse_func = hmacsha256_parse_hash;
8002 sort_by_digest = sort_by_digest_4_8;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_NOT_ITERATED;
8005 dgst_pos0 = 3;
8006 dgst_pos1 = 7;
8007 dgst_pos2 = 2;
8008 dgst_pos3 = 6;
8009 break;
8010
8011 case 1460: hash_type = HASH_TYPE_SHA256;
8012 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_HMACSHA256_SLT;
8018 dgst_size = DGST_SIZE_4_8;
8019 parse_func = hmacsha256_parse_hash;
8020 sort_by_digest = sort_by_digest_4_8;
8021 opti_type = OPTI_TYPE_ZERO_BYTE
8022 | OPTI_TYPE_NOT_ITERATED;
8023 dgst_pos0 = 3;
8024 dgst_pos1 = 7;
8025 dgst_pos2 = 2;
8026 dgst_pos3 = 6;
8027 break;
8028
8029 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8030 salt_type = SALT_TYPE_EMBEDDED;
8031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8032 opts_type = OPTS_TYPE_PT_GENERATE_LE
8033 | OPTS_TYPE_PT_BITSLICE;
8034 kern_type = KERN_TYPE_DESCRYPT;
8035 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8036 parse_func = descrypt_parse_hash;
8037 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8040 dgst_pos0 = 0;
8041 dgst_pos1 = 1;
8042 dgst_pos2 = 2;
8043 dgst_pos3 = 3;
8044 break;
8045
8046 case 1600: hash_type = HASH_TYPE_MD5;
8047 salt_type = SALT_TYPE_EMBEDDED;
8048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8050 kern_type = KERN_TYPE_APR1CRYPT;
8051 dgst_size = DGST_SIZE_4_4;
8052 parse_func = md5apr1_parse_hash;
8053 sort_by_digest = sort_by_digest_4_4;
8054 opti_type = OPTI_TYPE_ZERO_BYTE;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 1;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 3;
8059 break;
8060
8061 case 1700: hash_type = HASH_TYPE_SHA512;
8062 salt_type = SALT_TYPE_NONE;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_BE
8065 | OPTS_TYPE_PT_ADD80
8066 | OPTS_TYPE_PT_ADDBITS15;
8067 kern_type = KERN_TYPE_SHA512;
8068 dgst_size = DGST_SIZE_8_8;
8069 parse_func = sha512_parse_hash;
8070 sort_by_digest = sort_by_digest_8_8;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP
8075 | OPTI_TYPE_NOT_ITERATED
8076 | OPTI_TYPE_NOT_SALTED
8077 | OPTI_TYPE_USES_BITS_64
8078 | OPTI_TYPE_RAW_HASH;
8079 dgst_pos0 = 14;
8080 dgst_pos1 = 15;
8081 dgst_pos2 = 6;
8082 dgst_pos3 = 7;
8083 break;
8084
8085 case 1710: hash_type = HASH_TYPE_SHA512;
8086 salt_type = SALT_TYPE_INTERN;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_ST_ADD80
8090 | OPTS_TYPE_ST_ADDBITS15;
8091 kern_type = KERN_TYPE_SHA512_PWSLT;
8092 dgst_size = DGST_SIZE_8_8;
8093 parse_func = sha512s_parse_hash;
8094 sort_by_digest = sort_by_digest_8_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_PRECOMPUTE_INIT
8097 | OPTI_TYPE_PRECOMPUTE_MERKLE
8098 | OPTI_TYPE_EARLY_SKIP
8099 | OPTI_TYPE_NOT_ITERATED
8100 | OPTI_TYPE_APPENDED_SALT
8101 | OPTI_TYPE_USES_BITS_64
8102 | OPTI_TYPE_RAW_HASH;
8103 dgst_pos0 = 14;
8104 dgst_pos1 = 15;
8105 dgst_pos2 = 6;
8106 dgst_pos3 = 7;
8107 break;
8108
8109 case 1711: hash_type = HASH_TYPE_SHA512;
8110 salt_type = SALT_TYPE_EMBEDDED;
8111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_BE
8113 | OPTS_TYPE_ST_ADD80
8114 | OPTS_TYPE_ST_ADDBITS15;
8115 kern_type = KERN_TYPE_SHA512_PWSLT;
8116 dgst_size = DGST_SIZE_8_8;
8117 parse_func = sha512b64s_parse_hash;
8118 sort_by_digest = sort_by_digest_8_8;
8119 opti_type = OPTI_TYPE_ZERO_BYTE
8120 | OPTI_TYPE_PRECOMPUTE_INIT
8121 | OPTI_TYPE_PRECOMPUTE_MERKLE
8122 | OPTI_TYPE_EARLY_SKIP
8123 | OPTI_TYPE_NOT_ITERATED
8124 | OPTI_TYPE_APPENDED_SALT
8125 | OPTI_TYPE_USES_BITS_64
8126 | OPTI_TYPE_RAW_HASH;
8127 dgst_pos0 = 14;
8128 dgst_pos1 = 15;
8129 dgst_pos2 = 6;
8130 dgst_pos3 = 7;
8131 break;
8132
8133 case 1720: hash_type = HASH_TYPE_SHA512;
8134 salt_type = SALT_TYPE_INTERN;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_BE
8137 | OPTS_TYPE_PT_ADD80
8138 | OPTS_TYPE_PT_ADDBITS15;
8139 kern_type = KERN_TYPE_SHA512_SLTPW;
8140 dgst_size = DGST_SIZE_8_8;
8141 parse_func = sha512s_parse_hash;
8142 sort_by_digest = sort_by_digest_8_8;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_PREPENDED_SALT
8149 | OPTI_TYPE_USES_BITS_64
8150 | OPTI_TYPE_RAW_HASH;
8151 dgst_pos0 = 14;
8152 dgst_pos1 = 15;
8153 dgst_pos2 = 6;
8154 dgst_pos3 = 7;
8155 break;
8156
8157 case 1722: hash_type = HASH_TYPE_SHA512;
8158 salt_type = SALT_TYPE_EMBEDDED;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_BE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS15
8163 | OPTS_TYPE_ST_HEX;
8164 kern_type = KERN_TYPE_SHA512_SLTPW;
8165 dgst_size = DGST_SIZE_8_8;
8166 parse_func = osx512_parse_hash;
8167 sort_by_digest = sort_by_digest_8_8;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_PRECOMPUTE_INIT
8170 | OPTI_TYPE_PRECOMPUTE_MERKLE
8171 | OPTI_TYPE_EARLY_SKIP
8172 | OPTI_TYPE_NOT_ITERATED
8173 | OPTI_TYPE_PREPENDED_SALT
8174 | OPTI_TYPE_USES_BITS_64
8175 | OPTI_TYPE_RAW_HASH;
8176 dgst_pos0 = 14;
8177 dgst_pos1 = 15;
8178 dgst_pos2 = 6;
8179 dgst_pos3 = 7;
8180 break;
8181
8182 case 1730: hash_type = HASH_TYPE_SHA512;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_BE
8186 | OPTS_TYPE_PT_UNICODE
8187 | OPTS_TYPE_ST_ADD80
8188 | OPTS_TYPE_ST_ADDBITS15;
8189 kern_type = KERN_TYPE_SHA512_PWSLTU;
8190 dgst_size = DGST_SIZE_8_8;
8191 parse_func = sha512s_parse_hash;
8192 sort_by_digest = sort_by_digest_8_8;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_ITERATED
8198 | OPTI_TYPE_APPENDED_SALT
8199 | OPTI_TYPE_USES_BITS_64
8200 | OPTI_TYPE_RAW_HASH;
8201 dgst_pos0 = 14;
8202 dgst_pos1 = 15;
8203 dgst_pos2 = 6;
8204 dgst_pos3 = 7;
8205 break;
8206
8207 case 1731: hash_type = HASH_TYPE_SHA512;
8208 salt_type = SALT_TYPE_EMBEDDED;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_BE
8211 | OPTS_TYPE_PT_UNICODE
8212 | OPTS_TYPE_ST_ADD80
8213 | OPTS_TYPE_ST_ADDBITS15
8214 | OPTS_TYPE_ST_HEX;
8215 kern_type = KERN_TYPE_SHA512_PWSLTU;
8216 dgst_size = DGST_SIZE_8_8;
8217 parse_func = mssql2012_parse_hash;
8218 sort_by_digest = sort_by_digest_8_8;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_EARLY_SKIP
8223 | OPTI_TYPE_NOT_ITERATED
8224 | OPTI_TYPE_APPENDED_SALT
8225 | OPTI_TYPE_USES_BITS_64
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 14;
8228 dgst_pos1 = 15;
8229 dgst_pos2 = 6;
8230 dgst_pos3 = 7;
8231 break;
8232
8233 case 1740: hash_type = HASH_TYPE_SHA512;
8234 salt_type = SALT_TYPE_INTERN;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_BE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS15
8239 | OPTS_TYPE_PT_UNICODE;
8240 kern_type = KERN_TYPE_SHA512_SLTPWU;
8241 dgst_size = DGST_SIZE_8_8;
8242 parse_func = sha512s_parse_hash;
8243 sort_by_digest = sort_by_digest_8_8;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED
8249 | OPTI_TYPE_PREPENDED_SALT
8250 | OPTI_TYPE_USES_BITS_64
8251 | OPTI_TYPE_RAW_HASH;
8252 dgst_pos0 = 14;
8253 dgst_pos1 = 15;
8254 dgst_pos2 = 6;
8255 dgst_pos3 = 7;
8256 break;
8257
8258 case 1750: hash_type = HASH_TYPE_SHA512;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_BE
8262 | OPTS_TYPE_ST_ADD80;
8263 kern_type = KERN_TYPE_HMACSHA512_PW;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = hmacsha512_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_USES_BITS_64
8269 | OPTI_TYPE_NOT_ITERATED;
8270 dgst_pos0 = 14;
8271 dgst_pos1 = 15;
8272 dgst_pos2 = 6;
8273 dgst_pos3 = 7;
8274 break;
8275
8276 case 1760: hash_type = HASH_TYPE_SHA512;
8277 salt_type = SALT_TYPE_INTERN;
8278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8279 opts_type = OPTS_TYPE_PT_GENERATE_BE
8280 | OPTS_TYPE_PT_ADD80
8281 | OPTS_TYPE_PT_ADDBITS15;
8282 kern_type = KERN_TYPE_HMACSHA512_SLT;
8283 dgst_size = DGST_SIZE_8_8;
8284 parse_func = hmacsha512_parse_hash;
8285 sort_by_digest = sort_by_digest_8_8;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_USES_BITS_64
8288 | OPTI_TYPE_NOT_ITERATED;
8289 dgst_pos0 = 14;
8290 dgst_pos1 = 15;
8291 dgst_pos2 = 6;
8292 dgst_pos3 = 7;
8293 break;
8294
8295 case 1800: hash_type = HASH_TYPE_SHA512;
8296 salt_type = SALT_TYPE_EMBEDDED;
8297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8299 kern_type = KERN_TYPE_SHA512CRYPT;
8300 dgst_size = DGST_SIZE_8_8;
8301 parse_func = sha512crypt_parse_hash;
8302 sort_by_digest = sort_by_digest_8_8;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_USES_BITS_64;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 1;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 3;
8309 break;
8310
8311 case 2100: hash_type = HASH_TYPE_DCC2;
8312 salt_type = SALT_TYPE_EMBEDDED;
8313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8315 | OPTS_TYPE_ST_LOWER
8316 | OPTS_TYPE_ST_UNICODE;
8317 kern_type = KERN_TYPE_DCC2;
8318 dgst_size = DGST_SIZE_4_4;
8319 parse_func = dcc2_parse_hash;
8320 sort_by_digest = sort_by_digest_4_4;
8321 opti_type = OPTI_TYPE_ZERO_BYTE;
8322 dgst_pos0 = 0;
8323 dgst_pos1 = 1;
8324 dgst_pos2 = 2;
8325 dgst_pos3 = 3;
8326 break;
8327
8328 case 2400: hash_type = HASH_TYPE_MD5;
8329 salt_type = SALT_TYPE_NONE;
8330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8331 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8332 kern_type = KERN_TYPE_MD5PIX;
8333 dgst_size = DGST_SIZE_4_4;
8334 parse_func = md5pix_parse_hash;
8335 sort_by_digest = sort_by_digest_4_4;
8336 opti_type = OPTI_TYPE_ZERO_BYTE
8337 | OPTI_TYPE_PRECOMPUTE_INIT
8338 | OPTI_TYPE_PRECOMPUTE_MERKLE
8339 | OPTI_TYPE_EARLY_SKIP
8340 | OPTI_TYPE_NOT_ITERATED
8341 | OPTI_TYPE_NOT_SALTED;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 3;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 1;
8346 break;
8347
8348 case 2410: hash_type = HASH_TYPE_MD5;
8349 salt_type = SALT_TYPE_INTERN;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8352 kern_type = KERN_TYPE_MD5ASA;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = md5asa_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_PRECOMPUTE_MERKLE
8359 | OPTI_TYPE_EARLY_SKIP
8360 | OPTI_TYPE_NOT_ITERATED;
8361 dgst_pos0 = 0;
8362 dgst_pos1 = 3;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 1;
8365 break;
8366
8367 case 2500: hash_type = HASH_TYPE_WPA;
8368 salt_type = SALT_TYPE_EMBEDDED;
8369 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8371 kern_type = KERN_TYPE_WPA;
8372 dgst_size = DGST_SIZE_4_4;
8373 parse_func = wpa_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4;
8375 opti_type = OPTI_TYPE_ZERO_BYTE;
8376 dgst_pos0 = 0;
8377 dgst_pos1 = 1;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 3;
8380 break;
8381
8382 case 2600: hash_type = HASH_TYPE_MD5;
8383 salt_type = SALT_TYPE_VIRTUAL;
8384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE
8386 | OPTS_TYPE_PT_ADD80
8387 | OPTS_TYPE_PT_ADDBITS14
8388 | OPTS_TYPE_ST_ADD80;
8389 kern_type = KERN_TYPE_MD55_PWSLT1;
8390 dgst_size = DGST_SIZE_4_4;
8391 parse_func = md5md5_parse_hash;
8392 sort_by_digest = sort_by_digest_4_4;
8393 opti_type = OPTI_TYPE_ZERO_BYTE
8394 | OPTI_TYPE_PRECOMPUTE_INIT
8395 | OPTI_TYPE_PRECOMPUTE_MERKLE
8396 | OPTI_TYPE_EARLY_SKIP;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 3;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 1;
8401 break;
8402
8403 case 2611: hash_type = HASH_TYPE_MD5;
8404 salt_type = SALT_TYPE_INTERN;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE
8407 | OPTS_TYPE_PT_ADD80
8408 | OPTS_TYPE_PT_ADDBITS14
8409 | OPTS_TYPE_ST_ADD80;
8410 kern_type = KERN_TYPE_MD55_PWSLT1;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = vb3_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 3;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 1;
8422 break;
8423
8424 case 2612: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
8432 kern_type = KERN_TYPE_MD55_PWSLT1;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = phps_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 3;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 1;
8444 break;
8445
8446 case 2711: hash_type = HASH_TYPE_MD5;
8447 salt_type = SALT_TYPE_INTERN;
8448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_LE
8450 | OPTS_TYPE_PT_ADD80
8451 | OPTS_TYPE_PT_ADDBITS14
8452 | OPTS_TYPE_ST_ADD80;
8453 kern_type = KERN_TYPE_MD55_PWSLT2;
8454 dgst_size = DGST_SIZE_4_4;
8455 parse_func = vb30_parse_hash;
8456 sort_by_digest = sort_by_digest_4_4;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_PRECOMPUTE_INIT
8459 | OPTI_TYPE_EARLY_SKIP;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 3;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 1;
8464 break;
8465
8466 case 2811: hash_type = HASH_TYPE_MD5;
8467 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_MD55_SLTPW;
8473 dgst_size = DGST_SIZE_4_4;
8474 parse_func = ipb2_parse_hash;
8475 sort_by_digest = sort_by_digest_4_4;
8476 opti_type = OPTI_TYPE_ZERO_BYTE
8477 | OPTI_TYPE_PRECOMPUTE_INIT
8478 | OPTI_TYPE_EARLY_SKIP;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 3;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 1;
8483 break;
8484
8485 case 3000: hash_type = HASH_TYPE_LM;
8486 salt_type = SALT_TYPE_NONE;
8487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE
8489 | OPTS_TYPE_PT_UPPER
8490 | OPTS_TYPE_PT_BITSLICE;
8491 kern_type = KERN_TYPE_LM;
8492 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8493 parse_func = lm_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 3100: hash_type = HASH_TYPE_ORACLEH;
8504 salt_type = SALT_TYPE_INTERN;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE
8507 | OPTS_TYPE_PT_UPPER
8508 | OPTS_TYPE_ST_UPPER;
8509 kern_type = KERN_TYPE_ORACLEH;
8510 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8511 parse_func = oracleh_parse_hash;
8512 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8513 opti_type = OPTI_TYPE_ZERO_BYTE;
8514 dgst_pos0 = 0;
8515 dgst_pos1 = 1;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 3;
8518 break;
8519
8520 case 3200: hash_type = HASH_TYPE_BCRYPT;
8521 salt_type = SALT_TYPE_EMBEDDED;
8522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_LE
8524 | OPTS_TYPE_ST_GENERATE_LE;
8525 kern_type = KERN_TYPE_BCRYPT;
8526 dgst_size = DGST_SIZE_4_6;
8527 parse_func = bcrypt_parse_hash;
8528 sort_by_digest = sort_by_digest_4_6;
8529 opti_type = OPTI_TYPE_ZERO_BYTE;
8530 dgst_pos0 = 0;
8531 dgst_pos1 = 1;
8532 dgst_pos2 = 2;
8533 dgst_pos3 = 3;
8534 break;
8535
8536 case 3710: hash_type = HASH_TYPE_MD5;
8537 salt_type = SALT_TYPE_INTERN;
8538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8539 opts_type = OPTS_TYPE_PT_GENERATE_LE
8540 | OPTS_TYPE_PT_ADD80
8541 | OPTS_TYPE_PT_ADDBITS14;
8542 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8543 dgst_size = DGST_SIZE_4_4;
8544 parse_func = md5s_parse_hash;
8545 sort_by_digest = sort_by_digest_4_4;
8546 opti_type = OPTI_TYPE_ZERO_BYTE
8547 | OPTI_TYPE_PRECOMPUTE_INIT
8548 | OPTI_TYPE_PRECOMPUTE_MERKLE
8549 | OPTI_TYPE_EARLY_SKIP;
8550 dgst_pos0 = 0;
8551 dgst_pos1 = 3;
8552 dgst_pos2 = 2;
8553 dgst_pos3 = 1;
8554 break;
8555
8556 case 3711: hash_type = HASH_TYPE_MD5;
8557 salt_type = SALT_TYPE_EMBEDDED;
8558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_LE
8560 | OPTS_TYPE_PT_ADD80
8561 | OPTS_TYPE_PT_ADDBITS14;
8562 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8563 dgst_size = DGST_SIZE_4_4;
8564 parse_func = mediawiki_b_parse_hash;
8565 sort_by_digest = sort_by_digest_4_4;
8566 opti_type = OPTI_TYPE_ZERO_BYTE
8567 | OPTI_TYPE_PRECOMPUTE_INIT
8568 | OPTI_TYPE_PRECOMPUTE_MERKLE
8569 | OPTI_TYPE_EARLY_SKIP;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 3;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 1;
8574 break;
8575
8576 case 3800: hash_type = HASH_TYPE_MD5;
8577 salt_type = SALT_TYPE_INTERN;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE
8580 | OPTS_TYPE_ST_ADDBITS14;
8581 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8582 dgst_size = DGST_SIZE_4_4;
8583 parse_func = md5s_parse_hash;
8584 sort_by_digest = sort_by_digest_4_4;
8585 opti_type = OPTI_TYPE_ZERO_BYTE
8586 | OPTI_TYPE_PRECOMPUTE_INIT
8587 | OPTI_TYPE_PRECOMPUTE_MERKLE
8588 | OPTI_TYPE_EARLY_SKIP
8589 | OPTI_TYPE_NOT_ITERATED
8590 | OPTI_TYPE_RAW_HASH;
8591 dgst_pos0 = 0;
8592 dgst_pos1 = 3;
8593 dgst_pos2 = 2;
8594 dgst_pos3 = 1;
8595 break;
8596
8597 case 4300: hash_type = HASH_TYPE_MD5;
8598 salt_type = SALT_TYPE_VIRTUAL;
8599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8600 opts_type = OPTS_TYPE_PT_GENERATE_LE
8601 | OPTS_TYPE_PT_ADD80
8602 | OPTS_TYPE_PT_ADDBITS14
8603 | OPTS_TYPE_ST_ADD80;
8604 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8605 dgst_size = DGST_SIZE_4_4;
8606 parse_func = md5md5_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
8619 case 4400: hash_type = HASH_TYPE_MD5;
8620 salt_type = SALT_TYPE_NONE;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_BE
8623 | OPTS_TYPE_PT_ADD80
8624 | OPTS_TYPE_PT_ADDBITS15;
8625 kern_type = KERN_TYPE_MD5_SHA1;
8626 dgst_size = DGST_SIZE_4_4;
8627 parse_func = md5_parse_hash;
8628 sort_by_digest = sort_by_digest_4_4;
8629 opti_type = OPTI_TYPE_ZERO_BYTE
8630 | OPTI_TYPE_PRECOMPUTE_INIT
8631 | OPTI_TYPE_PRECOMPUTE_MERKLE
8632 | OPTI_TYPE_EARLY_SKIP
8633 | OPTI_TYPE_NOT_ITERATED
8634 | OPTI_TYPE_NOT_SALTED
8635 | OPTI_TYPE_RAW_HASH;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 3;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 1;
8640 break;
8641
8642 case 4500: hash_type = HASH_TYPE_SHA1;
8643 salt_type = SALT_TYPE_NONE;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_BE
8646 | OPTS_TYPE_PT_ADD80
8647 | OPTS_TYPE_PT_ADDBITS15;
8648 kern_type = KERN_TYPE_SHA11;
8649 dgst_size = DGST_SIZE_4_5;
8650 parse_func = sha1_parse_hash;
8651 sort_by_digest = sort_by_digest_4_5;
8652 opti_type = OPTI_TYPE_ZERO_BYTE
8653 | OPTI_TYPE_PRECOMPUTE_INIT
8654 | OPTI_TYPE_PRECOMPUTE_MERKLE
8655 | OPTI_TYPE_EARLY_SKIP
8656 | OPTI_TYPE_NOT_SALTED;
8657 dgst_pos0 = 3;
8658 dgst_pos1 = 4;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 1;
8661 break;
8662
8663 case 4700: hash_type = HASH_TYPE_SHA1;
8664 salt_type = SALT_TYPE_NONE;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS14;
8669 kern_type = KERN_TYPE_SHA1_MD5;
8670 dgst_size = DGST_SIZE_4_5;
8671 parse_func = sha1_parse_hash;
8672 sort_by_digest = sort_by_digest_4_5;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_NOT_SALTED
8679 | OPTI_TYPE_RAW_HASH;
8680 dgst_pos0 = 3;
8681 dgst_pos1 = 4;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 1;
8684 break;
8685
8686 case 4800: hash_type = HASH_TYPE_MD5;
8687 salt_type = SALT_TYPE_EMBEDDED;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE
8690 | OPTS_TYPE_PT_ADDBITS14;
8691 kern_type = KERN_TYPE_MD5_CHAP;
8692 dgst_size = DGST_SIZE_4_4;
8693 parse_func = chap_parse_hash;
8694 sort_by_digest = sort_by_digest_4_4;
8695 opti_type = OPTI_TYPE_ZERO_BYTE
8696 | OPTI_TYPE_PRECOMPUTE_INIT
8697 | OPTI_TYPE_PRECOMPUTE_MERKLE
8698 | OPTI_TYPE_MEET_IN_MIDDLE
8699 | OPTI_TYPE_EARLY_SKIP
8700 | OPTI_TYPE_NOT_ITERATED
8701 | OPTI_TYPE_RAW_HASH;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 3;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 1;
8706 break;
8707
8708 case 4900: hash_type = HASH_TYPE_SHA1;
8709 salt_type = SALT_TYPE_INTERN;
8710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8712 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8713 dgst_size = DGST_SIZE_4_5;
8714 parse_func = sha1s_parse_hash;
8715 sort_by_digest = sort_by_digest_4_5;
8716 opti_type = OPTI_TYPE_ZERO_BYTE
8717 | OPTI_TYPE_PRECOMPUTE_INIT
8718 | OPTI_TYPE_PRECOMPUTE_MERKLE
8719 | OPTI_TYPE_EARLY_SKIP;
8720 dgst_pos0 = 3;
8721 dgst_pos1 = 4;
8722 dgst_pos2 = 2;
8723 dgst_pos3 = 1;
8724 break;
8725
8726 case 5000: hash_type = HASH_TYPE_KECCAK;
8727 salt_type = SALT_TYPE_EMBEDDED;
8728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_LE
8730 | OPTS_TYPE_PT_ADD01;
8731 kern_type = KERN_TYPE_KECCAK;
8732 dgst_size = DGST_SIZE_8_25;
8733 parse_func = keccak_parse_hash;
8734 sort_by_digest = sort_by_digest_8_25;
8735 opti_type = OPTI_TYPE_ZERO_BYTE
8736 | OPTI_TYPE_USES_BITS_64
8737 | OPTI_TYPE_RAW_HASH;
8738 dgst_pos0 = 2;
8739 dgst_pos1 = 3;
8740 dgst_pos2 = 4;
8741 dgst_pos3 = 5;
8742 break;
8743
8744 case 5100: hash_type = HASH_TYPE_MD5H;
8745 salt_type = SALT_TYPE_NONE;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14;
8750 kern_type = KERN_TYPE_MD5H;
8751 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8752 parse_func = md5half_parse_hash;
8753 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8754 opti_type = OPTI_TYPE_ZERO_BYTE
8755 | OPTI_TYPE_RAW_HASH;
8756 dgst_pos0 = 0;
8757 dgst_pos1 = 1;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 3;
8760 break;
8761
8762 case 5200: hash_type = HASH_TYPE_SHA256;
8763 salt_type = SALT_TYPE_EMBEDDED;
8764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8766 kern_type = KERN_TYPE_PSAFE3;
8767 dgst_size = DGST_SIZE_4_8;
8768 parse_func = psafe3_parse_hash;
8769 sort_by_digest = sort_by_digest_4_8;
8770 opti_type = OPTI_TYPE_ZERO_BYTE;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 1;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 3;
8775 break;
8776
8777 case 5300: hash_type = HASH_TYPE_MD5;
8778 salt_type = SALT_TYPE_EMBEDDED;
8779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_LE
8781 | OPTS_TYPE_ST_ADD80;
8782 kern_type = KERN_TYPE_IKEPSK_MD5;
8783 dgst_size = DGST_SIZE_4_4;
8784 parse_func = ikepsk_md5_parse_hash;
8785 sort_by_digest = sort_by_digest_4_4;
8786 opti_type = OPTI_TYPE_ZERO_BYTE;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 3;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 1;
8791 break;
8792
8793 case 5400: hash_type = HASH_TYPE_SHA1;
8794 salt_type = SALT_TYPE_EMBEDDED;
8795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8796 opts_type = OPTS_TYPE_PT_GENERATE_BE
8797 | OPTS_TYPE_ST_ADD80;
8798 kern_type = KERN_TYPE_IKEPSK_SHA1;
8799 dgst_size = DGST_SIZE_4_5;
8800 parse_func = ikepsk_sha1_parse_hash;
8801 sort_by_digest = sort_by_digest_4_5;
8802 opti_type = OPTI_TYPE_ZERO_BYTE;
8803 dgst_pos0 = 3;
8804 dgst_pos1 = 4;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 1;
8807 break;
8808
8809 case 5500: hash_type = HASH_TYPE_NETNTLM;
8810 salt_type = SALT_TYPE_EMBEDDED;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE
8813 | OPTS_TYPE_PT_ADD80
8814 | OPTS_TYPE_PT_ADDBITS14
8815 | OPTS_TYPE_PT_UNICODE
8816 | OPTS_TYPE_ST_HEX;
8817 kern_type = KERN_TYPE_NETNTLMv1;
8818 dgst_size = DGST_SIZE_4_4;
8819 parse_func = netntlmv1_parse_hash;
8820 sort_by_digest = sort_by_digest_4_4;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 5600: hash_type = HASH_TYPE_MD5;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE
8833 | OPTS_TYPE_PT_ADD80
8834 | OPTS_TYPE_PT_ADDBITS14
8835 | OPTS_TYPE_PT_UNICODE;
8836 kern_type = KERN_TYPE_NETNTLMv2;
8837 dgst_size = DGST_SIZE_4_4;
8838 parse_func = netntlmv2_parse_hash;
8839 sort_by_digest = sort_by_digest_4_4;
8840 opti_type = OPTI_TYPE_ZERO_BYTE;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 3;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 1;
8845 break;
8846
8847 case 5700: hash_type = HASH_TYPE_SHA256;
8848 salt_type = SALT_TYPE_NONE;
8849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_BE
8851 | OPTS_TYPE_PT_ADD80
8852 | OPTS_TYPE_PT_ADDBITS15;
8853 kern_type = KERN_TYPE_SHA256;
8854 dgst_size = DGST_SIZE_4_8;
8855 parse_func = cisco4_parse_hash;
8856 sort_by_digest = sort_by_digest_4_8;
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_PRECOMPUTE_INIT
8859 | OPTI_TYPE_PRECOMPUTE_MERKLE
8860 | OPTI_TYPE_EARLY_SKIP
8861 | OPTI_TYPE_NOT_ITERATED
8862 | OPTI_TYPE_NOT_SALTED
8863 | OPTI_TYPE_RAW_HASH;
8864 dgst_pos0 = 3;
8865 dgst_pos1 = 7;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 6;
8868 break;
8869
8870 case 5800: hash_type = HASH_TYPE_SHA1;
8871 salt_type = SALT_TYPE_INTERN;
8872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8874 | OPTS_TYPE_ST_ADD80;
8875 kern_type = KERN_TYPE_ANDROIDPIN;
8876 dgst_size = DGST_SIZE_4_5;
8877 parse_func = androidpin_parse_hash;
8878 sort_by_digest = sort_by_digest_4_5;
8879 opti_type = OPTI_TYPE_ZERO_BYTE;
8880 dgst_pos0 = 0;
8881 dgst_pos1 = 1;
8882 dgst_pos2 = 2;
8883 dgst_pos3 = 3;
8884 break;
8885
8886 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8887 salt_type = SALT_TYPE_NONE;
8888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8889 opts_type = OPTS_TYPE_PT_GENERATE_LE
8890 | OPTS_TYPE_PT_ADD80;
8891 kern_type = KERN_TYPE_RIPEMD160;
8892 dgst_size = DGST_SIZE_4_5;
8893 parse_func = ripemd160_parse_hash;
8894 sort_by_digest = sort_by_digest_4_5;
8895 opti_type = OPTI_TYPE_ZERO_BYTE;
8896 dgst_pos0 = 0;
8897 dgst_pos1 = 1;
8898 dgst_pos2 = 2;
8899 dgst_pos3 = 3;
8900 break;
8901
8902 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8903 salt_type = SALT_TYPE_NONE;
8904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8905 opts_type = OPTS_TYPE_PT_GENERATE_BE
8906 | OPTS_TYPE_PT_ADD80;
8907 kern_type = KERN_TYPE_WHIRLPOOL;
8908 dgst_size = DGST_SIZE_4_16;
8909 parse_func = whirlpool_parse_hash;
8910 sort_by_digest = sort_by_digest_4_16;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8922 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8923 dgst_size = DGST_SIZE_4_5;
8924 parse_func = truecrypt_parse_hash_2k;
8925 sort_by_digest = sort_by_digest_4_5;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8937 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = truecrypt_parse_hash_2k;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = truecrypt_parse_hash_2k;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6221: hash_type = HASH_TYPE_SHA512;
8964 salt_type = SALT_TYPE_EMBEDDED;
8965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8967 kern_type = KERN_TYPE_TCSHA512_XTS512;
8968 dgst_size = DGST_SIZE_8_8;
8969 parse_func = truecrypt_parse_hash_1k;
8970 sort_by_digest = sort_by_digest_8_8;
8971 opti_type = OPTI_TYPE_ZERO_BYTE
8972 | OPTI_TYPE_USES_BITS_64;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6222: hash_type = HASH_TYPE_SHA512;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8983 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8984 dgst_size = DGST_SIZE_8_8;
8985 parse_func = truecrypt_parse_hash_1k;
8986 sort_by_digest = sort_by_digest_8_8;
8987 opti_type = OPTI_TYPE_ZERO_BYTE
8988 | OPTI_TYPE_USES_BITS_64;
8989 dgst_pos0 = 0;
8990 dgst_pos1 = 1;
8991 dgst_pos2 = 2;
8992 dgst_pos3 = 3;
8993 break;
8994
8995 case 6223: hash_type = HASH_TYPE_SHA512;
8996 salt_type = SALT_TYPE_EMBEDDED;
8997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8998 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8999 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9000 dgst_size = DGST_SIZE_8_8;
9001 parse_func = truecrypt_parse_hash_1k;
9002 sort_by_digest = sort_by_digest_8_8;
9003 opti_type = OPTI_TYPE_ZERO_BYTE
9004 | OPTI_TYPE_USES_BITS_64;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9015 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9016 dgst_size = DGST_SIZE_4_8;
9017 parse_func = truecrypt_parse_hash_1k;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9031 dgst_size = DGST_SIZE_4_8;
9032 parse_func = truecrypt_parse_hash_1k;
9033 sort_by_digest = sort_by_digest_4_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9045 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = truecrypt_parse_hash_1k;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9061 dgst_size = DGST_SIZE_4_5;
9062 parse_func = truecrypt_parse_hash_1k;
9063 sort_by_digest = sort_by_digest_4_5;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9075 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9076 dgst_size = DGST_SIZE_4_5;
9077 parse_func = truecrypt_parse_hash_1k;
9078 sort_by_digest = sort_by_digest_4_5;
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9090 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9091 dgst_size = DGST_SIZE_4_5;
9092 parse_func = truecrypt_parse_hash_1k;
9093 sort_by_digest = sort_by_digest_4_5;
9094 opti_type = OPTI_TYPE_ZERO_BYTE;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 6300: hash_type = HASH_TYPE_MD5;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9105 kern_type = KERN_TYPE_MD5AIX;
9106 dgst_size = DGST_SIZE_4_4;
9107 parse_func = md5aix_parse_hash;
9108 sort_by_digest = sort_by_digest_4_4;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 6400: hash_type = HASH_TYPE_SHA256;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9120 kern_type = KERN_TYPE_SHA256AIX;
9121 dgst_size = DGST_SIZE_4_8;
9122 parse_func = sha256aix_parse_hash;
9123 sort_by_digest = sort_by_digest_4_8;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 6500: hash_type = HASH_TYPE_SHA512;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9135 kern_type = KERN_TYPE_SHA512AIX;
9136 dgst_size = DGST_SIZE_8_8;
9137 parse_func = sha512aix_parse_hash;
9138 sort_by_digest = sort_by_digest_8_8;
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_USES_BITS_64;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 6600: hash_type = HASH_TYPE_AES;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9151 kern_type = KERN_TYPE_AGILEKEY;
9152 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9153 parse_func = agilekey_parse_hash;
9154 sort_by_digest = sort_by_digest_4_5;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6700: hash_type = HASH_TYPE_SHA1;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9166 kern_type = KERN_TYPE_SHA1AIX;
9167 dgst_size = DGST_SIZE_4_5;
9168 parse_func = sha1aix_parse_hash;
9169 sort_by_digest = sort_by_digest_4_5;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6800: hash_type = HASH_TYPE_AES;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9181 kern_type = KERN_TYPE_LASTPASS;
9182 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9183 parse_func = lastpass_parse_hash;
9184 sort_by_digest = sort_by_digest_4_8;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 6900: hash_type = HASH_TYPE_GOST;
9193 salt_type = SALT_TYPE_NONE;
9194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9196 kern_type = KERN_TYPE_GOST;
9197 dgst_size = DGST_SIZE_4_8;
9198 parse_func = gost_parse_hash;
9199 sort_by_digest = sort_by_digest_4_8;
9200 opti_type = OPTI_TYPE_ZERO_BYTE;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 7100: hash_type = HASH_TYPE_SHA512;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9211 kern_type = KERN_TYPE_PBKDF2_SHA512;
9212 dgst_size = DGST_SIZE_8_16;
9213 parse_func = sha512osx_parse_hash;
9214 sort_by_digest = sort_by_digest_8_16;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_USES_BITS_64;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 7200: hash_type = HASH_TYPE_SHA512;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9227 kern_type = KERN_TYPE_PBKDF2_SHA512;
9228 dgst_size = DGST_SIZE_8_16;
9229 parse_func = sha512grub_parse_hash;
9230 sort_by_digest = sort_by_digest_8_16;
9231 opti_type = OPTI_TYPE_ZERO_BYTE
9232 | OPTI_TYPE_USES_BITS_64;
9233 dgst_pos0 = 0;
9234 dgst_pos1 = 1;
9235 dgst_pos2 = 2;
9236 dgst_pos3 = 3;
9237 break;
9238
9239 case 7300: hash_type = HASH_TYPE_SHA1;
9240 salt_type = SALT_TYPE_EMBEDDED;
9241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9242 opts_type = OPTS_TYPE_PT_GENERATE_BE
9243 | OPTS_TYPE_ST_ADD80
9244 | OPTS_TYPE_ST_ADDBITS15;
9245 kern_type = KERN_TYPE_RAKP;
9246 dgst_size = DGST_SIZE_4_5;
9247 parse_func = rakp_parse_hash;
9248 sort_by_digest = sort_by_digest_4_5;
9249 opti_type = OPTI_TYPE_ZERO_BYTE
9250 | OPTI_TYPE_NOT_ITERATED;
9251 dgst_pos0 = 3;
9252 dgst_pos1 = 4;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 1;
9255 break;
9256
9257 case 7400: hash_type = HASH_TYPE_SHA256;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9261 kern_type = KERN_TYPE_SHA256CRYPT;
9262 dgst_size = DGST_SIZE_4_8;
9263 parse_func = sha256crypt_parse_hash;
9264 sort_by_digest = sort_by_digest_4_8;
9265 opti_type = OPTI_TYPE_ZERO_BYTE;
9266 dgst_pos0 = 0;
9267 dgst_pos1 = 1;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 3;
9270 break;
9271
9272 case 7500: hash_type = HASH_TYPE_KRB5PA;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9276 kern_type = KERN_TYPE_KRB5PA;
9277 dgst_size = DGST_SIZE_4_4;
9278 parse_func = krb5pa_parse_hash;
9279 sort_by_digest = sort_by_digest_4_4;
9280 opti_type = OPTI_TYPE_ZERO_BYTE
9281 | OPTI_TYPE_NOT_ITERATED;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 7600: hash_type = HASH_TYPE_SHA1;
9289 salt_type = SALT_TYPE_INTERN;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_BE
9292 | OPTS_TYPE_PT_ADD80
9293 | OPTS_TYPE_PT_ADDBITS15;
9294 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9295 dgst_size = DGST_SIZE_4_5;
9296 parse_func = redmine_parse_hash;
9297 sort_by_digest = sort_by_digest_4_5;
9298 opti_type = OPTI_TYPE_ZERO_BYTE
9299 | OPTI_TYPE_PRECOMPUTE_INIT
9300 | OPTI_TYPE_EARLY_SKIP
9301 | OPTI_TYPE_NOT_ITERATED
9302 | OPTI_TYPE_PREPENDED_SALT;
9303 dgst_pos0 = 3;
9304 dgst_pos1 = 4;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 1;
9307 break;
9308
9309 case 7700: hash_type = HASH_TYPE_SAPB;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_LE
9313 | OPTS_TYPE_PT_UPPER
9314 | OPTS_TYPE_ST_UPPER;
9315 kern_type = KERN_TYPE_SAPB;
9316 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9317 parse_func = sapb_parse_hash;
9318 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9319 opti_type = OPTI_TYPE_ZERO_BYTE
9320 | OPTI_TYPE_PRECOMPUTE_INIT
9321 | OPTI_TYPE_NOT_ITERATED;
9322 dgst_pos0 = 0;
9323 dgst_pos1 = 1;
9324 dgst_pos2 = 2;
9325 dgst_pos3 = 3;
9326 break;
9327
9328 case 7800: hash_type = HASH_TYPE_SAPG;
9329 salt_type = SALT_TYPE_EMBEDDED;
9330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9331 opts_type = OPTS_TYPE_PT_GENERATE_BE
9332 | OPTS_TYPE_ST_ADD80
9333 | OPTS_TYPE_ST_UPPER;
9334 kern_type = KERN_TYPE_SAPG;
9335 dgst_size = DGST_SIZE_4_5;
9336 parse_func = sapg_parse_hash;
9337 sort_by_digest = sort_by_digest_4_5;
9338 opti_type = OPTI_TYPE_ZERO_BYTE
9339 | OPTI_TYPE_PRECOMPUTE_INIT
9340 | OPTI_TYPE_NOT_ITERATED;
9341 dgst_pos0 = 3;
9342 dgst_pos1 = 4;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 1;
9345 break;
9346
9347 case 7900: hash_type = HASH_TYPE_SHA512;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9350 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9351 kern_type = KERN_TYPE_DRUPAL7;
9352 dgst_size = DGST_SIZE_8_8;
9353 parse_func = drupal7_parse_hash;
9354 sort_by_digest = sort_by_digest_8_8;
9355 opti_type = OPTI_TYPE_ZERO_BYTE
9356 | OPTI_TYPE_USES_BITS_64;
9357 dgst_pos0 = 0;
9358 dgst_pos1 = 1;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 3;
9361 break;
9362
9363 case 8000: hash_type = HASH_TYPE_SHA256;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_BE
9367 | OPTS_TYPE_PT_UNICODE
9368 | OPTS_TYPE_ST_ADD80
9369 | OPTS_TYPE_ST_HEX;
9370 kern_type = KERN_TYPE_SYBASEASE;
9371 dgst_size = DGST_SIZE_4_8;
9372 parse_func = sybasease_parse_hash;
9373 sort_by_digest = sort_by_digest_4_8;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_INIT
9376 | OPTI_TYPE_EARLY_SKIP
9377 | OPTI_TYPE_NOT_ITERATED
9378 | OPTI_TYPE_RAW_HASH;
9379 dgst_pos0 = 3;
9380 dgst_pos1 = 7;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 6;
9383 break;
9384
9385 case 8100: hash_type = HASH_TYPE_SHA1;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9389 kern_type = KERN_TYPE_NETSCALER;
9390 dgst_size = DGST_SIZE_4_5;
9391 parse_func = netscaler_parse_hash;
9392 sort_by_digest = sort_by_digest_4_5;
9393 opti_type = OPTI_TYPE_ZERO_BYTE
9394 | OPTI_TYPE_PRECOMPUTE_INIT
9395 | OPTI_TYPE_PRECOMPUTE_MERKLE
9396 | OPTI_TYPE_EARLY_SKIP
9397 | OPTI_TYPE_NOT_ITERATED
9398 | OPTI_TYPE_PREPENDED_SALT
9399 | OPTI_TYPE_RAW_HASH;
9400 dgst_pos0 = 3;
9401 dgst_pos1 = 4;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 1;
9404 break;
9405
9406 case 8200: hash_type = HASH_TYPE_SHA256;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9410 kern_type = KERN_TYPE_CLOUDKEY;
9411 dgst_size = DGST_SIZE_4_8;
9412 parse_func = cloudkey_parse_hash;
9413 sort_by_digest = sort_by_digest_4_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 8300: hash_type = HASH_TYPE_SHA1;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE
9425 | OPTS_TYPE_ST_HEX
9426 | OPTS_TYPE_ST_ADD80;
9427 kern_type = KERN_TYPE_NSEC3;
9428 dgst_size = DGST_SIZE_4_5;
9429 parse_func = nsec3_parse_hash;
9430 sort_by_digest = sort_by_digest_4_5;
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 3;
9433 dgst_pos1 = 4;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 1;
9436 break;
9437
9438 case 8400: hash_type = HASH_TYPE_SHA1;
9439 salt_type = SALT_TYPE_INTERN;
9440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_BE
9442 | OPTS_TYPE_PT_ADD80
9443 | OPTS_TYPE_PT_ADDBITS15;
9444 kern_type = KERN_TYPE_WBB3;
9445 dgst_size = DGST_SIZE_4_5;
9446 parse_func = wbb3_parse_hash;
9447 sort_by_digest = sort_by_digest_4_5;
9448 opti_type = OPTI_TYPE_ZERO_BYTE
9449 | OPTI_TYPE_PRECOMPUTE_INIT
9450 | OPTI_TYPE_NOT_ITERATED;
9451 dgst_pos0 = 3;
9452 dgst_pos1 = 4;
9453 dgst_pos2 = 2;
9454 dgst_pos3 = 1;
9455 break;
9456
9457 case 8500: hash_type = HASH_TYPE_DESRACF;
9458 salt_type = SALT_TYPE_EMBEDDED;
9459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9460 opts_type = OPTS_TYPE_PT_GENERATE_LE
9461 | OPTS_TYPE_ST_UPPER;
9462 kern_type = KERN_TYPE_RACF;
9463 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9464 parse_func = racf_parse_hash;
9465 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9468 dgst_pos0 = 0;
9469 dgst_pos1 = 1;
9470 dgst_pos2 = 2;
9471 dgst_pos3 = 3;
9472 break;
9473
9474 case 8600: hash_type = HASH_TYPE_LOTUS5;
9475 salt_type = SALT_TYPE_NONE;
9476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9477 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9478 kern_type = KERN_TYPE_LOTUS5;
9479 dgst_size = DGST_SIZE_4_4;
9480 parse_func = lotus5_parse_hash;
9481 sort_by_digest = sort_by_digest_4_4;
9482 opti_type = OPTI_TYPE_EARLY_SKIP
9483 | OPTI_TYPE_NOT_ITERATED
9484 | OPTI_TYPE_NOT_SALTED
9485 | OPTI_TYPE_RAW_HASH;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 8700: hash_type = HASH_TYPE_LOTUS6;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9496 kern_type = KERN_TYPE_LOTUS6;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = lotus6_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_EARLY_SKIP
9501 | OPTI_TYPE_NOT_ITERATED
9502 | OPTI_TYPE_RAW_HASH;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9513 kern_type = KERN_TYPE_ANDROIDFDE;
9514 dgst_size = DGST_SIZE_4_4;
9515 parse_func = androidfde_parse_hash;
9516 sort_by_digest = sort_by_digest_4_4;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8900: hash_type = HASH_TYPE_SCRYPT;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9528 kern_type = KERN_TYPE_SCRYPT;
9529 dgst_size = DGST_SIZE_4_8;
9530 parse_func = scrypt_parse_hash;
9531 sort_by_digest = sort_by_digest_4_8;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 9000: hash_type = HASH_TYPE_SHA1;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE
9543 | OPTS_TYPE_ST_GENERATE_LE;
9544 kern_type = KERN_TYPE_PSAFE2;
9545 dgst_size = DGST_SIZE_4_5;
9546 parse_func = psafe2_parse_hash;
9547 sort_by_digest = sort_by_digest_4_5;
9548 opti_type = OPTI_TYPE_ZERO_BYTE;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 9100: hash_type = HASH_TYPE_LOTUS8;
9556 salt_type = SALT_TYPE_EMBEDDED;
9557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_LOTUS8;
9560 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9561 parse_func = lotus8_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9563 opti_type = OPTI_TYPE_ZERO_BYTE;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9200: hash_type = HASH_TYPE_SHA256;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9574 kern_type = KERN_TYPE_PBKDF2_SHA256;
9575 dgst_size = DGST_SIZE_4_32;
9576 parse_func = cisco8_parse_hash;
9577 sort_by_digest = sort_by_digest_4_32;
9578 opti_type = OPTI_TYPE_ZERO_BYTE;
9579 dgst_pos0 = 0;
9580 dgst_pos1 = 1;
9581 dgst_pos2 = 2;
9582 dgst_pos3 = 3;
9583 break;
9584
9585 case 9300: hash_type = HASH_TYPE_SCRYPT;
9586 salt_type = SALT_TYPE_EMBEDDED;
9587 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9588 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9589 kern_type = KERN_TYPE_SCRYPT;
9590 dgst_size = DGST_SIZE_4_8;
9591 parse_func = cisco9_parse_hash;
9592 sort_by_digest = sort_by_digest_4_8;
9593 opti_type = OPTI_TYPE_ZERO_BYTE;
9594 dgst_pos0 = 0;
9595 dgst_pos1 = 1;
9596 dgst_pos2 = 2;
9597 dgst_pos3 = 3;
9598 break;
9599
9600 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9601 salt_type = SALT_TYPE_EMBEDDED;
9602 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9603 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9604 kern_type = KERN_TYPE_OFFICE2007;
9605 dgst_size = DGST_SIZE_4_4;
9606 parse_func = office2007_parse_hash;
9607 sort_by_digest = sort_by_digest_4_4;
9608 opti_type = OPTI_TYPE_ZERO_BYTE;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 1;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 3;
9613 break;
9614
9615 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9619 kern_type = KERN_TYPE_OFFICE2010;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = office2010_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE;
9624 dgst_pos0 = 0;
9625 dgst_pos1 = 1;
9626 dgst_pos2 = 2;
9627 dgst_pos3 = 3;
9628 break;
9629
9630 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9631 salt_type = SALT_TYPE_EMBEDDED;
9632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9634 kern_type = KERN_TYPE_OFFICE2013;
9635 dgst_size = DGST_SIZE_4_4;
9636 parse_func = office2013_parse_hash;
9637 sort_by_digest = sort_by_digest_4_4;
9638 opti_type = OPTI_TYPE_ZERO_BYTE;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE
9649 | OPTS_TYPE_PT_ADD80
9650 | OPTS_TYPE_PT_UNICODE;
9651 kern_type = KERN_TYPE_OLDOFFICE01;
9652 dgst_size = DGST_SIZE_4_4;
9653 parse_func = oldoffice01_parse_hash;
9654 sort_by_digest = sort_by_digest_4_4;
9655 opti_type = OPTI_TYPE_ZERO_BYTE
9656 | OPTI_TYPE_PRECOMPUTE_INIT
9657 | OPTI_TYPE_NOT_ITERATED;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE
9668 | OPTS_TYPE_PT_ADD80;
9669 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9670 dgst_size = DGST_SIZE_4_4;
9671 parse_func = oldoffice01cm1_parse_hash;
9672 sort_by_digest = sort_by_digest_4_4;
9673 opti_type = OPTI_TYPE_ZERO_BYTE
9674 | OPTI_TYPE_PRECOMPUTE_INIT
9675 | OPTI_TYPE_NOT_ITERATED;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE
9686 | OPTS_TYPE_PT_ADD80
9687 | OPTS_TYPE_PT_UNICODE
9688 | OPTS_TYPE_PT_NEVERCRACK;
9689 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9690 dgst_size = DGST_SIZE_4_4;
9691 parse_func = oldoffice01cm2_parse_hash;
9692 sort_by_digest = sort_by_digest_4_4;
9693 opti_type = OPTI_TYPE_ZERO_BYTE
9694 | OPTI_TYPE_PRECOMPUTE_INIT
9695 | OPTI_TYPE_NOT_ITERATED;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 1;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 3;
9700 break;
9701
9702 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_BE
9706 | OPTS_TYPE_PT_ADD80
9707 | OPTS_TYPE_PT_UNICODE;
9708 kern_type = KERN_TYPE_OLDOFFICE34;
9709 dgst_size = DGST_SIZE_4_4;
9710 parse_func = oldoffice34_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4;
9712 opti_type = OPTI_TYPE_ZERO_BYTE
9713 | OPTI_TYPE_PRECOMPUTE_INIT
9714 | OPTI_TYPE_NOT_ITERATED;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 1;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 3;
9719 break;
9720
9721 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9725 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9726 dgst_size = DGST_SIZE_4_4;
9727 parse_func = oldoffice34cm1_parse_hash;
9728 sort_by_digest = sort_by_digest_4_4;
9729 opti_type = OPTI_TYPE_ZERO_BYTE
9730 | OPTI_TYPE_PRECOMPUTE_INIT
9731 | OPTI_TYPE_NOT_ITERATED;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 1;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 3;
9736 break;
9737
9738 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_BE
9742 | OPTS_TYPE_PT_ADD80
9743 | OPTS_TYPE_PT_UNICODE
9744 | OPTS_TYPE_PT_NEVERCRACK;
9745 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9746 dgst_size = DGST_SIZE_4_4;
9747 parse_func = oldoffice34cm2_parse_hash;
9748 sort_by_digest = sort_by_digest_4_4;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_PRECOMPUTE_INIT
9751 | OPTI_TYPE_NOT_ITERATED;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 1;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 3;
9756 break;
9757
9758 case 9900: hash_type = HASH_TYPE_MD5;
9759 salt_type = SALT_TYPE_NONE;
9760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9762 kern_type = KERN_TYPE_RADMIN2;
9763 dgst_size = DGST_SIZE_4_4;
9764 parse_func = radmin2_parse_hash;
9765 sort_by_digest = sort_by_digest_4_4;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_PRECOMPUTE_INIT
9768 | OPTI_TYPE_EARLY_SKIP
9769 | OPTI_TYPE_NOT_ITERATED
9770 | OPTI_TYPE_NOT_SALTED;
9771 dgst_pos0 = 0;
9772 dgst_pos1 = 3;
9773 dgst_pos2 = 2;
9774 dgst_pos3 = 1;
9775 break;
9776
9777 case 10000: hash_type = HASH_TYPE_SHA256;
9778 salt_type = SALT_TYPE_EMBEDDED;
9779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9781 kern_type = KERN_TYPE_PBKDF2_SHA256;
9782 dgst_size = DGST_SIZE_4_32;
9783 parse_func = djangopbkdf2_parse_hash;
9784 sort_by_digest = sort_by_digest_4_32;
9785 opti_type = OPTI_TYPE_ZERO_BYTE;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 10100: hash_type = HASH_TYPE_SIPHASH;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9796 kern_type = KERN_TYPE_SIPHASH;
9797 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9798 parse_func = siphash_parse_hash;
9799 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_NOT_ITERATED
9802 | OPTI_TYPE_RAW_HASH;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 10200: hash_type = HASH_TYPE_MD5;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE
9813 | OPTS_TYPE_ST_ADD80
9814 | OPTS_TYPE_ST_ADDBITS14;
9815 kern_type = KERN_TYPE_HMACMD5_PW;
9816 dgst_size = DGST_SIZE_4_4;
9817 parse_func = crammd5_parse_hash;
9818 sort_by_digest = sort_by_digest_4_4;
9819 opti_type = OPTI_TYPE_ZERO_BYTE
9820 | OPTI_TYPE_NOT_ITERATED;
9821 dgst_pos0 = 0;
9822 dgst_pos1 = 3;
9823 dgst_pos2 = 2;
9824 dgst_pos3 = 1;
9825 break;
9826
9827 case 10300: hash_type = HASH_TYPE_SHA1;
9828 salt_type = SALT_TYPE_EMBEDDED;
9829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9830 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9831 kern_type = KERN_TYPE_SAPH_SHA1;
9832 dgst_size = DGST_SIZE_4_5;
9833 parse_func = saph_sha1_parse_hash;
9834 sort_by_digest = sort_by_digest_4_5;
9835 opti_type = OPTI_TYPE_ZERO_BYTE;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 10400: hash_type = HASH_TYPE_PDFU16;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9846 kern_type = KERN_TYPE_PDF11;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = pdf11_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_NOT_ITERATED;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 10410: hash_type = HASH_TYPE_PDFU16;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9862 kern_type = KERN_TYPE_PDF11CM1;
9863 dgst_size = DGST_SIZE_4_4;
9864 parse_func = pdf11cm1_parse_hash;
9865 sort_by_digest = sort_by_digest_4_4;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_NOT_ITERATED;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 1;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 3;
9872 break;
9873
9874 case 10420: hash_type = HASH_TYPE_PDFU16;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9878 kern_type = KERN_TYPE_PDF11CM2;
9879 dgst_size = DGST_SIZE_4_4;
9880 parse_func = pdf11cm2_parse_hash;
9881 sort_by_digest = sort_by_digest_4_4;
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_NOT_ITERATED;
9884 dgst_pos0 = 0;
9885 dgst_pos1 = 1;
9886 dgst_pos2 = 2;
9887 dgst_pos3 = 3;
9888 break;
9889
9890 case 10500: hash_type = HASH_TYPE_PDFU16;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9894 kern_type = KERN_TYPE_PDF14;
9895 dgst_size = DGST_SIZE_4_4;
9896 parse_func = pdf14_parse_hash;
9897 sort_by_digest = sort_by_digest_4_4;
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_NOT_ITERATED;
9900 dgst_pos0 = 0;
9901 dgst_pos1 = 1;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 3;
9904 break;
9905
9906 case 10600: hash_type = HASH_TYPE_SHA256;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_BE
9910 | OPTS_TYPE_ST_ADD80
9911 | OPTS_TYPE_ST_ADDBITS15
9912 | OPTS_TYPE_HASH_COPY;
9913 kern_type = KERN_TYPE_SHA256_PWSLT;
9914 dgst_size = DGST_SIZE_4_8;
9915 parse_func = pdf17l3_parse_hash;
9916 sort_by_digest = sort_by_digest_4_8;
9917 opti_type = OPTI_TYPE_ZERO_BYTE
9918 | OPTI_TYPE_PRECOMPUTE_INIT
9919 | OPTI_TYPE_PRECOMPUTE_MERKLE
9920 | OPTI_TYPE_EARLY_SKIP
9921 | OPTI_TYPE_NOT_ITERATED
9922 | OPTI_TYPE_APPENDED_SALT
9923 | OPTI_TYPE_RAW_HASH;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 7;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 6;
9928 break;
9929
9930 case 10700: hash_type = HASH_TYPE_PDFU32;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_HASH_COPY;
9935 kern_type = KERN_TYPE_PDF17L8;
9936 dgst_size = DGST_SIZE_4_8;
9937 parse_func = pdf17l8_parse_hash;
9938 sort_by_digest = sort_by_digest_4_8;
9939 opti_type = OPTI_TYPE_ZERO_BYTE
9940 | OPTI_TYPE_NOT_ITERATED;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 10800: hash_type = HASH_TYPE_SHA384;
9948 salt_type = SALT_TYPE_NONE;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_BE
9951 | OPTS_TYPE_PT_ADD80
9952 | OPTS_TYPE_PT_ADDBITS15;
9953 kern_type = KERN_TYPE_SHA384;
9954 dgst_size = DGST_SIZE_8_8;
9955 parse_func = sha384_parse_hash;
9956 sort_by_digest = sort_by_digest_8_8;
9957 opti_type = OPTI_TYPE_ZERO_BYTE
9958 | OPTI_TYPE_PRECOMPUTE_INIT
9959 | OPTI_TYPE_PRECOMPUTE_MERKLE
9960 | OPTI_TYPE_EARLY_SKIP
9961 | OPTI_TYPE_NOT_ITERATED
9962 | OPTI_TYPE_NOT_SALTED
9963 | OPTI_TYPE_USES_BITS_64
9964 | OPTI_TYPE_RAW_HASH;
9965 dgst_pos0 = 6;
9966 dgst_pos1 = 7;
9967 dgst_pos2 = 4;
9968 dgst_pos3 = 5;
9969 break;
9970
9971 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9972 salt_type = SALT_TYPE_EMBEDDED;
9973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9974 opts_type = OPTS_TYPE_PT_GENERATE_LE
9975 | OPTS_TYPE_ST_BASE64
9976 | OPTS_TYPE_HASH_COPY;
9977 kern_type = KERN_TYPE_PBKDF2_SHA256;
9978 dgst_size = DGST_SIZE_4_32;
9979 parse_func = pbkdf2_sha256_parse_hash;
9980 sort_by_digest = sort_by_digest_4_32;
9981 opti_type = OPTI_TYPE_ZERO_BYTE;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 11000: hash_type = HASH_TYPE_MD5;
9989 salt_type = SALT_TYPE_INTERN;
9990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE
9992 | OPTS_TYPE_PT_ADD80;
9993 kern_type = KERN_TYPE_PRESTASHOP;
9994 dgst_size = DGST_SIZE_4_4;
9995 parse_func = prestashop_parse_hash;
9996 sort_by_digest = sort_by_digest_4_4;
9997 opti_type = OPTI_TYPE_ZERO_BYTE
9998 | OPTI_TYPE_PRECOMPUTE_INIT
9999 | OPTI_TYPE_NOT_ITERATED
10000 | OPTI_TYPE_PREPENDED_SALT;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 3;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 1;
10005 break;
10006
10007 case 11100: hash_type = HASH_TYPE_MD5;
10008 salt_type = SALT_TYPE_EMBEDDED;
10009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE
10011 | OPTS_TYPE_ST_ADD80;
10012 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10013 dgst_size = DGST_SIZE_4_4;
10014 parse_func = postgresql_auth_parse_hash;
10015 sort_by_digest = sort_by_digest_4_4;
10016 opti_type = OPTI_TYPE_ZERO_BYTE
10017 | OPTI_TYPE_PRECOMPUTE_INIT
10018 | OPTI_TYPE_PRECOMPUTE_MERKLE
10019 | OPTI_TYPE_EARLY_SKIP;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 3;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 1;
10024 break;
10025
10026 case 11200: hash_type = HASH_TYPE_SHA1;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_BE
10030 | OPTS_TYPE_PT_ADD80
10031 | OPTS_TYPE_ST_HEX;
10032 kern_type = KERN_TYPE_MYSQL_AUTH;
10033 dgst_size = DGST_SIZE_4_5;
10034 parse_func = mysql_auth_parse_hash;
10035 sort_by_digest = sort_by_digest_4_5;
10036 opti_type = OPTI_TYPE_ZERO_BYTE
10037 | OPTI_TYPE_EARLY_SKIP;
10038 dgst_pos0 = 3;
10039 dgst_pos1 = 4;
10040 dgst_pos2 = 2;
10041 dgst_pos3 = 1;
10042 break;
10043
10044 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10045 salt_type = SALT_TYPE_EMBEDDED;
10046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10047 opts_type = OPTS_TYPE_PT_GENERATE_LE
10048 | OPTS_TYPE_ST_HEX
10049 | OPTS_TYPE_ST_ADD80;
10050 kern_type = KERN_TYPE_BITCOIN_WALLET;
10051 dgst_size = DGST_SIZE_4_4;
10052 parse_func = bitcoin_wallet_parse_hash;
10053 sort_by_digest = sort_by_digest_4_4;
10054 opti_type = OPTI_TYPE_ZERO_BYTE;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 1;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 3;
10059 break;
10060
10061 case 11400: hash_type = HASH_TYPE_MD5;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_LE
10065 | OPTS_TYPE_PT_ADD80
10066 | OPTS_TYPE_HASH_COPY;
10067 kern_type = KERN_TYPE_SIP_AUTH;
10068 dgst_size = DGST_SIZE_4_4;
10069 parse_func = sip_auth_parse_hash;
10070 sort_by_digest = sort_by_digest_4_4;
10071 opti_type = OPTI_TYPE_ZERO_BYTE;
10072 dgst_pos0 = 0;
10073 dgst_pos1 = 3;
10074 dgst_pos2 = 2;
10075 dgst_pos3 = 1;
10076 break;
10077
10078 case 11500: hash_type = HASH_TYPE_CRC32;
10079 salt_type = SALT_TYPE_INTERN;
10080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10081 opts_type = OPTS_TYPE_PT_GENERATE_LE
10082 | OPTS_TYPE_ST_GENERATE_LE
10083 | OPTS_TYPE_ST_HEX;
10084 kern_type = KERN_TYPE_CRC32;
10085 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10086 parse_func = crc32_parse_hash;
10087 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10088 opti_type = OPTI_TYPE_ZERO_BYTE;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 11600: hash_type = HASH_TYPE_AES;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE
10099 | OPTS_TYPE_PT_NEVERCRACK;
10100 kern_type = KERN_TYPE_SEVEN_ZIP;
10101 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10102 parse_func = seven_zip_parse_hash;
10103 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10104 opti_type = OPTI_TYPE_ZERO_BYTE;
10105 dgst_pos0 = 0;
10106 dgst_pos1 = 1;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 3;
10109 break;
10110
10111 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10112 salt_type = SALT_TYPE_NONE;
10113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE
10115 | OPTS_TYPE_PT_ADD01;
10116 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10117 dgst_size = DGST_SIZE_4_8;
10118 parse_func = gost2012sbog_256_parse_hash;
10119 sort_by_digest = sort_by_digest_4_8;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10128 salt_type = SALT_TYPE_NONE;
10129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE
10131 | OPTS_TYPE_PT_ADD01;
10132 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10133 dgst_size = DGST_SIZE_4_16;
10134 parse_func = gost2012sbog_512_parse_hash;
10135 sort_by_digest = sort_by_digest_4_16;
10136 opti_type = OPTI_TYPE_ZERO_BYTE;
10137 dgst_pos0 = 0;
10138 dgst_pos1 = 1;
10139 dgst_pos2 = 2;
10140 dgst_pos3 = 3;
10141 break;
10142
10143 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10144 salt_type = SALT_TYPE_EMBEDDED;
10145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10146 opts_type = OPTS_TYPE_PT_GENERATE_LE
10147 | OPTS_TYPE_ST_BASE64
10148 | OPTS_TYPE_HASH_COPY;
10149 kern_type = KERN_TYPE_PBKDF2_MD5;
10150 dgst_size = DGST_SIZE_4_32;
10151 parse_func = pbkdf2_md5_parse_hash;
10152 sort_by_digest = sort_by_digest_4_32;
10153 opti_type = OPTI_TYPE_ZERO_BYTE;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE
10164 | OPTS_TYPE_ST_BASE64
10165 | OPTS_TYPE_HASH_COPY;
10166 kern_type = KERN_TYPE_PBKDF2_SHA1;
10167 dgst_size = DGST_SIZE_4_32;
10168 parse_func = pbkdf2_sha1_parse_hash;
10169 sort_by_digest = sort_by_digest_4_32;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE
10181 | OPTS_TYPE_ST_BASE64
10182 | OPTS_TYPE_HASH_COPY;
10183 kern_type = KERN_TYPE_PBKDF2_SHA512;
10184 dgst_size = DGST_SIZE_8_16;
10185 parse_func = pbkdf2_sha512_parse_hash;
10186 sort_by_digest = sort_by_digest_8_16;
10187 opti_type = OPTI_TYPE_ZERO_BYTE
10188 | OPTI_TYPE_USES_BITS_64;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10196 salt_type = SALT_TYPE_EMBEDDED;
10197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10199 kern_type = KERN_TYPE_ECRYPTFS;
10200 dgst_size = DGST_SIZE_8_8;
10201 parse_func = ecryptfs_parse_hash;
10202 sort_by_digest = sort_by_digest_8_8;
10203 opti_type = OPTI_TYPE_ZERO_BYTE
10204 | OPTI_TYPE_USES_BITS_64;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 12300: hash_type = HASH_TYPE_ORACLET;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10215 kern_type = KERN_TYPE_ORACLET;
10216 dgst_size = DGST_SIZE_8_16;
10217 parse_func = oraclet_parse_hash;
10218 sort_by_digest = sort_by_digest_8_16;
10219 opti_type = OPTI_TYPE_ZERO_BYTE
10220 | OPTI_TYPE_USES_BITS_64;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_BSDICRYPT;
10232 dgst_size = DGST_SIZE_4_4;
10233 parse_func = bsdicrypt_parse_hash;
10234 sort_by_digest = sort_by_digest_4_4;
10235 opti_type = OPTI_TYPE_ZERO_BYTE
10236 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10237 dgst_pos0 = 0;
10238 dgst_pos1 = 1;
10239 dgst_pos2 = 2;
10240 dgst_pos3 = 3;
10241 break;
10242
10243 case 12500: hash_type = HASH_TYPE_RAR3HP;
10244 salt_type = SALT_TYPE_EMBEDDED;
10245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10247 kern_type = KERN_TYPE_RAR3;
10248 dgst_size = DGST_SIZE_4_4;
10249 parse_func = rar3hp_parse_hash;
10250 sort_by_digest = sort_by_digest_4_4;
10251 opti_type = OPTI_TYPE_ZERO_BYTE;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 12600: hash_type = HASH_TYPE_SHA256;
10259 salt_type = SALT_TYPE_INTERN;
10260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_BE
10262 | OPTS_TYPE_PT_ADD80;
10263 kern_type = KERN_TYPE_CF10;
10264 dgst_size = DGST_SIZE_4_8;
10265 parse_func = cf10_parse_hash;
10266 sort_by_digest = sort_by_digest_4_8;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_PRECOMPUTE_INIT
10269 | OPTI_TYPE_EARLY_SKIP
10270 | OPTI_TYPE_NOT_ITERATED;
10271 dgst_pos0 = 3;
10272 dgst_pos1 = 7;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 6;
10275 break;
10276
10277 case 12700: hash_type = HASH_TYPE_AES;
10278 salt_type = SALT_TYPE_EMBEDDED;
10279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_LE
10281 | OPTS_TYPE_HASH_COPY;
10282 kern_type = KERN_TYPE_MYWALLET;
10283 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10284 parse_func = mywallet_parse_hash;
10285 sort_by_digest = sort_by_digest_4_5;
10286 opti_type = OPTI_TYPE_ZERO_BYTE;
10287 dgst_pos0 = 0;
10288 dgst_pos1 = 1;
10289 dgst_pos2 = 2;
10290 dgst_pos3 = 3;
10291 break;
10292
10293 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10294 salt_type = SALT_TYPE_EMBEDDED;
10295 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10297 kern_type = KERN_TYPE_MS_DRSR;
10298 dgst_size = DGST_SIZE_4_8;
10299 parse_func = ms_drsr_parse_hash;
10300 sort_by_digest = sort_by_digest_4_8;
10301 opti_type = OPTI_TYPE_ZERO_BYTE;
10302 dgst_pos0 = 0;
10303 dgst_pos1 = 1;
10304 dgst_pos2 = 2;
10305 dgst_pos3 = 3;
10306 break;
10307
10308 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10309 salt_type = SALT_TYPE_EMBEDDED;
10310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10312 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10313 dgst_size = DGST_SIZE_4_8;
10314 parse_func = androidfde_samsung_parse_hash;
10315 sort_by_digest = sort_by_digest_4_8;
10316 opti_type = OPTI_TYPE_ZERO_BYTE;
10317 dgst_pos0 = 0;
10318 dgst_pos1 = 1;
10319 dgst_pos2 = 2;
10320 dgst_pos3 = 3;
10321 break;
10322
10323 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10324 salt_type = SALT_TYPE_EMBEDDED;
10325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10327 kern_type = KERN_TYPE_RAR5;
10328 dgst_size = DGST_SIZE_4_4;
10329 parse_func = rar5_parse_hash;
10330 sort_by_digest = sort_by_digest_4_4;
10331 opti_type = OPTI_TYPE_ZERO_BYTE;
10332 dgst_pos0 = 0;
10333 dgst_pos1 = 1;
10334 dgst_pos2 = 2;
10335 dgst_pos3 = 3;
10336 break;
10337
10338 default: usage_mini_print (PROGNAME); return (-1);
10339 }
10340
10341 /**
10342 * transpose
10343 */
10344
10345 data.parse_func = parse_func;
10346
10347 /**
10348 * misc stuff
10349 */
10350
10351 if (hex_salt)
10352 {
10353 if (salt_type == SALT_TYPE_INTERN)
10354 {
10355 opts_type |= OPTS_TYPE_ST_HEX;
10356 }
10357 else
10358 {
10359 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10360
10361 return (-1);
10362 }
10363 }
10364
10365 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10366 | (salt_type == SALT_TYPE_EXTERN)
10367 | (salt_type == SALT_TYPE_EMBEDDED)
10368 | (salt_type == SALT_TYPE_VIRTUAL));
10369
10370 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10371
10372 data.hash_type = hash_type;
10373 data.attack_mode = attack_mode;
10374 data.attack_kern = attack_kern;
10375 data.attack_exec = attack_exec;
10376 data.kern_type = kern_type;
10377 data.opts_type = opts_type;
10378 data.dgst_size = dgst_size;
10379 data.salt_type = salt_type;
10380 data.isSalted = isSalted;
10381 data.sort_by_digest = sort_by_digest;
10382 data.dgst_pos0 = dgst_pos0;
10383 data.dgst_pos1 = dgst_pos1;
10384 data.dgst_pos2 = dgst_pos2;
10385 data.dgst_pos3 = dgst_pos3;
10386
10387 esalt_size = 0;
10388
10389 switch (hash_mode)
10390 {
10391 case 2500: esalt_size = sizeof (wpa_t); break;
10392 case 5300: esalt_size = sizeof (ikepsk_t); break;
10393 case 5400: esalt_size = sizeof (ikepsk_t); break;
10394 case 5500: esalt_size = sizeof (netntlm_t); break;
10395 case 5600: esalt_size = sizeof (netntlm_t); break;
10396 case 6211: esalt_size = sizeof (tc_t); break;
10397 case 6212: esalt_size = sizeof (tc_t); break;
10398 case 6213: esalt_size = sizeof (tc_t); break;
10399 case 6221: esalt_size = sizeof (tc_t); break;
10400 case 6222: esalt_size = sizeof (tc_t); break;
10401 case 6223: esalt_size = sizeof (tc_t); break;
10402 case 6231: esalt_size = sizeof (tc_t); break;
10403 case 6232: esalt_size = sizeof (tc_t); break;
10404 case 6233: esalt_size = sizeof (tc_t); break;
10405 case 6241: esalt_size = sizeof (tc_t); break;
10406 case 6242: esalt_size = sizeof (tc_t); break;
10407 case 6243: esalt_size = sizeof (tc_t); break;
10408 case 6600: esalt_size = sizeof (agilekey_t); break;
10409 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10410 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10411 case 7300: esalt_size = sizeof (rakp_t); break;
10412 case 7500: esalt_size = sizeof (krb5pa_t); break;
10413 case 8200: esalt_size = sizeof (cloudkey_t); break;
10414 case 8800: esalt_size = sizeof (androidfde_t); break;
10415 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10416 case 9400: esalt_size = sizeof (office2007_t); break;
10417 case 9500: esalt_size = sizeof (office2010_t); break;
10418 case 9600: esalt_size = sizeof (office2013_t); break;
10419 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10420 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10421 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10422 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10423 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10424 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10425 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10426 case 10200: esalt_size = sizeof (cram_md5_t); break;
10427 case 10400: esalt_size = sizeof (pdf_t); break;
10428 case 10410: esalt_size = sizeof (pdf_t); break;
10429 case 10420: esalt_size = sizeof (pdf_t); break;
10430 case 10500: esalt_size = sizeof (pdf_t); break;
10431 case 10600: esalt_size = sizeof (pdf_t); break;
10432 case 10700: esalt_size = sizeof (pdf_t); break;
10433 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10434 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10435 case 11400: esalt_size = sizeof (sip_t); break;
10436 case 11600: esalt_size = sizeof (seven_zip_t); break;
10437 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10438 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10439 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10440 case 13000: esalt_size = sizeof (rar5_t); break;
10441 }
10442
10443 data.esalt_size = esalt_size;
10444
10445 /**
10446 * choose dictionary parser
10447 */
10448
10449 if (hash_type == HASH_TYPE_LM)
10450 {
10451 get_next_word_func = get_next_word_lm;
10452 }
10453 else if (opts_type & OPTS_TYPE_PT_UPPER)
10454 {
10455 get_next_word_func = get_next_word_uc;
10456 }
10457 else
10458 {
10459 get_next_word_func = get_next_word_std;
10460 }
10461
10462 /**
10463 * dictstat
10464 */
10465
10466 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10467
10468 #ifdef _POSIX
10469 size_t dictstat_nmemb = 0;
10470 #endif
10471
10472 #ifdef _WIN
10473 uint dictstat_nmemb = 0;
10474 #endif
10475
10476 char dictstat[256] = { 0 };
10477
10478 FILE *dictstat_fp = NULL;
10479
10480 if (keyspace == 0)
10481 {
10482 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10483
10484 dictstat_fp = fopen (dictstat, "rb");
10485
10486 if (dictstat_fp)
10487 {
10488 #ifdef _POSIX
10489 struct stat tmpstat;
10490
10491 fstat (fileno (dictstat_fp), &tmpstat);
10492 #endif
10493
10494 #ifdef _WIN
10495 struct stat64 tmpstat;
10496
10497 _fstat64 (fileno (dictstat_fp), &tmpstat);
10498 #endif
10499
10500 if (tmpstat.st_mtime < COMPTIME)
10501 {
10502 /* with v0.15 the format changed so we have to ensure user is using a good version
10503 since there is no version-header in the dictstat file */
10504
10505 fclose (dictstat_fp);
10506
10507 unlink (dictstat);
10508 }
10509 else
10510 {
10511 while (!feof (dictstat_fp))
10512 {
10513 dictstat_t d;
10514
10515 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10516
10517 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10518
10519 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10520 {
10521 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10522
10523 return -1;
10524 }
10525 }
10526
10527 fclose (dictstat_fp);
10528 }
10529 }
10530 }
10531
10532 /**
10533 * potfile
10534 */
10535
10536 char potfile[256] = { 0 };
10537
10538 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10539
10540 data.pot_fp = NULL;
10541
10542 FILE *out_fp = NULL;
10543 FILE *pot_fp = NULL;
10544
10545 if (show == 1 || left == 1)
10546 {
10547 pot_fp = fopen (potfile, "rb");
10548
10549 if (pot_fp == NULL)
10550 {
10551 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10552
10553 return (-1);
10554 }
10555
10556 if (outfile != NULL)
10557 {
10558 if ((out_fp = fopen (outfile, "ab")) == NULL)
10559 {
10560 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10561
10562 fclose (pot_fp);
10563
10564 return (-1);
10565 }
10566 }
10567 else
10568 {
10569 out_fp = stdout;
10570 }
10571 }
10572 else
10573 {
10574 if (potfile_disable == 0)
10575 {
10576 pot_fp = fopen (potfile, "ab");
10577
10578 if (pot_fp == NULL)
10579 {
10580 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10581
10582 return (-1);
10583 }
10584
10585 data.pot_fp = pot_fp;
10586 }
10587 }
10588
10589 pot_t *pot = NULL;
10590
10591 uint pot_cnt = 0;
10592 uint pot_avail = 0;
10593
10594 if (show == 1 || left == 1)
10595 {
10596 SUPPRESS_OUTPUT = 1;
10597
10598 pot_avail = count_lines (pot_fp);
10599
10600 rewind (pot_fp);
10601
10602 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10603
10604 uint pot_hashes_avail = 0;
10605
10606 uint line_num = 0;
10607
10608 while (!feof (pot_fp))
10609 {
10610 line_num++;
10611
10612 char line_buf[BUFSIZ] = { 0 };
10613
10614 int line_len = fgetl (pot_fp, line_buf);
10615
10616 if (line_len == 0) continue;
10617
10618 char *plain_buf = line_buf + line_len;
10619
10620 pot_t *pot_ptr = &pot[pot_cnt];
10621
10622 hash_t *hashes_buf = &pot_ptr->hash;
10623
10624 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10625 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10626
10627 if (pot_cnt == pot_hashes_avail)
10628 {
10629 uint pos = 0;
10630
10631 for (pos = 0; pos < INCR_POT; pos++)
10632 {
10633 if ((pot_cnt + pos) >= pot_avail) break;
10634
10635 pot_t *tmp_pot = &pot[pot_cnt + pos];
10636
10637 hash_t *tmp_hash = &tmp_pot->hash;
10638
10639 tmp_hash->digest = mymalloc (dgst_size);
10640
10641 if (isSalted)
10642 {
10643 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10644 }
10645
10646 if (esalt_size)
10647 {
10648 tmp_hash->esalt = mymalloc (esalt_size);
10649 }
10650
10651 pot_hashes_avail++;
10652 }
10653 }
10654
10655 int plain_len = 0;
10656
10657 int parser_status;
10658
10659 int iter = MAX_CUT_TRIES;
10660
10661 do
10662 {
10663 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10664 {
10665 if (line_buf[i] == ':')
10666 {
10667 line_len--;
10668
10669 break;
10670 }
10671 }
10672
10673 if (data.hash_mode != 2500)
10674 {
10675 parser_status = parse_func (line_buf, line_len, hashes_buf);
10676 }
10677 else
10678 {
10679 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10680
10681 if (line_len > max_salt_size)
10682 {
10683 parser_status = PARSER_GLOBAL_LENGTH;
10684 }
10685 else
10686 {
10687 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10688
10689 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10690
10691 hashes_buf->salt->salt_len = line_len;
10692
10693 parser_status = PARSER_OK;
10694 }
10695 }
10696
10697 // if NOT parsed without error, we add the ":" to the plain
10698
10699 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10700 {
10701 plain_len++;
10702 plain_buf--;
10703 }
10704
10705 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10706
10707 if (parser_status < PARSER_GLOBAL_ZERO)
10708 {
10709 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10710
10711 continue;
10712 }
10713
10714 if (plain_len >= 255) continue;
10715
10716 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10717
10718 pot_ptr->plain_len = plain_len;
10719
10720 pot_cnt++;
10721 }
10722
10723 fclose (pot_fp);
10724
10725 SUPPRESS_OUTPUT = 0;
10726
10727 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10728 }
10729
10730 /**
10731 * word len
10732 */
10733
10734 uint pw_min = PW_MIN;
10735 uint pw_max = PW_MAX;
10736
10737 switch (hash_mode)
10738 {
10739 case 400: if (pw_max > 40) pw_max = 40;
10740 break;
10741 case 500: if (pw_max > 16) pw_max = 16;
10742 break;
10743 case 1500: if (pw_max > 8) pw_max = 8;
10744 break;
10745 case 1600: if (pw_max > 16) pw_max = 16;
10746 break;
10747 case 1800: if (pw_max > 16) pw_max = 16;
10748 break;
10749 case 2100: if (pw_max > 16) pw_max = 16;
10750 break;
10751 case 2500: if (pw_min < 8) pw_min = 8;
10752 break;
10753 case 3000: if (pw_max > 7) pw_max = 7;
10754 break;
10755 case 5200: if (pw_max > 24) pw_max = 24;
10756 break;
10757 case 5800: if (pw_max > 16) pw_max = 16;
10758 break;
10759 case 6300: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 7400: if (pw_max > 16) pw_max = 16;
10762 break;
10763 case 7900: if (pw_max > 48) pw_max = 48;
10764 break;
10765 case 8500: if (pw_max > 8) pw_max = 8;
10766 break;
10767 case 8600: if (pw_max > 16) pw_max = 16;
10768 break;
10769 case 9710: pw_min = 5;
10770 pw_max = 5;
10771 break;
10772 case 9810: pw_min = 5;
10773 pw_max = 5;
10774 break;
10775 case 10410: pw_min = 5;
10776 pw_max = 5;
10777 break;
10778 case 10300: if (pw_max < 3) pw_min = 3;
10779 if (pw_max > 40) pw_max = 40;
10780 break;
10781 case 10500: if (pw_max < 3) pw_min = 3;
10782 if (pw_max > 40) pw_max = 40;
10783 break;
10784 case 10700: if (pw_max > 16) pw_max = 16;
10785 break;
10786 case 11300: if (pw_max > 40) pw_max = 40;
10787 break;
10788 case 12500: if (pw_max > 20) pw_max = 20;
10789 break;
10790 case 12800: if (pw_max > 24) pw_max = 24;
10791 break;
10792 }
10793
10794 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10795 {
10796 switch (attack_kern)
10797 {
10798 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10799 break;
10800 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10801 break;
10802 }
10803 }
10804
10805 /**
10806 * charsets : keep them together for more easy maintainnce
10807 */
10808
10809 cs_t mp_sys[6] = { { { 0 }, 0 } };
10810 cs_t mp_usr[4] = { { { 0 }, 0 } };
10811
10812 mp_setup_sys (mp_sys);
10813
10814 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10815 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10816 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10817 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10818
10819 /**
10820 * load hashes, part I: find input mode, count hashes
10821 */
10822
10823 uint hashlist_mode = 0;
10824 uint hashlist_format = HLFMT_HASHCAT;
10825
10826 uint hashes_avail = 0;
10827
10828 if (benchmark == 0)
10829 {
10830 struct stat f;
10831
10832 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10833
10834 if ((hash_mode == 2500) ||
10835 (hash_mode == 5200) ||
10836 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10837 (hash_mode == 9000))
10838 {
10839 hashlist_mode = HL_MODE_ARG;
10840
10841 char *hashfile = myargv[optind];
10842
10843 data.hashfile = hashfile;
10844
10845 logfile_top_var_string ("target", hashfile);
10846 }
10847
10848 if (hashlist_mode == HL_MODE_ARG)
10849 {
10850 if (hash_mode == 2500)
10851 {
10852 struct stat st;
10853
10854 if (stat (data.hashfile, &st) == -1)
10855 {
10856 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10857
10858 return (-1);
10859 }
10860
10861 hashes_avail = st.st_size / sizeof (hccap_t);
10862 }
10863 else
10864 {
10865 hashes_avail = 1;
10866 }
10867 }
10868 else if (hashlist_mode == HL_MODE_FILE)
10869 {
10870 char *hashfile = myargv[optind];
10871
10872 data.hashfile = hashfile;
10873
10874 logfile_top_var_string ("target", hashfile);
10875
10876 FILE *fp = NULL;
10877
10878 if ((fp = fopen (hashfile, "rb")) == NULL)
10879 {
10880 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10881
10882 return (-1);
10883 }
10884
10885 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10886
10887 hashes_avail = count_lines (fp);
10888
10889 rewind (fp);
10890
10891 if (hashes_avail == 0)
10892 {
10893 log_error ("ERROR: hashfile is empty or corrupt");
10894
10895 fclose (fp);
10896
10897 return (-1);
10898 }
10899
10900 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10901
10902 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10903 {
10904 log_error ("ERROR: remove not supported in native hashfile-format mode");
10905
10906 fclose (fp);
10907
10908 return (-1);
10909 }
10910
10911 fclose (fp);
10912 }
10913 }
10914 else
10915 {
10916 hashlist_mode = HL_MODE_ARG;
10917
10918 hashes_avail = 1;
10919 }
10920
10921 if (hash_mode == 3000) hashes_avail *= 2;
10922
10923 data.hashlist_mode = hashlist_mode;
10924 data.hashlist_format = hashlist_format;
10925
10926 logfile_top_uint (hashlist_mode);
10927 logfile_top_uint (hashlist_format);
10928
10929 /**
10930 * load hashes, part II: allocate required memory, set pointers
10931 */
10932
10933 hash_t *hashes_buf = NULL;
10934 void *digests_buf = NULL;
10935 salt_t *salts_buf = NULL;
10936 void *esalts_buf = NULL;
10937
10938 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10939
10940 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10941
10942 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10943 {
10944 u32 hash_pos;
10945
10946 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10947 {
10948 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10949
10950 hashes_buf[hash_pos].hash_info = hash_info;
10951
10952 if (username && (remove || show || left))
10953 {
10954 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10955 }
10956
10957 if (benchmark)
10958 {
10959 hash_info->orighash = (char *) mymalloc (256);
10960 }
10961 }
10962 }
10963
10964 if (isSalted)
10965 {
10966 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10967
10968 if (esalt_size)
10969 {
10970 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10971 }
10972 }
10973 else
10974 {
10975 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10976 }
10977
10978 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10979 {
10980 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10981
10982 if (isSalted)
10983 {
10984 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10985
10986 if (esalt_size)
10987 {
10988 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10989 }
10990 }
10991 else
10992 {
10993 hashes_buf[hash_pos].salt = &salts_buf[0];
10994 }
10995 }
10996
10997 /**
10998 * load hashes, part III: parse hashes or generate them if benchmark
10999 */
11000
11001 uint hashes_cnt = 0;
11002
11003 if (benchmark == 0)
11004 {
11005 if (keyspace == 1)
11006 {
11007 // useless to read hash file for keyspace, cheat a little bit w/ optind
11008 }
11009 else if (hashes_avail == 0)
11010 {
11011 }
11012 else if (hashlist_mode == HL_MODE_ARG)
11013 {
11014 char *input_buf = myargv[optind];
11015
11016 uint input_len = strlen (input_buf);
11017
11018 logfile_top_var_string ("target", input_buf);
11019
11020 char *hash_buf = NULL;
11021 int hash_len = 0;
11022
11023 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11024
11025 if (hash_len)
11026 {
11027 if (opts_type & OPTS_TYPE_HASH_COPY)
11028 {
11029 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11030
11031 hash_info_tmp->orighash = mystrdup (hash_buf);
11032 }
11033
11034 if (isSalted)
11035 {
11036 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11037 }
11038
11039 int parser_status = PARSER_OK;
11040
11041 if (hash_mode == 2500)
11042 {
11043 if (hash_len == 0)
11044 {
11045 log_error ("ERROR: hccap file not specified");
11046
11047 return (-1);
11048 }
11049
11050 hashlist_mode = HL_MODE_FILE;
11051
11052 data.hashlist_mode = hashlist_mode;
11053
11054 FILE *fp = fopen (hash_buf, "rb");
11055
11056 if (fp == NULL)
11057 {
11058 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11059
11060 return (-1);
11061 }
11062
11063 if (hashes_avail < 1)
11064 {
11065 log_error ("ERROR: hccap file is empty or corrupt");
11066
11067 fclose (fp);
11068
11069 return (-1);
11070 }
11071
11072 uint hccap_size = sizeof (hccap_t);
11073
11074 char *in = (char *) mymalloc (hccap_size);
11075
11076 while (!feof (fp))
11077 {
11078 int n = fread (in, hccap_size, 1, fp);
11079
11080 if (n != 1)
11081 {
11082 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11083
11084 break;
11085 }
11086
11087 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11088
11089 if (parser_status != PARSER_OK)
11090 {
11091 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11092
11093 continue;
11094 }
11095
11096 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11097
11098 if ((show == 1) || (left == 1))
11099 {
11100 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11101
11102 char *salt_ptr = (char *) tmp_salt->salt_buf;
11103
11104 int cur_pos = tmp_salt->salt_len;
11105 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11106
11107 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11108
11109 u8 *pke_ptr = (u8 *) wpa->pke;
11110
11111 // do the appending task
11112
11113 snprintf (salt_ptr + cur_pos,
11114 rem_len,
11115 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11116 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11117 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11118
11119
11120 // memset () the remaining part of the salt
11121
11122 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11123 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11124
11125 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11126
11127 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11128 }
11129
11130 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);
11131 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);
11132
11133 hashes_cnt++;
11134 }
11135
11136 fclose (fp);
11137
11138 myfree (in);
11139 }
11140 else if (hash_mode == 3000)
11141 {
11142 if (hash_len == 32)
11143 {
11144 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11145
11146 hash_t *lm_hash_left = NULL;
11147
11148 if (parser_status == PARSER_OK)
11149 {
11150 lm_hash_left = &hashes_buf[hashes_cnt];
11151
11152 hashes_cnt++;
11153 }
11154 else
11155 {
11156 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11157 }
11158
11159 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11160
11161 hash_t *lm_hash_right = NULL;
11162
11163 if (parser_status == PARSER_OK)
11164 {
11165 lm_hash_right = &hashes_buf[hashes_cnt];
11166
11167 hashes_cnt++;
11168 }
11169 else
11170 {
11171 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11172 }
11173
11174 // show / left
11175
11176 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11177 {
11178 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);
11179 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);
11180 }
11181 }
11182 else
11183 {
11184 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11185
11186 if (parser_status == PARSER_OK)
11187 {
11188 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11189 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11190 }
11191
11192 if (parser_status == PARSER_OK)
11193 {
11194 hashes_cnt++;
11195 }
11196 else
11197 {
11198 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11199 }
11200 }
11201 }
11202 else
11203 {
11204 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11205
11206 if (parser_status == PARSER_OK)
11207 {
11208 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11209 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11210 }
11211
11212 if (parser_status == PARSER_OK)
11213 {
11214 hashes_cnt++;
11215 }
11216 else
11217 {
11218 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11219 }
11220 }
11221 }
11222 }
11223 else if (hashlist_mode == HL_MODE_FILE)
11224 {
11225 char *hashfile = data.hashfile;
11226
11227 FILE *fp;
11228
11229 if ((fp = fopen (hashfile, "rb")) == NULL)
11230 {
11231 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11232
11233 return (-1);
11234 }
11235
11236 uint line_num = 0;
11237
11238 while (!feof (fp))
11239 {
11240 line_num++;
11241
11242 char line_buf[BUFSIZ] = { 0 };
11243
11244 int line_len = fgetl (fp, line_buf);
11245
11246 if (line_len == 0) continue;
11247
11248 char *hash_buf = NULL;
11249 int hash_len = 0;
11250
11251 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11252
11253 if (username)
11254 {
11255 char *user_buf = NULL;
11256 int user_len = 0;
11257
11258 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11259
11260 if (remove || show)
11261 {
11262 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11263
11264 *user = (user_t *) mymalloc (sizeof (user_t));
11265
11266 user_t *user_ptr = *user;
11267
11268 if (user_buf != NULL)
11269 {
11270 user_ptr->user_name = mystrdup (user_buf);
11271 }
11272 else
11273 {
11274 user_ptr->user_name = mystrdup ("");
11275 }
11276
11277 user_ptr->user_len = user_len;
11278 }
11279 }
11280
11281 if (opts_type & OPTS_TYPE_HASH_COPY)
11282 {
11283 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11284
11285 hash_info_tmp->orighash = mystrdup (hash_buf);
11286 }
11287
11288 if (isSalted)
11289 {
11290 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11291 }
11292
11293 if (hash_mode == 3000)
11294 {
11295 if (hash_len == 32)
11296 {
11297 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11298
11299 if (parser_status < PARSER_GLOBAL_ZERO)
11300 {
11301 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11302
11303 continue;
11304 }
11305
11306 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11307
11308 hashes_cnt++;
11309
11310 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11311
11312 if (parser_status < PARSER_GLOBAL_ZERO)
11313 {
11314 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11315
11316 continue;
11317 }
11318
11319 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11320
11321 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);
11322
11323 hashes_cnt++;
11324
11325 // show / left
11326
11327 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);
11328 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);
11329 }
11330 else
11331 {
11332 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11333
11334 if (parser_status < PARSER_GLOBAL_ZERO)
11335 {
11336 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11337
11338 continue;
11339 }
11340
11341 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);
11342
11343 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11344 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11345
11346 hashes_cnt++;
11347 }
11348 }
11349 else
11350 {
11351 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11352
11353 if (parser_status < PARSER_GLOBAL_ZERO)
11354 {
11355 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11356
11357 continue;
11358 }
11359
11360 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);
11361
11362 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11363 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11364
11365 hashes_cnt++;
11366 }
11367 }
11368
11369 fclose (fp);
11370
11371 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11372
11373 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11374 }
11375 }
11376 else
11377 {
11378 if (isSalted)
11379 {
11380 hashes_buf[0].salt->salt_len = 8;
11381
11382 // special salt handling
11383
11384 switch (hash_mode)
11385 {
11386 case 1500: hashes_buf[0].salt->salt_len = 2;
11387 break;
11388 case 1731: hashes_buf[0].salt->salt_len = 4;
11389 break;
11390 case 2410: hashes_buf[0].salt->salt_len = 4;
11391 break;
11392 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11393 break;
11394 case 3100: hashes_buf[0].salt->salt_len = 1;
11395 break;
11396 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11397 break;
11398 case 5800: hashes_buf[0].salt->salt_len = 16;
11399 break;
11400 case 6800: hashes_buf[0].salt->salt_len = 32;
11401 break;
11402 case 8400: hashes_buf[0].salt->salt_len = 40;
11403 break;
11404 case 8800: hashes_buf[0].salt->salt_len = 16;
11405 break;
11406 case 8900: hashes_buf[0].salt->salt_len = 16;
11407 hashes_buf[0].salt->scrypt_N = 1024;
11408 hashes_buf[0].salt->scrypt_r = 1;
11409 hashes_buf[0].salt->scrypt_p = 1;
11410 break;
11411 case 9100: hashes_buf[0].salt->salt_len = 16;
11412 break;
11413 case 9300: hashes_buf[0].salt->salt_len = 14;
11414 hashes_buf[0].salt->scrypt_N = 16384;
11415 hashes_buf[0].salt->scrypt_r = 1;
11416 hashes_buf[0].salt->scrypt_p = 1;
11417 break;
11418 case 9400: hashes_buf[0].salt->salt_len = 16;
11419 break;
11420 case 9500: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 9600: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9700: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9710: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9720: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9800: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 9810: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 9820: hashes_buf[0].salt->salt_len = 16;
11435 break;
11436 case 10300: hashes_buf[0].salt->salt_len = 12;
11437 break;
11438 case 11500: hashes_buf[0].salt->salt_len = 4;
11439 break;
11440 case 11600: hashes_buf[0].salt->salt_len = 4;
11441 break;
11442 case 12400: hashes_buf[0].salt->salt_len = 4;
11443 break;
11444 case 12500: hashes_buf[0].salt->salt_len = 8;
11445 break;
11446 case 12600: hashes_buf[0].salt->salt_len = 64;
11447 break;
11448 }
11449
11450 // special esalt handling
11451
11452 switch (hash_mode)
11453 {
11454 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11455 break;
11456 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11457 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11458 break;
11459 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11460 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11461 break;
11462 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11463 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11464 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11465 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11466 break;
11467 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11468 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11469 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11470 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11471 break;
11472 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11473 break;
11474 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11475 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11476 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11477 break;
11478 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11481 break;
11482 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11485 break;
11486 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11489 break;
11490 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11491 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11492 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11493 break;
11494 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11495 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11496 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11497 break;
11498 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11499 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11500 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11501 break;
11502 }
11503 }
11504
11505 // set hashfile
11506
11507 switch (hash_mode)
11508 {
11509 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11510 break;
11511 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11512 break;
11513 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11514 break;
11515 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11516 break;
11517 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11518 break;
11519 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11520 break;
11521 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11540 break;
11541 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11542 break;
11543 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11544 break;
11545 }
11546
11547 // set default iterations
11548
11549 switch (hash_mode)
11550 {
11551 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11552 break;
11553 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11554 break;
11555 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11556 break;
11557 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11558 break;
11559 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11560 break;
11561 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11562 break;
11563 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11564 break;
11565 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11566 break;
11567 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11568 break;
11569 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11570 break;
11571 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11572 break;
11573 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11574 break;
11575 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11576 break;
11577 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11578 break;
11579 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11580 break;
11581 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11582 break;
11583 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11596 break;
11597 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11598 break;
11599 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11600 break;
11601 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11602 break;
11603 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11604 break;
11605 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11606 break;
11607 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11608 break;
11609 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11610 break;
11611 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11612 break;
11613 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11614 break;
11615 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11616 break;
11617 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11618 break;
11619 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11620 break;
11621 case 8900: hashes_buf[0].salt->salt_iter = 1;
11622 break;
11623 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11624 break;
11625 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11626 break;
11627 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11628 break;
11629 case 9300: hashes_buf[0].salt->salt_iter = 1;
11630 break;
11631 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11632 break;
11633 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11634 break;
11635 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11636 break;
11637 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11638 break;
11639 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11640 break;
11641 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11642 break;
11643 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11644 break;
11645 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11646 break;
11647 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11648 break;
11649 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11650 break;
11651 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11652 break;
11653 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11654 break;
11655 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11656 break;
11657 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11658 break;
11659 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11660 break;
11661 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11662 break;
11663 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11664 break;
11665 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11666 break;
11667 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11668 break;
11669 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11670 break;
11671 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11672 break;
11673 }
11674
11675 hashes_cnt = 1;
11676 }
11677
11678 if (show == 1 || left == 1)
11679 {
11680 for (uint i = 0; i < pot_cnt; i++)
11681 {
11682 pot_t *pot_ptr = &pot[i];
11683
11684 hash_t *hashes_buf = &pot_ptr->hash;
11685
11686 local_free (hashes_buf->digest);
11687
11688 if (isSalted)
11689 {
11690 local_free (hashes_buf->salt);
11691 }
11692 }
11693
11694 local_free (pot);
11695
11696 if (data.quiet == 0) log_info_nn ("");
11697
11698 return (0);
11699 }
11700
11701 if (keyspace == 0)
11702 {
11703 if (hashes_cnt == 0)
11704 {
11705 log_error ("ERROR: No hashes loaded");
11706
11707 return (-1);
11708 }
11709 }
11710
11711 /**
11712 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11713 */
11714
11715 if (data.outfile != NULL)
11716 {
11717 if (data.hashfile != NULL)
11718 {
11719 #ifdef _POSIX
11720 struct stat tmpstat_outfile;
11721 struct stat tmpstat_hashfile;
11722 #endif
11723
11724 #ifdef _WIN
11725 struct stat64 tmpstat_outfile;
11726 struct stat64 tmpstat_hashfile;
11727 #endif
11728
11729 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11730
11731 if (tmp_outfile_fp)
11732 {
11733 #ifdef _POSIX
11734 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11735 #endif
11736
11737 #ifdef _WIN
11738 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11739 #endif
11740
11741 fclose (tmp_outfile_fp);
11742 }
11743
11744 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11745
11746 if (tmp_hashfile_fp)
11747 {
11748 #ifdef _POSIX
11749 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11750 #endif
11751
11752 #ifdef _WIN
11753 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11754 #endif
11755
11756 fclose (tmp_hashfile_fp);
11757 }
11758
11759 if (tmp_outfile_fp && tmp_outfile_fp)
11760 {
11761 tmpstat_outfile.st_mode = 0;
11762 tmpstat_outfile.st_nlink = 0;
11763 tmpstat_outfile.st_uid = 0;
11764 tmpstat_outfile.st_gid = 0;
11765 tmpstat_outfile.st_rdev = 0;
11766 tmpstat_outfile.st_atime = 0;
11767
11768 tmpstat_hashfile.st_mode = 0;
11769 tmpstat_hashfile.st_nlink = 0;
11770 tmpstat_hashfile.st_uid = 0;
11771 tmpstat_hashfile.st_gid = 0;
11772 tmpstat_hashfile.st_rdev = 0;
11773 tmpstat_hashfile.st_atime = 0;
11774
11775 #ifdef _POSIX
11776 tmpstat_outfile.st_blksize = 0;
11777 tmpstat_outfile.st_blocks = 0;
11778
11779 tmpstat_hashfile.st_blksize = 0;
11780 tmpstat_hashfile.st_blocks = 0;
11781 #endif
11782
11783 #ifdef _POSIX
11784 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11785 {
11786 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11787
11788 return (-1);
11789 }
11790 #endif
11791
11792 #ifdef _WIN
11793 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11794 {
11795 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11796
11797 return (-1);
11798 }
11799 #endif
11800 }
11801 }
11802 }
11803
11804 /**
11805 * Remove duplicates
11806 */
11807
11808 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11809
11810 if (isSalted)
11811 {
11812 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11813 }
11814 else
11815 {
11816 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11817 }
11818
11819 uint hashes_cnt_orig = hashes_cnt;
11820
11821 hashes_cnt = 1;
11822
11823 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11824 {
11825 if (isSalted)
11826 {
11827 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11828 {
11829 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11830 }
11831 }
11832 else
11833 {
11834 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11835 }
11836
11837 if (hashes_pos > hashes_cnt)
11838 {
11839 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11840 }
11841
11842 hashes_cnt++;
11843 }
11844
11845 /**
11846 * Potfile removes
11847 */
11848
11849 uint potfile_remove_cracks = 0;
11850
11851 if (potfile_disable == 0)
11852 {
11853 hash_t hash_buf;
11854
11855 hash_buf.digest = mymalloc (dgst_size);
11856 hash_buf.salt = NULL;
11857 hash_buf.esalt = NULL;
11858 hash_buf.hash_info = NULL;
11859 hash_buf.cracked = 0;
11860
11861 if (isSalted)
11862 {
11863 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11864 }
11865
11866 if (esalt_size)
11867 {
11868 hash_buf.esalt = mymalloc (esalt_size);
11869 }
11870
11871 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11872
11873 // no solution for these special hash types (for instane because they use hashfile in output etc)
11874 if ((hash_mode != 5200) &&
11875 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11876 (hash_mode != 9000))
11877 {
11878 FILE *fp = fopen (potfile, "rb");
11879
11880 if (fp != NULL)
11881 {
11882 while (!feof (fp))
11883 {
11884 char line_buf[BUFSIZ] = { 0 };
11885
11886 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11887
11888 if (ptr == NULL) break;
11889
11890 int line_len = strlen (line_buf);
11891
11892 if (line_len == 0) continue;
11893
11894 int iter = MAX_CUT_TRIES;
11895
11896 for (int i = line_len - 1; i && iter; i--, line_len--)
11897 {
11898 if (line_buf[i] != ':') continue;
11899
11900 if (isSalted)
11901 {
11902 memset (hash_buf.salt, 0, sizeof (salt_t));
11903 }
11904
11905 hash_t *found = NULL;
11906
11907 if (hash_mode == 6800)
11908 {
11909 if (i < 64) // 64 = 16 * uint in salt_buf[]
11910 {
11911 // manipulate salt_buf
11912 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11913
11914 hash_buf.salt->salt_len = i;
11915
11916 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11917 }
11918 }
11919 else if (hash_mode == 2500)
11920 {
11921 if (i < 64) // 64 = 16 * uint in salt_buf[]
11922 {
11923 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11924 // manipulate salt_buf
11925
11926 // to be safe work with a copy (because of line_len loop, i etc)
11927
11928 char line_buf_cpy[BUFSIZ] = { 0 };
11929
11930 memcpy (line_buf_cpy, line_buf, i);
11931
11932 char *mac2_pos = strrchr (line_buf_cpy, ':');
11933
11934 if (mac2_pos == NULL) continue;
11935
11936 mac2_pos[0] = 0;
11937 mac2_pos++;
11938
11939 if (strlen (mac2_pos) != 12) continue;
11940
11941 char *mac1_pos = strrchr (line_buf_cpy, ':');
11942
11943 if (mac1_pos == NULL) continue;
11944
11945 mac1_pos[0] = 0;
11946 mac1_pos++;
11947
11948 if (strlen (mac1_pos) != 12) continue;
11949
11950 uint essid_length = mac1_pos - line_buf_cpy - 1;
11951
11952 // here we need the ESSID
11953 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11954
11955 hash_buf.salt->salt_len = essid_length;
11956
11957 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11958
11959 if (found)
11960 {
11961 wpa_t *wpa = (wpa_t *) found->esalt;
11962
11963 uint pke[25] = { 0 };
11964
11965 char *pke_ptr = (char *) pke;
11966
11967 for (uint i = 0; i < 25; i++)
11968 {
11969 pke[i] = byte_swap_32 (wpa->pke[i]);
11970 }
11971
11972 u8 mac1[6] = { 0 };
11973 u8 mac2[6] = { 0 };
11974
11975 memcpy (mac1, pke_ptr + 23, 6);
11976 memcpy (mac2, pke_ptr + 29, 6);
11977
11978 // compare hex string(s) vs binary MAC address(es)
11979
11980 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11981 {
11982 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11983 {
11984 found = NULL;
11985 break;
11986 }
11987 }
11988
11989 // early skip ;)
11990 if (!found) continue;
11991
11992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11993 {
11994 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11995 {
11996 found = NULL;
11997 break;
11998 }
11999 }
12000 }
12001 }
12002 }
12003 else
12004 {
12005 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12006
12007 if (parser_status == PARSER_OK)
12008 {
12009 if (isSalted)
12010 {
12011 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12012 }
12013 else
12014 {
12015 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12016 }
12017 }
12018 }
12019
12020 if (found == NULL) continue;
12021
12022 if (!found->cracked) potfile_remove_cracks++;
12023
12024 found->cracked = 1;
12025
12026 if (found) break;
12027
12028 iter--;
12029 }
12030 }
12031
12032 fclose (fp);
12033 }
12034 }
12035
12036 if (esalt_size)
12037 {
12038 local_free (hash_buf.esalt);
12039 }
12040
12041 if (isSalted)
12042 {
12043 local_free (hash_buf.salt);
12044 }
12045
12046 local_free (hash_buf.digest);
12047 }
12048
12049 /**
12050 * Now generate all the buffers required for later
12051 */
12052
12053 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12054
12055 salt_t *salts_buf_new = NULL;
12056 void *esalts_buf_new = NULL;
12057
12058 if (isSalted)
12059 {
12060 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12061
12062 if (esalt_size)
12063 {
12064 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12065 }
12066 }
12067 else
12068 {
12069 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12070 }
12071
12072 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12073
12074 uint digests_cnt = hashes_cnt;
12075 uint digests_done = 0;
12076
12077 uint size_digests = digests_cnt * dgst_size;
12078 uint size_shown = digests_cnt * sizeof (uint);
12079
12080 uint *digests_shown = (uint *) mymalloc (size_shown);
12081 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12082
12083 uint salts_cnt = 0;
12084 uint salts_done = 0;
12085
12086 hashinfo_t **hash_info = NULL;
12087
12088 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12089 {
12090 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12091
12092 if (username && (remove || show))
12093 {
12094 uint user_pos;
12095
12096 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12097 {
12098 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12099
12100 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12101 }
12102 }
12103 }
12104
12105 uint *salts_shown = (uint *) mymalloc (size_shown);
12106
12107 salt_t *salt_buf;
12108
12109 {
12110 // copied from inner loop
12111
12112 salt_buf = &salts_buf_new[salts_cnt];
12113
12114 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12115
12116 if (esalt_size)
12117 {
12118 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12119 }
12120
12121 salt_buf->digests_cnt = 0;
12122 salt_buf->digests_done = 0;
12123 salt_buf->digests_offset = 0;
12124
12125 salts_cnt++;
12126 }
12127
12128 if (hashes_buf[0].cracked == 1)
12129 {
12130 digests_shown[0] = 1;
12131
12132 digests_done++;
12133
12134 salt_buf->digests_done++;
12135 }
12136
12137 salt_buf->digests_cnt++;
12138
12139 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12140
12141 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12142 {
12143 hash_info[0] = hashes_buf[0].hash_info;
12144 }
12145
12146 // copy from inner loop
12147
12148 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12149 {
12150 if (isSalted)
12151 {
12152 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12153 {
12154 salt_buf = &salts_buf_new[salts_cnt];
12155
12156 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12157
12158 if (esalt_size)
12159 {
12160 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12161 }
12162
12163 salt_buf->digests_cnt = 0;
12164 salt_buf->digests_done = 0;
12165 salt_buf->digests_offset = hashes_pos;
12166
12167 salts_cnt++;
12168 }
12169 }
12170
12171 if (hashes_buf[hashes_pos].cracked == 1)
12172 {
12173 digests_shown[hashes_pos] = 1;
12174
12175 digests_done++;
12176
12177 salt_buf->digests_done++;
12178 }
12179
12180 salt_buf->digests_cnt++;
12181
12182 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12183
12184 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12185 {
12186 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12187 }
12188 }
12189
12190 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12191 {
12192 salt_t *salt_buf = &salts_buf_new[salt_pos];
12193
12194 if (salt_buf->digests_done == salt_buf->digests_cnt)
12195 {
12196 salts_shown[salt_pos] = 1;
12197
12198 salts_done++;
12199 }
12200
12201 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12202 }
12203
12204 local_free (digests_buf);
12205 local_free (salts_buf);
12206 local_free (esalts_buf);
12207
12208 digests_buf = digests_buf_new;
12209 salts_buf = salts_buf_new;
12210 esalts_buf = esalts_buf_new;
12211
12212 local_free (hashes_buf);
12213
12214 /**
12215 * special modification not set from parser
12216 */
12217
12218 switch (hash_mode)
12219 {
12220 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12221 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12222 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12223 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12224 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12225 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12226 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12227 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12228 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12229 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12230 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12231 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12232 }
12233
12234 if (truecrypt_keyfiles)
12235 {
12236 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12237
12238 char *keyfiles = strdup (truecrypt_keyfiles);
12239
12240 char *keyfile = strtok (keyfiles, ",");
12241
12242 do
12243 {
12244 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12245
12246 } while ((keyfile = strtok (NULL, ",")) != NULL);
12247
12248 free (keyfiles);
12249 }
12250
12251 data.digests_cnt = digests_cnt;
12252 data.digests_done = digests_done;
12253 data.digests_buf = digests_buf;
12254 data.digests_shown = digests_shown;
12255 data.digests_shown_tmp = digests_shown_tmp;
12256
12257 data.salts_cnt = salts_cnt;
12258 data.salts_done = salts_done;
12259 data.salts_buf = salts_buf;
12260 data.salts_shown = salts_shown;
12261
12262 data.esalts_buf = esalts_buf;
12263 data.hash_info = hash_info;
12264
12265 /**
12266 * Automatic Optimizers
12267 */
12268
12269 if (salts_cnt == 1)
12270 opti_type |= OPTI_TYPE_SINGLE_SALT;
12271
12272 if (digests_cnt == 1)
12273 opti_type |= OPTI_TYPE_SINGLE_HASH;
12274
12275 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12276 opti_type |= OPTI_TYPE_NOT_ITERATED;
12277
12278 if (attack_mode == ATTACK_MODE_BF)
12279 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12280
12281 data.opti_type = opti_type;
12282
12283 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12284 {
12285 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12286 {
12287 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12288 {
12289 if (opts_type & OPTS_TYPE_ST_ADD80)
12290 {
12291 opts_type &= ~OPTS_TYPE_ST_ADD80;
12292 opts_type |= OPTS_TYPE_PT_ADD80;
12293 }
12294
12295 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12296 {
12297 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12298 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12299 }
12300
12301 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12302 {
12303 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12304 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12305 }
12306 }
12307 }
12308 }
12309
12310 /**
12311 * Some algorithm, like descrypt, can benefit from JIT compilation
12312 */
12313
12314 int force_jit_compilation = -1;
12315
12316 if (hash_mode == 8900)
12317 {
12318 force_jit_compilation = 8900;
12319 }
12320 else if (hash_mode == 9300)
12321 {
12322 force_jit_compilation = 8900;
12323 }
12324 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12325 {
12326 force_jit_compilation = 1500;
12327 }
12328
12329 /**
12330 * generate bitmap tables
12331 */
12332
12333 const uint bitmap_shift1 = 5;
12334 const uint bitmap_shift2 = 13;
12335
12336 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12337
12338 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12339 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12340 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12341 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12342 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12343 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346
12347 uint bitmap_bits;
12348 uint bitmap_nums;
12349 uint bitmap_mask;
12350 uint bitmap_size;
12351
12352 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12353 {
12354 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12355
12356 bitmap_nums = 1 << bitmap_bits;
12357
12358 bitmap_mask = bitmap_nums - 1;
12359
12360 bitmap_size = bitmap_nums * sizeof (uint);
12361
12362 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12363
12364 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;
12365 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;
12366
12367 break;
12368 }
12369
12370 bitmap_nums = 1 << bitmap_bits;
12371
12372 bitmap_mask = bitmap_nums - 1;
12373
12374 bitmap_size = bitmap_nums * sizeof (uint);
12375
12376 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);
12377 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);
12378
12379 /**
12380 * prepare quick rule
12381 */
12382
12383 data.rule_buf_l = rule_buf_l;
12384 data.rule_buf_r = rule_buf_r;
12385
12386 int rule_len_l = (int) strlen (rule_buf_l);
12387 int rule_len_r = (int) strlen (rule_buf_r);
12388
12389 data.rule_len_l = rule_len_l;
12390 data.rule_len_r = rule_len_r;
12391
12392 /**
12393 * load rules
12394 */
12395
12396 uint *all_kernel_rules_cnt = NULL;
12397
12398 kernel_rule_t **all_kernel_rules_buf = NULL;
12399
12400 if (rp_files_cnt)
12401 {
12402 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12403
12404 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12405 }
12406
12407 char rule_buf[BUFSIZ] = { 0 };
12408
12409 int rule_len = 0;
12410
12411 for (uint i = 0; i < rp_files_cnt; i++)
12412 {
12413 uint kernel_rules_avail = 0;
12414
12415 uint kernel_rules_cnt = 0;
12416
12417 kernel_rule_t *kernel_rules_buf = NULL;
12418
12419 char *rp_file = rp_files[i];
12420
12421 char in[BLOCK_SIZE] = { 0 };
12422 char out[BLOCK_SIZE] = { 0 };
12423
12424 FILE *fp = NULL;
12425
12426 uint rule_line = 0;
12427
12428 if ((fp = fopen (rp_file, "rb")) == NULL)
12429 {
12430 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12431
12432 return (-1);
12433 }
12434
12435 while (!feof (fp))
12436 {
12437 memset (rule_buf, 0, BUFSIZ);
12438
12439 rule_len = fgetl (fp, rule_buf);
12440
12441 rule_line++;
12442
12443 if (rule_len == 0) continue;
12444
12445 if (rule_buf[0] == '#') continue;
12446
12447 if (kernel_rules_avail == kernel_rules_cnt)
12448 {
12449 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12450
12451 kernel_rules_avail += INCR_RULES;
12452 }
12453
12454 memset (in, 0, BLOCK_SIZE);
12455 memset (out, 0, BLOCK_SIZE);
12456
12457 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12458
12459 if (result == -1)
12460 {
12461 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12462
12463 continue;
12464 }
12465
12466 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12467 {
12468 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12469
12470 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12471
12472 continue;
12473 }
12474
12475 /* its so slow
12476 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12477 {
12478 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12479
12480 continue;
12481 }
12482 */
12483
12484 kernel_rules_cnt++;
12485 }
12486
12487 fclose (fp);
12488
12489 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12490
12491 all_kernel_rules_buf[i] = kernel_rules_buf;
12492 }
12493
12494 /**
12495 * merge rules or automatic rule generator
12496 */
12497
12498 uint kernel_rules_cnt = 0;
12499
12500 kernel_rule_t *kernel_rules_buf = NULL;
12501
12502 if (attack_mode == ATTACK_MODE_STRAIGHT)
12503 {
12504 if (rp_files_cnt)
12505 {
12506 kernel_rules_cnt = 1;
12507
12508 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12509
12510 repeats[0] = kernel_rules_cnt;
12511
12512 for (uint i = 0; i < rp_files_cnt; i++)
12513 {
12514 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12515
12516 repeats[i + 1] = kernel_rules_cnt;
12517 }
12518
12519 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12520
12521 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12522
12523 for (uint i = 0; i < kernel_rules_cnt; i++)
12524 {
12525 uint out_pos = 0;
12526
12527 kernel_rule_t *out = &kernel_rules_buf[i];
12528
12529 for (uint j = 0; j < rp_files_cnt; j++)
12530 {
12531 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12532 uint in_pos;
12533
12534 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12535
12536 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12537 {
12538 if (out_pos == RULES_MAX - 1)
12539 {
12540 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12541
12542 break;
12543 }
12544
12545 out->cmds[out_pos] = in->cmds[in_pos];
12546 }
12547 }
12548 }
12549
12550 local_free (repeats);
12551 }
12552 else if (rp_gen)
12553 {
12554 uint kernel_rules_avail = 0;
12555
12556 while (kernel_rules_cnt < rp_gen)
12557 {
12558 if (kernel_rules_avail == kernel_rules_cnt)
12559 {
12560 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12561
12562 kernel_rules_avail += INCR_RULES;
12563 }
12564
12565 memset (rule_buf, 0, BLOCK_SIZE);
12566
12567 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12568
12569 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12570
12571 kernel_rules_cnt++;
12572 }
12573 }
12574 }
12575
12576 /**
12577 * generate NOP rules
12578 */
12579
12580 if (kernel_rules_cnt == 0)
12581 {
12582 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12583
12584 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12585
12586 kernel_rules_cnt++;
12587 }
12588
12589 data.kernel_rules_cnt = kernel_rules_cnt;
12590 data.kernel_rules_buf = kernel_rules_buf;
12591
12592 /**
12593 * OpenCL platforms: detect
12594 */
12595
12596 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12597 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12598
12599 cl_uint platforms_cnt = 0;
12600 cl_uint platform_devices_cnt = 0;
12601
12602 if (keyspace == 0)
12603 {
12604 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12605
12606 if (platforms_cnt == 0)
12607 {
12608 log_error ("ERROR: No OpenCL compatible platform found");
12609
12610 return (-1);
12611 }
12612 }
12613
12614 /**
12615 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12616 */
12617
12618 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12619 {
12620 cl_platform_id platform = platforms[platform_id];
12621
12622 char platform_vendor[INFOSZ] = { 0 };
12623
12624 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12625
12626 #ifdef HAVE_HWMON
12627 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12628 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12629 {
12630 // make sure that we do not directly control the fan for NVidia
12631
12632 gpu_temp_retain = 0;
12633
12634 data.gpu_temp_retain = gpu_temp_retain;
12635 }
12636 #endif // HAVE_NVML || HAVE_NVAPI
12637 #endif
12638 }
12639
12640 /**
12641 * OpenCL devices: simply push all devices from all platforms into the same device array
12642 */
12643
12644 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12645
12646 data.devices_param = devices_param;
12647
12648 uint devices_cnt = 0;
12649
12650 uint devices_active = 0;
12651
12652 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12653 {
12654 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12655
12656 cl_platform_id platform = platforms[platform_id];
12657
12658 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12659
12660 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12661 {
12662 size_t param_value_size = 0;
12663
12664 const uint device_id = devices_cnt;
12665
12666 hc_device_param_t *device_param = &data.devices_param[device_id];
12667
12668 device_param->device = platform_devices[platform_devices_id];
12669
12670 device_param->device_id = device_id;
12671
12672 device_param->platform_devices_id = platform_devices_id;
12673
12674 // device_type
12675
12676 cl_device_type device_type;
12677
12678 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12679
12680 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12681
12682 device_param->device_type = device_type;
12683
12684 // vendor_id
12685
12686 cl_uint vendor_id = 0;
12687
12688 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12689
12690 device_param->vendor_id = vendor_id;
12691
12692 // device_name
12693
12694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12695
12696 char *device_name = (char *) mymalloc (param_value_size);
12697
12698 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12699
12700 device_param->device_name = device_name;
12701
12702 // tuning db
12703
12704 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12705
12706 // device_version
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12709
12710 char *device_version = (char *) mymalloc (param_value_size);
12711
12712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12713
12714 device_param->device_version = device_version;
12715
12716 // device_opencl_version
12717
12718 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12719
12720 char *device_opencl_version = (char *) mymalloc (param_value_size);
12721
12722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12723
12724 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12725
12726 myfree (device_opencl_version);
12727
12728 if (strstr (device_version, "pocl"))
12729 {
12730 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12731 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12732
12733 cl_uint vendor_id = VENDOR_ID_GENERIC;
12734
12735 device_param->vendor_id = vendor_id;
12736 }
12737
12738 // vector_width
12739
12740 cl_uint vector_width;
12741
12742 if (opencl_vector_width_chgd == 0)
12743 {
12744 if (tuningdb_entry == NULL)
12745 {
12746 if (opti_type & OPTI_TYPE_USES_BITS_64)
12747 {
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12749 }
12750 else
12751 {
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12753 }
12754 }
12755 else
12756 {
12757 if (tuningdb_entry->vector_width == -1)
12758 {
12759 if (opti_type & OPTI_TYPE_USES_BITS_64)
12760 {
12761 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12762 }
12763 else
12764 {
12765 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12766 }
12767 }
12768 else
12769 {
12770 vector_width = (cl_uint) tuningdb_entry->vector_width;
12771 }
12772 }
12773 }
12774 else
12775 {
12776 vector_width = opencl_vector_width;
12777 }
12778
12779 if (vector_width > 8) vector_width = 8;
12780
12781 device_param->vector_width = vector_width;
12782
12783 // max_compute_units
12784
12785 cl_uint device_processors;
12786
12787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12788
12789 device_param->device_processors = device_processors;
12790
12791 // max_mem_alloc_size
12792
12793 cl_ulong device_maxmem_alloc;
12794
12795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12796
12797 device_param->device_maxmem_alloc = device_maxmem_alloc;
12798
12799 // max_mem_alloc_size
12800
12801 cl_ulong device_global_mem;
12802
12803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12804
12805 device_param->device_global_mem = device_global_mem;
12806
12807 // max_clock_frequency
12808
12809 cl_uint device_maxclock_frequency;
12810
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12812
12813 device_param->device_maxclock_frequency = device_maxclock_frequency;
12814
12815 // skipped
12816
12817 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12818 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12819
12820 device_param->skipped = (skipped1 || skipped2);
12821
12822 // driver_version
12823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12824
12825 char *driver_version = (char *) mymalloc (param_value_size);
12826
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12828
12829 device_param->driver_version = driver_version;
12830
12831 // device_name_chksum
12832
12833 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12834
12835 #if __x86_64__
12836 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);
12837 #else
12838 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);
12839 #endif
12840
12841 uint device_name_digest[4] = { 0 };
12842
12843 md5_64 ((uint *) device_name_chksum, device_name_digest);
12844
12845 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12846
12847 device_param->device_name_chksum = device_name_chksum;
12848
12849 // device_processor_cores
12850
12851 if (device_type & CL_DEVICE_TYPE_CPU)
12852 {
12853 cl_uint device_processor_cores = 1;
12854
12855 device_param->device_processor_cores = device_processor_cores;
12856 }
12857
12858 if (device_type & CL_DEVICE_TYPE_GPU)
12859 {
12860 if (vendor_id == VENDOR_ID_AMD)
12861 {
12862 cl_uint device_processor_cores = 0;
12863
12864 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12865
12866 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12867
12868 device_param->device_processor_cores = device_processor_cores;
12869 }
12870 else if (vendor_id == VENDOR_ID_NV)
12871 {
12872 cl_uint kernel_exec_timeout = 0;
12873
12874 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12875
12876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12877
12878 device_param->kernel_exec_timeout = kernel_exec_timeout;
12879
12880 cl_uint device_processor_cores = 0;
12881
12882 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12883
12884 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12885
12886 device_param->device_processor_cores = device_processor_cores;
12887
12888 cl_uint sm_minor = 0;
12889 cl_uint sm_major = 0;
12890
12891 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12892 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12893
12894 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12895 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12896
12897 device_param->sm_minor = sm_minor;
12898 device_param->sm_major = sm_major;
12899 }
12900 else
12901 {
12902 cl_uint device_processor_cores = 1;
12903
12904 device_param->device_processor_cores = device_processor_cores;
12905 }
12906 }
12907
12908 // display results
12909
12910 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12911 {
12912 if (device_param->skipped == 0)
12913 {
12914 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12915 device_id + 1,
12916 device_name,
12917 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12918 (unsigned int) (device_global_mem / 1024 / 1024),
12919 (unsigned int) (device_maxclock_frequency),
12920 (unsigned int) device_processors);
12921 }
12922 else
12923 {
12924 log_info ("Device #%u: %s, skipped",
12925 device_id + 1,
12926 device_name);
12927 }
12928 }
12929
12930 // common driver check
12931
12932 if (device_param->skipped == 0)
12933 {
12934 if (strstr (device_version, "pocl"))
12935 {
12936 if (force == 0)
12937 {
12938 log_info ("");
12939 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12940 log_info ("You are STRONGLY encouraged not to use it");
12941 log_info ("You can use --force to override this but do not post error reports if you do so");
12942 log_info ("");
12943
12944 return (-1);
12945 }
12946 }
12947
12948 if (device_type & CL_DEVICE_TYPE_GPU)
12949 {
12950 if (vendor_id == VENDOR_ID_NV)
12951 {
12952 if (device_param->kernel_exec_timeout != 0)
12953 {
12954 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);
12955 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12956 }
12957 }
12958 else if (vendor_id == VENDOR_ID_AMD)
12959 {
12960 int catalyst_check = (force == 1) ? 0 : 1;
12961
12962 int catalyst_warn = 0;
12963
12964 int catalyst_broken = 0;
12965
12966 if (catalyst_check == 1)
12967 {
12968 catalyst_warn = 1;
12969
12970 // v14.9 and higher
12971 if (atoi (device_param->driver_version) >= 1573)
12972 {
12973 catalyst_warn = 0;
12974 }
12975
12976 catalyst_check = 0;
12977 }
12978
12979 if (catalyst_broken == 1)
12980 {
12981 log_info ("");
12982 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12983 log_info ("It will pass over cracked hashes and does not report them as cracked");
12984 log_info ("You are STRONGLY encouraged not to use it");
12985 log_info ("You can use --force to override this but do not post error reports if you do so");
12986 log_info ("");
12987
12988 return (-1);
12989 }
12990
12991 if (catalyst_warn == 1)
12992 {
12993 log_info ("");
12994 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12995 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12996 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12997 #ifdef _WIN
12998 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12999 #endif
13000 log_info ("You can use --force to override this but do not post error reports if you do so");
13001 log_info ("");
13002
13003 return (-1);
13004 }
13005 }
13006 }
13007
13008 /**
13009 * kernel accel and loops tuning db adjustment
13010 */
13011
13012 uint _kernel_accel = kernel_accel;
13013 uint _kernel_loops = kernel_loops;
13014
13015 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
13016
13017 if (kernel_accel_chgd == 0)
13018 {
13019 if (tuningdb_entry)
13020 {
13021 _kernel_accel = tuningdb_entry->kernel_accel;
13022 }
13023 }
13024
13025 if (kernel_loops_chgd == 0)
13026 {
13027 if (tuningdb_entry)
13028 {
13029 _kernel_loops = tuningdb_entry->kernel_loops;
13030
13031 if (workload_profile == 1)
13032 {
13033 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13034 }
13035 else if (workload_profile == 2)
13036 {
13037 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13038 }
13039 }
13040 }
13041
13042 device_param->kernel_accel = _kernel_accel;
13043 device_param->kernel_loops = _kernel_loops;
13044
13045 devices_active++;
13046 }
13047
13048 // next please
13049
13050 devices_cnt++;
13051 }
13052 }
13053
13054 if (keyspace == 0 && devices_active == 0)
13055 {
13056 log_error ("ERROR: No devices found/left");
13057
13058 return (-1);
13059 }
13060
13061 data.devices_cnt = devices_cnt;
13062
13063 data.devices_active = devices_active;
13064
13065 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13066 {
13067 log_info ("");
13068 }
13069
13070 /**
13071 * HM devices: init
13072 */
13073
13074 #ifdef HAVE_HWMON
13075 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13076 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13077 #endif
13078
13079 #ifdef HAVE_ADL
13080 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13081 #endif
13082
13083 if (gpu_temp_disable == 0)
13084 {
13085 #if defined(WIN) && defined(HAVE_NVAPI)
13086 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13087
13088 if (nvapi_init (nvapi) == 0)
13089 data.hm_nv = nvapi;
13090
13091 if (data.hm_nv)
13092 {
13093 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13094 {
13095 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13096
13097 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13098
13099 int tmp_out = 0;
13100
13101 for (int i = 0; i < tmp_in; i++)
13102 {
13103 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13104 }
13105
13106 for (int i = 0; i < tmp_out; i++)
13107 {
13108 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13109
13110 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13111
13112 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;
13113 }
13114 }
13115 }
13116 #endif // WIN && HAVE_NVAPI
13117
13118 #if defined(LINUX) && defined(HAVE_NVML)
13119 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13120
13121 if (nvml_init (nvml) == 0)
13122 data.hm_nv = nvml;
13123
13124 if (data.hm_nv)
13125 {
13126 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13127 {
13128 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13129
13130 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13131
13132 int tmp_out = 0;
13133
13134 for (int i = 0; i < tmp_in; i++)
13135 {
13136 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13137 }
13138
13139 for (int i = 0; i < tmp_out; i++)
13140 {
13141 unsigned int speed;
13142
13143 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;
13144 }
13145 }
13146 }
13147 #endif // LINUX && HAVE_NVML
13148
13149 data.hm_amd = NULL;
13150
13151 #ifdef HAVE_ADL
13152 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13153
13154 if (adl_init (adl) == 0)
13155 data.hm_amd = adl;
13156
13157 if (data.hm_amd)
13158 {
13159 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13160 {
13161 // total number of adapters
13162
13163 int hm_adapters_num;
13164
13165 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13166
13167 // adapter info
13168
13169 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13170
13171 if (lpAdapterInfo == NULL) return (-1);
13172
13173 // get a list (of ids of) valid/usable adapters
13174
13175 int num_adl_adapters = 0;
13176
13177 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13178
13179 if (num_adl_adapters > 0)
13180 {
13181 hc_thread_mutex_lock (mux_adl);
13182
13183 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13184
13185 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13186
13187 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13188 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13189
13190 hc_thread_mutex_unlock (mux_adl);
13191 }
13192
13193 myfree (valid_adl_device_list);
13194 myfree (lpAdapterInfo);
13195 }
13196 }
13197 #endif // HAVE_ADL
13198
13199 if (data.hm_amd == NULL && data.hm_nv == NULL)
13200 {
13201 gpu_temp_disable = 1;
13202 }
13203 }
13204
13205 /**
13206 * OpenCL devices: allocate buffer for device specific information
13207 */
13208
13209 #ifdef HAVE_HWMON
13210 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13211
13212 #ifdef HAVE_ADL
13213 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13214
13215 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13216 #endif // ADL
13217 #endif
13218
13219 /**
13220 * enable custom signal handler(s)
13221 */
13222
13223 if (benchmark == 0)
13224 {
13225 hc_signal (sigHandler_default);
13226 }
13227 else
13228 {
13229 hc_signal (sigHandler_benchmark);
13230 }
13231
13232 /**
13233 * User-defined GPU temp handling
13234 */
13235
13236 #ifdef HAVE_HWMON
13237 if (gpu_temp_disable == 1)
13238 {
13239 gpu_temp_abort = 0;
13240 gpu_temp_retain = 0;
13241 }
13242
13243 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13244 {
13245 if (gpu_temp_abort < gpu_temp_retain)
13246 {
13247 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13248
13249 return (-1);
13250 }
13251 }
13252
13253 data.gpu_temp_disable = gpu_temp_disable;
13254 data.gpu_temp_abort = gpu_temp_abort;
13255 data.gpu_temp_retain = gpu_temp_retain;
13256 #endif
13257
13258 /**
13259 * inform the user
13260 */
13261
13262 if (data.quiet == 0)
13263 {
13264 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13265
13266 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);
13267
13268 if (attack_mode == ATTACK_MODE_STRAIGHT)
13269 {
13270 log_info ("Rules: %u", kernel_rules_cnt);
13271 }
13272
13273 if (opti_type)
13274 {
13275 log_info ("Applicable Optimizers:");
13276
13277 for (uint i = 0; i < 32; i++)
13278 {
13279 const uint opti_bit = 1u << i;
13280
13281 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13282 }
13283 }
13284
13285 /**
13286 * Watchdog and Temperature balance
13287 */
13288
13289 #ifdef HAVE_HWMON
13290 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13291 {
13292 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13293 }
13294
13295 if (gpu_temp_abort == 0)
13296 {
13297 log_info ("Watchdog: Temperature abort trigger disabled");
13298 }
13299 else
13300 {
13301 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13302 }
13303
13304 if (gpu_temp_retain == 0)
13305 {
13306 log_info ("Watchdog: Temperature retain trigger disabled");
13307 }
13308 else
13309 {
13310 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13311 }
13312 #endif
13313 }
13314
13315 if (data.quiet == 0) log_info ("");
13316
13317 /**
13318 * HM devices: copy
13319 */
13320
13321 if (gpu_temp_disable == 0)
13322 {
13323 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13324 {
13325 hc_device_param_t *device_param = &data.devices_param[device_id];
13326
13327 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13328
13329 if (device_param->skipped) continue;
13330
13331 const uint platform_devices_id = device_param->platform_devices_id;
13332
13333 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13334 if (device_param->vendor_id == VENDOR_ID_NV)
13335 {
13336 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13337 }
13338 #endif
13339
13340 #ifdef HAVE_ADL
13341 if (device_param->vendor_id == VENDOR_ID_AMD)
13342 {
13343 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13344 }
13345 #endif
13346 }
13347 }
13348
13349 /*
13350 * Temporary fix:
13351 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13352 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13353 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13354 * Driver / ADL bug?
13355 */
13356
13357 #ifdef HAVE_ADL
13358 if (powertune_enable == 1)
13359 {
13360 hc_thread_mutex_lock (mux_adl);
13361
13362 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13363 {
13364 hc_device_param_t *device_param = &data.devices_param[device_id];
13365
13366 if (device_param->skipped) continue;
13367
13368 if (data.hm_device[device_id].od_version == 6)
13369 {
13370 // set powertune value only
13371
13372 int powertune_supported = 0;
13373
13374 int ADL_rc = 0;
13375
13376 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13377 {
13378 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13379
13380 return (-1);
13381 }
13382
13383 if (powertune_supported != 0)
13384 {
13385 // powertune set
13386 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13387
13388 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13389 {
13390 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13391
13392 return (-1);
13393 }
13394
13395 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13396 {
13397 log_error ("ERROR: Failed to set new ADL PowerControl values");
13398
13399 return (-1);
13400 }
13401 }
13402 }
13403 }
13404
13405 hc_thread_mutex_unlock (mux_adl);
13406 }
13407 #endif // HAVE_ADK
13408 #endif // HAVE_HWMON
13409
13410 #ifdef OSX
13411 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13412 {
13413 if (force == 0)
13414 {
13415 log_info ("");
13416 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13417 log_info ("You can use --force to override this but do not post error reports if you do so");
13418 log_info ("");
13419
13420 continue;
13421 }
13422 }
13423 #endif
13424
13425 #ifdef DEBUG
13426 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13427 #endif
13428
13429 uint kernel_power_all = 0;
13430
13431 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13432 {
13433 /**
13434 * host buffer
13435 */
13436
13437 hc_device_param_t *device_param = &data.devices_param[device_id];
13438
13439 if (device_param->skipped) continue;
13440
13441 /**
13442 * device properties
13443 */
13444
13445 const char *device_name_chksum = device_param->device_name_chksum;
13446 const u32 device_processors = device_param->device_processors;
13447 const u32 device_processor_cores = device_param->device_processor_cores;
13448
13449 /**
13450 * create context for each device
13451 */
13452
13453 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13454
13455 /**
13456 * create command-queue
13457 */
13458
13459 // not supported with NV
13460 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13461
13462 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13463
13464 /**
13465 * create input buffers on device : calculate size of fixed memory buffers
13466 */
13467
13468 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13469 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13470
13471 device_param->size_root_css = size_root_css;
13472 device_param->size_markov_css = size_markov_css;
13473
13474 uint size_results = KERNEL_THREADS * sizeof (uint);
13475
13476 device_param->size_results = size_results;
13477
13478 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13479 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13480
13481 uint size_plains = digests_cnt * sizeof (plain_t);
13482 uint size_salts = salts_cnt * sizeof (salt_t);
13483 uint size_esalts = salts_cnt * esalt_size;
13484
13485 device_param->size_plains = size_plains;
13486 device_param->size_digests = size_digests;
13487 device_param->size_shown = size_shown;
13488 device_param->size_salts = size_salts;
13489
13490 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13491 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13492 uint size_tm = 32 * sizeof (bs_word_t);
13493
13494 // scryptV stuff
13495
13496 u64 size_scryptV = 1;
13497
13498 if ((hash_mode == 8900) || (hash_mode == 9300))
13499 {
13500 uint tmto_start = 0;
13501 uint tmto_stop = 10;
13502
13503 if (scrypt_tmto)
13504 {
13505 tmto_start = scrypt_tmto;
13506 }
13507 else
13508 {
13509 // in case the user did not specify the tmto manually
13510 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13511 // but set the lower end only in case the user has a device with too less memory
13512
13513 if (hash_mode == 8900)
13514 {
13515 if (device_param->vendor_id == VENDOR_ID_AMD)
13516 {
13517 tmto_start = 1;
13518 }
13519 else if (device_param->vendor_id == VENDOR_ID_NV)
13520 {
13521 tmto_start = 3;
13522 }
13523 }
13524 else if (hash_mode == 9300)
13525 {
13526 if (device_param->vendor_id == VENDOR_ID_AMD)
13527 {
13528 tmto_start = 3;
13529 }
13530 else if (device_param->vendor_id == VENDOR_ID_NV)
13531 {
13532 tmto_start = 5;
13533 }
13534 }
13535 }
13536
13537 if (quiet == 0) log_info ("");
13538
13539 uint shader_per_mp = 1;
13540
13541 if (device_param->vendor_id == VENDOR_ID_AMD)
13542 {
13543 shader_per_mp = 8;
13544 }
13545 else if (device_param->vendor_id == VENDOR_ID_NV)
13546 {
13547 shader_per_mp = 32;
13548 }
13549
13550 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13551 {
13552 // TODO: in theory the following calculation needs to be done per salt, not global
13553 // we assume all hashes have the same scrypt settings
13554
13555 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13556
13557 size_scryptV /= 1 << tmto;
13558
13559 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13560
13561 if (size_scryptV > device_param->device_maxmem_alloc)
13562 {
13563 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13564
13565 continue;
13566 }
13567
13568 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13569 {
13570 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13571 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13572 }
13573
13574 break;
13575 }
13576
13577 if (data.salts_buf[0].scrypt_phy == 0)
13578 {
13579 log_error ("ERROR: can't allocate enough device memory");
13580
13581 return -1;
13582 }
13583
13584 if (quiet == 0) log_info ("");
13585 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13586 }
13587
13588 /**
13589 * create input buffers on device : calculate size of dynamic size memory buffers
13590 */
13591
13592 uint kernel_threads = KERNEL_THREADS;
13593
13594 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13595
13596 if (hash_mode == 3200) kernel_threads = 8;
13597 if (hash_mode == 9000) kernel_threads = 8;
13598
13599 /**
13600 * some algorithms need a fixed kernel-loops count
13601 */
13602
13603 u32 kernel_loops_min = 1;
13604 u32 kernel_loops_max = 1024;
13605
13606 if (hash_mode == 1500)
13607 {
13608 const u32 kernel_loops_fixed = 1024;
13609
13610 kernel_loops_min = kernel_loops_fixed;
13611 kernel_loops_max = kernel_loops_fixed;
13612 }
13613
13614 if (hash_mode == 3000)
13615 {
13616 const u32 kernel_loops_fixed = 1024;
13617
13618 kernel_loops_min = kernel_loops_fixed;
13619 kernel_loops_max = kernel_loops_fixed;
13620 }
13621
13622 if (hash_mode == 8900)
13623 {
13624 const u32 kernel_loops_fixed = 1;
13625
13626 kernel_loops_min = kernel_loops_fixed;
13627 kernel_loops_max = kernel_loops_fixed;
13628 }
13629
13630 if (hash_mode == 9300)
13631 {
13632 const u32 kernel_loops_fixed = 1;
13633
13634 kernel_loops_min = kernel_loops_fixed;
13635 kernel_loops_max = kernel_loops_fixed;
13636 }
13637
13638 if (hash_mode == 12500)
13639 {
13640 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13641
13642 kernel_loops_min = kernel_loops_fixed;
13643 kernel_loops_max = kernel_loops_fixed;
13644 }
13645
13646 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13647 {
13648 if (data.salts_buf[0].salt_iter < kernel_loops_max)
13649 {
13650 kernel_loops_max = data.salts_buf[0].salt_iter;
13651 }
13652 }
13653
13654 device_param->kernel_loops_min = kernel_loops_min;
13655 device_param->kernel_loops_max = kernel_loops_max;
13656
13657 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13658
13659 uint size_pws = 4;
13660 uint size_tmps = 4;
13661 uint size_hooks = 4;
13662
13663 uint kernel_accel_min = 1;
13664 uint kernel_accel_max = 1024;
13665
13666 /**
13667 * some algorithms need a special kernel-accel
13668 */
13669
13670 if (hash_mode == 8900)
13671 {
13672 kernel_accel_max = 64;
13673 }
13674
13675 if (hash_mode == 9300)
13676 {
13677 kernel_accel_max = 64;
13678 }
13679
13680 while (kernel_accel_max)
13681 {
13682 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13683
13684 // size_pws
13685
13686 size_pws = kernel_power_max * sizeof (pw_t);
13687
13688 // size_tmps
13689
13690 switch (hash_mode)
13691 {
13692 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13693 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13694 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13695 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13696 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13697 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13698 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13699 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13700 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13701 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13702 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13703 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13704 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13705 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13706 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13707 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13708 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13709 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13710 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13711 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13712 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13713 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13714 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13715 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13716 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13717 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13718 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13719 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13720 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13721 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13722 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13723 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13724 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13725 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13726 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13727 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13728 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13729 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13730 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13731 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13732 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13733 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13734 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13735 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13736 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13737 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13738 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13739 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13740 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13741 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13742 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13743 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13744 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13745 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13746 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13747 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13748 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13749 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13750 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13751 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13752 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13753 };
13754
13755 // size_hooks
13756
13757 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13758 {
13759 // none yet
13760 }
13761
13762 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13763 // if not, decrease amplifier and try again
13764
13765 int skip = 0;
13766
13767 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13768 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13769 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13770
13771 if (( bitmap_size
13772 + bitmap_size
13773 + bitmap_size
13774 + bitmap_size
13775 + bitmap_size
13776 + bitmap_size
13777 + bitmap_size
13778 + bitmap_size
13779 + size_bfs
13780 + size_combs
13781 + size_digests
13782 + size_esalts
13783 + size_hooks
13784 + size_markov_css
13785 + size_plains
13786 + size_pws
13787 + size_results
13788 + size_root_css
13789 + size_rules
13790 + size_rules_c
13791 + size_salts
13792 + size_scryptV
13793 + size_shown
13794 + size_tm
13795 + size_tmps) > device_param->device_global_mem) skip = 1;
13796
13797 if (skip == 1)
13798 {
13799 kernel_accel_max--;
13800
13801 continue;
13802 }
13803
13804 break;
13805 }
13806
13807 if (kernel_accel_max == 0)
13808 {
13809 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13810
13811 return -1;
13812 }
13813
13814 device_param->kernel_accel_min = kernel_accel_min;
13815 device_param->kernel_accel_max = kernel_accel_max;
13816
13817 if (kernel_accel_max < kernel_accel)
13818 {
13819 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13820
13821 device_param->kernel_accel = kernel_accel_max;
13822 }
13823
13824 const u32 kernel_accel = device_param->kernel_accel;
13825
13826 device_param->size_pws = size_pws;
13827 device_param->size_tmps = size_tmps;
13828 device_param->size_hooks = size_hooks;
13829
13830 // do not confuse kernel_accel_max with kernel_accel here
13831
13832 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13833
13834 device_param->kernel_threads = kernel_threads;
13835 device_param->kernel_power_user = kernel_power;
13836
13837 kernel_power_all += kernel_power;
13838
13839 /**
13840 * default building options
13841 */
13842
13843 char build_opts[1024] = { 0 };
13844
13845 // we don't have sm_* on vendors not NV but it doesn't matter
13846
13847 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);
13848
13849 /**
13850 * main kernel
13851 */
13852
13853 {
13854 /**
13855 * kernel source filename
13856 */
13857
13858 char source_file[256] = { 0 };
13859
13860 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13861
13862 struct stat sst;
13863
13864 if (stat (source_file, &sst) == -1)
13865 {
13866 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13867
13868 return -1;
13869 }
13870
13871 /**
13872 * kernel cached filename
13873 */
13874
13875 char cached_file[256] = { 0 };
13876
13877 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13878
13879 int cached = 1;
13880
13881 struct stat cst;
13882
13883 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13884 {
13885 cached = 0;
13886 }
13887
13888 /**
13889 * kernel compile or load
13890 */
13891
13892 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13893
13894 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13895
13896 if (force_jit_compilation == -1)
13897 {
13898 if (cached == 0)
13899 {
13900 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13901
13902 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13903
13904 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13905
13906 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13907
13908 if (rc != 0)
13909 {
13910 device_param->skipped = true;
13911 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13912 continue;
13913 }
13914
13915 size_t binary_size;
13916
13917 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13918
13919 u8 *binary = (u8 *) mymalloc (binary_size);
13920
13921 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13922
13923 writeProgramBin (cached_file, binary, binary_size);
13924
13925 local_free (binary);
13926 }
13927 else
13928 {
13929 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13930
13931 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13932
13933 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13934
13935 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13936 }
13937 }
13938 else
13939 {
13940 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13941
13942 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13943
13944 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13945
13946 char build_opts_update[1024] = { 0 };
13947
13948 if (force_jit_compilation == 1500)
13949 {
13950 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13951 }
13952 else if (force_jit_compilation == 8900)
13953 {
13954 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);
13955 }
13956
13957 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13958
13959 if (rc != 0)
13960 {
13961 device_param->skipped = true;
13962 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13963 }
13964 }
13965
13966 local_free (kernel_lengths);
13967 local_free (kernel_sources[0]);
13968 local_free (kernel_sources);
13969 }
13970
13971 /**
13972 * word generator kernel
13973 */
13974
13975 if (attack_mode != ATTACK_MODE_STRAIGHT)
13976 {
13977 /**
13978 * kernel mp source filename
13979 */
13980
13981 char source_file[256] = { 0 };
13982
13983 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13984
13985 struct stat sst;
13986
13987 if (stat (source_file, &sst) == -1)
13988 {
13989 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13990
13991 return -1;
13992 }
13993
13994 /**
13995 * kernel mp cached filename
13996 */
13997
13998 char cached_file[256] = { 0 };
13999
14000 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14001
14002 int cached = 1;
14003
14004 struct stat cst;
14005
14006 if (stat (cached_file, &cst) == -1)
14007 {
14008 cached = 0;
14009 }
14010
14011 /**
14012 * kernel compile or load
14013 */
14014
14015 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14016
14017 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14018
14019 if (cached == 0)
14020 {
14021 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14022
14023 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14024
14025 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14026
14027 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14028
14029 if (rc != 0)
14030 {
14031 device_param->skipped = true;
14032 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14033 continue;
14034 }
14035
14036 size_t binary_size;
14037
14038 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14039
14040 u8 *binary = (u8 *) mymalloc (binary_size);
14041
14042 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14043
14044 writeProgramBin (cached_file, binary, binary_size);
14045
14046 local_free (binary);
14047 }
14048 else
14049 {
14050 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14051
14052 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14053
14054 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14055
14056 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14057 }
14058
14059 local_free (kernel_lengths);
14060 local_free (kernel_sources[0]);
14061 local_free (kernel_sources);
14062 }
14063
14064 /**
14065 * amplifier kernel
14066 */
14067
14068 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14069 {
14070
14071 }
14072 else
14073 {
14074 /**
14075 * kernel amp source filename
14076 */
14077
14078 char source_file[256] = { 0 };
14079
14080 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14081
14082 struct stat sst;
14083
14084 if (stat (source_file, &sst) == -1)
14085 {
14086 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14087
14088 return -1;
14089 }
14090
14091 /**
14092 * kernel amp cached filename
14093 */
14094
14095 char cached_file[256] = { 0 };
14096
14097 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14098
14099 int cached = 1;
14100
14101 struct stat cst;
14102
14103 if (stat (cached_file, &cst) == -1)
14104 {
14105 cached = 0;
14106 }
14107
14108 /**
14109 * kernel compile or load
14110 */
14111
14112 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14113
14114 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14115
14116 if (cached == 0)
14117 {
14118 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14119
14120 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14121
14122 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14123
14124 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14125
14126 if (rc != 0)
14127 {
14128 device_param->skipped = true;
14129 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14130 continue;
14131 }
14132
14133 size_t binary_size;
14134
14135 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14136
14137 u8 *binary = (u8 *) mymalloc (binary_size);
14138
14139 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14140
14141 writeProgramBin (cached_file, binary, binary_size);
14142
14143 local_free (binary);
14144 }
14145 else
14146 {
14147 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14148
14149 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14150
14151 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14152
14153 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14154 }
14155
14156 local_free (kernel_lengths);
14157 local_free (kernel_sources[0]);
14158 local_free (kernel_sources);
14159 }
14160
14161 // some algorithm collide too fast, make that impossible
14162
14163 if (benchmark == 1)
14164 {
14165 ((uint *) digests_buf)[0] = -1;
14166 ((uint *) digests_buf)[1] = -1;
14167 ((uint *) digests_buf)[2] = -1;
14168 ((uint *) digests_buf)[3] = -1;
14169 }
14170
14171 /**
14172 * global buffers
14173 */
14174
14175 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14176 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14177 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14178 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14179 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14180 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14181 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14182 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14183 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14184 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14185 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14186 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14187 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14188 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14189 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14190 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14191 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14192 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14193
14194 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);
14195 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);
14196 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);
14197 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);
14198 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);
14199 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);
14200 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);
14201 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);
14202 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14203 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14204 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14205
14206 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14207 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14208 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14209 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14210 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14211 run_kernel_bzero (device_param, device_param->d_result, size_results);
14212
14213 /**
14214 * special buffers
14215 */
14216
14217 if (attack_kern == ATTACK_KERN_STRAIGHT)
14218 {
14219 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14220 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14221
14222 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14223
14224 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14225 }
14226 else if (attack_kern == ATTACK_KERN_COMBI)
14227 {
14228 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14229 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14230 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14231 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14232
14233 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14234 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14235 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14236 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14237 }
14238 else if (attack_kern == ATTACK_KERN_BF)
14239 {
14240 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14241 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14242 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14243 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14244 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14245
14246 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14247 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14248 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14249 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14250 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14251 }
14252
14253 if (size_esalts)
14254 {
14255 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14256
14257 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14258 }
14259
14260 /**
14261 * main host data
14262 */
14263
14264 uint *result = (uint *) mymalloc (size_results);
14265
14266 device_param->result = result;
14267
14268 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14269
14270 device_param->pws_buf = pws_buf;
14271
14272 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14273
14274 for (int i = 0; i < 64; i++)
14275 {
14276 pw_caches[i].pw_buf.pw_len = i;
14277 pw_caches[i].cnt = 0;
14278 }
14279
14280 device_param->pw_caches = pw_caches;
14281
14282 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14283
14284 device_param->combs_buf = combs_buf;
14285
14286 void *hooks_buf = mymalloc (size_hooks);
14287
14288 device_param->hooks_buf = hooks_buf;
14289
14290 device_param->pw_transpose = pw_transpose_to_hi1;
14291 device_param->pw_add = pw_add_to_hc1;
14292
14293 /**
14294 * kernel args
14295 */
14296
14297 device_param->kernel_params_buf32[21] = bitmap_mask;
14298 device_param->kernel_params_buf32[22] = bitmap_shift1;
14299 device_param->kernel_params_buf32[23] = bitmap_shift2;
14300 device_param->kernel_params_buf32[24] = 0; // salt_pos
14301 device_param->kernel_params_buf32[25] = 0; // loop_pos
14302 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14303 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14304 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14305 device_param->kernel_params_buf32[29] = 0; // digests_offset
14306 device_param->kernel_params_buf32[30] = 0; // combs_mode
14307 device_param->kernel_params_buf32[31] = 0; // gid_max
14308
14309 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14310 ? &device_param->d_pws_buf
14311 : &device_param->d_pws_amp_buf;
14312 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14313 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14314 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14315 device_param->kernel_params[ 4] = &device_param->d_tmps;
14316 device_param->kernel_params[ 5] = &device_param->d_hooks;
14317 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14318 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14319 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14320 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14321 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14322 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14323 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14324 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14325 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14326 device_param->kernel_params[15] = &device_param->d_digests_buf;
14327 device_param->kernel_params[16] = &device_param->d_digests_shown;
14328 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14329 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14330 device_param->kernel_params[19] = &device_param->d_result;
14331 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14332 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14333 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14334 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14335 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14336 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14337 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14338 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14339 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14340 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14341 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14342 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14343
14344 device_param->kernel_params_mp_buf64[3] = 0;
14345 device_param->kernel_params_mp_buf32[4] = 0;
14346 device_param->kernel_params_mp_buf32[5] = 0;
14347 device_param->kernel_params_mp_buf32[6] = 0;
14348 device_param->kernel_params_mp_buf32[7] = 0;
14349 device_param->kernel_params_mp_buf32[8] = 0;
14350
14351 device_param->kernel_params_mp[0] = NULL;
14352 device_param->kernel_params_mp[1] = NULL;
14353 device_param->kernel_params_mp[2] = NULL;
14354 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14355 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14356 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14357 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14358 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14359 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14360
14361 device_param->kernel_params_mp_l_buf64[3] = 0;
14362 device_param->kernel_params_mp_l_buf32[4] = 0;
14363 device_param->kernel_params_mp_l_buf32[5] = 0;
14364 device_param->kernel_params_mp_l_buf32[6] = 0;
14365 device_param->kernel_params_mp_l_buf32[7] = 0;
14366 device_param->kernel_params_mp_l_buf32[8] = 0;
14367 device_param->kernel_params_mp_l_buf32[9] = 0;
14368
14369 device_param->kernel_params_mp_l[0] = NULL;
14370 device_param->kernel_params_mp_l[1] = NULL;
14371 device_param->kernel_params_mp_l[2] = NULL;
14372 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14373 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14374 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14375 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14376 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14377 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14378 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14379
14380 device_param->kernel_params_mp_r_buf64[3] = 0;
14381 device_param->kernel_params_mp_r_buf32[4] = 0;
14382 device_param->kernel_params_mp_r_buf32[5] = 0;
14383 device_param->kernel_params_mp_r_buf32[6] = 0;
14384 device_param->kernel_params_mp_r_buf32[7] = 0;
14385 device_param->kernel_params_mp_r_buf32[8] = 0;
14386
14387 device_param->kernel_params_mp_r[0] = NULL;
14388 device_param->kernel_params_mp_r[1] = NULL;
14389 device_param->kernel_params_mp_r[2] = NULL;
14390 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14391 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14392 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14393 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14394 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14395 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14396
14397 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14398 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14399
14400 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14401 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14402 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14403 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14404 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14405 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14406 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14407
14408 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14409
14410 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14411 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14412
14413 /**
14414 * kernel name
14415 */
14416
14417 char kernel_name[64] = { 0 };
14418
14419 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14420 {
14421 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14422 {
14423 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14424
14425 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14426
14427 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14428
14429 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14430
14431 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14432
14433 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14434 }
14435 else
14436 {
14437 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14438
14439 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14440
14441 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14442
14443 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14444
14445 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14446
14447 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14448 }
14449
14450 if (data.attack_mode == ATTACK_MODE_BF)
14451 {
14452 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14453 {
14454 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14455
14456 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14457
14458 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14459
14460 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14461 }
14462 }
14463 }
14464 else
14465 {
14466 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14467
14468 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14469
14470 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14471
14472 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14473
14474 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14475
14476 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14477
14478 if (opts_type & OPTS_TYPE_HOOK12)
14479 {
14480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14481
14482 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14483 }
14484
14485 if (opts_type & OPTS_TYPE_HOOK23)
14486 {
14487 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14488
14489 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14490 }
14491 }
14492
14493 for (uint i = 0; i <= 20; i++)
14494 {
14495 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14496 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14497 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14498
14499 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14500 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14501 }
14502
14503 for (uint i = 21; i <= 31; i++)
14504 {
14505 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14506 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14507 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14508
14509 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14510 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14511 }
14512
14513 if (attack_mode == ATTACK_MODE_BF)
14514 {
14515 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14516 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14517
14518 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14519 {
14520 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14521
14522 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14523 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14524 }
14525 }
14526 else if (attack_mode == ATTACK_MODE_HYBRID1)
14527 {
14528 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14529 }
14530 else if (attack_mode == ATTACK_MODE_HYBRID2)
14531 {
14532 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14533 }
14534
14535 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14536 {
14537 // nothing to do
14538 }
14539 else
14540 {
14541 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14542 }
14543
14544 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14545 {
14546 // nothing to do
14547 }
14548 else
14549 {
14550 for (uint i = 0; i < 5; i++)
14551 {
14552 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14553 }
14554
14555 for (uint i = 5; i < 7; i++)
14556 {
14557 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14558 }
14559 }
14560
14561 /**
14562 * Store initial fanspeed if gpu_temp_retain is enabled
14563 */
14564
14565 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14566 int gpu_temp_retain_set = 0;
14567
14568 if (gpu_temp_disable == 0)
14569 {
14570 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14571 {
14572 hc_thread_mutex_lock (mux_adl);
14573
14574 if (data.hm_device[device_id].fan_supported == 1)
14575 {
14576 if (gpu_temp_retain_chgd == 0)
14577 {
14578 uint cur_temp = 0;
14579 uint default_temp = 0;
14580
14581 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);
14582
14583 if (ADL_rc == ADL_OK)
14584 {
14585 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14586
14587 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14588
14589 // special case with multi gpu setups: always use minimum retain
14590
14591 if (gpu_temp_retain_set == 0)
14592 {
14593 gpu_temp_retain = gpu_temp_retain_target;
14594 gpu_temp_retain_set = 1;
14595 }
14596 else
14597 {
14598 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14599 }
14600
14601 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14602 }
14603 }
14604
14605 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14606
14607 temp_retain_fanspeed_value[device_id] = fan_speed;
14608
14609 if (fan_speed == -1)
14610 {
14611 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14612
14613 temp_retain_fanspeed_value[device_id] = 0;
14614 }
14615 }
14616
14617 hc_thread_mutex_unlock (mux_adl);
14618 }
14619 }
14620
14621 /**
14622 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14623 */
14624
14625 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14626 {
14627 hc_thread_mutex_lock (mux_adl);
14628
14629 if (data.hm_device[device_id].od_version == 6)
14630 {
14631 int ADL_rc;
14632
14633 // check powertune capabilities first, if not available then skip device
14634
14635 int powertune_supported = 0;
14636
14637 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14638 {
14639 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14640
14641 return (-1);
14642 }
14643
14644 if (powertune_supported != 0)
14645 {
14646 // powercontrol settings
14647
14648 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14649
14650 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14651 {
14652 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14653 }
14654
14655 if (ADL_rc != ADL_OK)
14656 {
14657 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14658
14659 return (-1);
14660 }
14661
14662 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14663 {
14664 log_error ("ERROR: Failed to set new ADL PowerControl values");
14665
14666 return (-1);
14667 }
14668
14669 // clocks
14670
14671 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14672
14673 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14674
14675 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)
14676 {
14677 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14678
14679 return (-1);
14680 }
14681
14682 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14683
14684 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14685
14686 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14687 {
14688 log_error ("ERROR: Failed to get ADL device capabilities");
14689
14690 return (-1);
14691 }
14692
14693 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14694 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14695
14696 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14697 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14698
14699 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14700 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14701
14702 // warning if profile has too low max values
14703
14704 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14705 {
14706 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14707 }
14708
14709 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14710 {
14711 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14712 }
14713
14714 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14715
14716 performance_state->iNumberOfPerformanceLevels = 2;
14717
14718 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14719 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14720 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14721 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14722
14723 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)
14724 {
14725 log_info ("ERROR: Failed to set ADL performance state");
14726
14727 return (-1);
14728 }
14729
14730 local_free (performance_state);
14731 }
14732 }
14733
14734 hc_thread_mutex_unlock (mux_adl);
14735 }
14736 #endif // HAVE_HWMON && HAVE_ADL
14737 }
14738
14739 data.kernel_power_all = kernel_power_all;
14740
14741 if (data.quiet == 0) log_info ("");
14742
14743 /**
14744 * Inform user which algorithm is checked and at which workload setting
14745 */
14746
14747 if (benchmark == 1)
14748 {
14749 quiet = 0;
14750
14751 data.quiet = quiet;
14752
14753 char *hash_type = strhashtype (data.hash_mode); // not a bug
14754
14755 log_info ("Hashtype: %s", hash_type);
14756 log_info ("");
14757 }
14758
14759 /**
14760 * keep track of the progress
14761 */
14762
14763 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14764 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14765 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14766
14767 /**
14768 * open filehandles
14769 */
14770
14771 #if _WIN
14772 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14773 {
14774 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14775
14776 return (-1);
14777 }
14778
14779 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14780 {
14781 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14782
14783 return (-1);
14784 }
14785
14786 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14787 {
14788 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14789
14790 return (-1);
14791 }
14792 #endif
14793
14794 /**
14795 * dictionary pad
14796 */
14797
14798 segment_size *= (1024 * 1024);
14799
14800 data.segment_size = segment_size;
14801
14802 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14803
14804 wl_data->buf = (char *) mymalloc (segment_size);
14805 wl_data->avail = segment_size;
14806 wl_data->incr = segment_size;
14807 wl_data->cnt = 0;
14808 wl_data->pos = 0;
14809
14810 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14811
14812 data.wordlist_mode = wordlist_mode;
14813
14814 cs_t *css_buf = NULL;
14815 uint css_cnt = 0;
14816 uint dictcnt = 0;
14817 uint maskcnt = 1;
14818 char **masks = NULL;
14819 char **dictfiles = NULL;
14820
14821 uint mask_from_file = 0;
14822
14823 if (attack_mode == ATTACK_MODE_STRAIGHT)
14824 {
14825 if (wordlist_mode == WL_MODE_FILE)
14826 {
14827 int wls_left = myargc - (optind + 1);
14828
14829 for (int i = 0; i < wls_left; i++)
14830 {
14831 char *l0_filename = myargv[optind + 1 + i];
14832
14833 struct stat l0_stat;
14834
14835 if (stat (l0_filename, &l0_stat) == -1)
14836 {
14837 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14838
14839 return (-1);
14840 }
14841
14842 uint is_dir = S_ISDIR (l0_stat.st_mode);
14843
14844 if (is_dir == 0)
14845 {
14846 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14847
14848 dictcnt++;
14849
14850 dictfiles[dictcnt - 1] = l0_filename;
14851 }
14852 else
14853 {
14854 // do not allow --keyspace w/ a directory
14855
14856 if (keyspace == 1)
14857 {
14858 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14859
14860 return (-1);
14861 }
14862
14863 char **dictionary_files = NULL;
14864
14865 dictionary_files = scan_directory (l0_filename);
14866
14867 if (dictionary_files != NULL)
14868 {
14869 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14870
14871 for (int d = 0; dictionary_files[d] != NULL; d++)
14872 {
14873 char *l1_filename = dictionary_files[d];
14874
14875 struct stat l1_stat;
14876
14877 if (stat (l1_filename, &l1_stat) == -1)
14878 {
14879 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14880
14881 return (-1);
14882 }
14883
14884 if (S_ISREG (l1_stat.st_mode))
14885 {
14886 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14887
14888 dictcnt++;
14889
14890 dictfiles[dictcnt - 1] = strdup (l1_filename);
14891 }
14892 }
14893 }
14894
14895 local_free (dictionary_files);
14896 }
14897 }
14898
14899 if (dictcnt < 1)
14900 {
14901 log_error ("ERROR: No usable dictionary file found.");
14902
14903 return (-1);
14904 }
14905 }
14906 else if (wordlist_mode == WL_MODE_STDIN)
14907 {
14908 dictcnt = 1;
14909 }
14910 }
14911 else if (attack_mode == ATTACK_MODE_COMBI)
14912 {
14913 // display
14914
14915 char *dictfile1 = myargv[optind + 1 + 0];
14916 char *dictfile2 = myargv[optind + 1 + 1];
14917
14918 // find the bigger dictionary and use as base
14919
14920 FILE *fp1 = NULL;
14921 FILE *fp2 = NULL;
14922
14923 struct stat tmp_stat;
14924
14925 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14926 {
14927 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14928
14929 return (-1);
14930 }
14931
14932 if (stat (dictfile1, &tmp_stat) == -1)
14933 {
14934 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14935
14936 fclose (fp1);
14937
14938 return (-1);
14939 }
14940
14941 if (S_ISDIR (tmp_stat.st_mode))
14942 {
14943 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14944
14945 fclose (fp1);
14946
14947 return (-1);
14948 }
14949
14950 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14951 {
14952 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14953
14954 fclose (fp1);
14955
14956 return (-1);
14957 }
14958
14959 if (stat (dictfile2, &tmp_stat) == -1)
14960 {
14961 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14962
14963 fclose (fp1);
14964 fclose (fp2);
14965
14966 return (-1);
14967 }
14968
14969 if (S_ISDIR (tmp_stat.st_mode))
14970 {
14971 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14972
14973 fclose (fp1);
14974 fclose (fp2);
14975
14976 return (-1);
14977 }
14978
14979 data.combs_cnt = 1;
14980
14981 data.quiet = 1;
14982
14983 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14984
14985 data.quiet = quiet;
14986
14987 if (words1_cnt == 0)
14988 {
14989 log_error ("ERROR: %s: empty file", dictfile1);
14990
14991 fclose (fp1);
14992 fclose (fp2);
14993
14994 return (-1);
14995 }
14996
14997 data.combs_cnt = 1;
14998
14999 data.quiet = 1;
15000
15001 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15002
15003 data.quiet = quiet;
15004
15005 if (words2_cnt == 0)
15006 {
15007 log_error ("ERROR: %s: empty file", dictfile2);
15008
15009 fclose (fp1);
15010 fclose (fp2);
15011
15012 return (-1);
15013 }
15014
15015 fclose (fp1);
15016 fclose (fp2);
15017
15018 data.dictfile = dictfile1;
15019 data.dictfile2 = dictfile2;
15020
15021 if (words1_cnt >= words2_cnt)
15022 {
15023 data.combs_cnt = words2_cnt;
15024 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15025
15026 dictfiles = &data.dictfile;
15027
15028 dictcnt = 1;
15029 }
15030 else
15031 {
15032 data.combs_cnt = words1_cnt;
15033 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15034
15035 dictfiles = &data.dictfile2;
15036
15037 dictcnt = 1;
15038
15039 // we also have to switch wordlist related rules!
15040
15041 char *tmpc = data.rule_buf_l;
15042
15043 data.rule_buf_l = data.rule_buf_r;
15044 data.rule_buf_r = tmpc;
15045
15046 int tmpi = data.rule_len_l;
15047
15048 data.rule_len_l = data.rule_len_r;
15049 data.rule_len_r = tmpi;
15050 }
15051 }
15052 else if (attack_mode == ATTACK_MODE_BF)
15053 {
15054 char *mask = NULL;
15055
15056 maskcnt = 0;
15057
15058 if (benchmark == 0)
15059 {
15060 mask = myargv[optind + 1];
15061
15062 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15063
15064 if ((optind + 2) <= myargc)
15065 {
15066 struct stat file_stat;
15067
15068 if (stat (mask, &file_stat) == -1)
15069 {
15070 maskcnt = 1;
15071
15072 masks[maskcnt - 1] = mystrdup (mask);
15073 }
15074 else
15075 {
15076 int wls_left = myargc - (optind + 1);
15077
15078 uint masks_avail = INCR_MASKS;
15079
15080 for (int i = 0; i < wls_left; i++)
15081 {
15082 if (i != 0)
15083 {
15084 mask = myargv[optind + 1 + i];
15085
15086 if (stat (mask, &file_stat) == -1)
15087 {
15088 log_error ("ERROR: %s: %s", mask, strerror (errno));
15089
15090 return (-1);
15091 }
15092 }
15093
15094 uint is_file = S_ISREG (file_stat.st_mode);
15095
15096 if (is_file == 1)
15097 {
15098 FILE *mask_fp;
15099
15100 if ((mask_fp = fopen (mask, "r")) == NULL)
15101 {
15102 log_error ("ERROR: %s: %s", mask, strerror (errno));
15103
15104 return (-1);
15105 }
15106
15107 char line_buf[BUFSIZ] = { 0 };
15108
15109 while (!feof (mask_fp))
15110 {
15111 memset (line_buf, 0, BUFSIZ);
15112
15113 int line_len = fgetl (mask_fp, line_buf);
15114
15115 if (line_len == 0) continue;
15116
15117 if (line_buf[0] == '#') continue;
15118
15119 if (masks_avail == maskcnt)
15120 {
15121 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15122
15123 masks_avail += INCR_MASKS;
15124 }
15125
15126 masks[maskcnt] = mystrdup (line_buf);
15127
15128 maskcnt++;
15129 }
15130
15131 fclose (mask_fp);
15132 }
15133 else
15134 {
15135 log_error ("ERROR: %s: unsupported file-type", mask);
15136
15137 return (-1);
15138 }
15139 }
15140
15141 mask_from_file = 1;
15142 }
15143 }
15144 else
15145 {
15146 custom_charset_1 = (char *) "?l?d?u";
15147 custom_charset_2 = (char *) "?l?d";
15148 custom_charset_3 = (char *) "?l?d*!$@_";
15149
15150 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15151 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15152 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15153
15154 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15155
15156 wordlist_mode = WL_MODE_MASK;
15157
15158 data.wordlist_mode = wordlist_mode;
15159
15160 increment = 1;
15161
15162 maskcnt = 1;
15163 }
15164 }
15165 else
15166 {
15167 /**
15168 * generate full masks and charsets
15169 */
15170
15171 masks = (char **) mymalloc (sizeof (char *));
15172
15173 switch (hash_mode)
15174 {
15175 case 1731: pw_min = 5;
15176 pw_max = 5;
15177 mask = mystrdup ("?b?b?b?b?b");
15178 break;
15179 case 12500: pw_min = 5;
15180 pw_max = 5;
15181 mask = mystrdup ("?b?b?b?b?b");
15182 break;
15183 default: pw_min = 7;
15184 pw_max = 7;
15185 mask = mystrdup ("?b?b?b?b?b?b?b");
15186 break;
15187 }
15188
15189 maskcnt = 1;
15190
15191 masks[maskcnt - 1] = mystrdup (mask);
15192
15193 wordlist_mode = WL_MODE_MASK;
15194
15195 data.wordlist_mode = wordlist_mode;
15196
15197 increment = 1;
15198 }
15199
15200 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15201
15202 if (increment)
15203 {
15204 if (increment_min > pw_min) pw_min = increment_min;
15205
15206 if (increment_max < pw_max) pw_max = increment_max;
15207 }
15208 }
15209 else if (attack_mode == ATTACK_MODE_HYBRID1)
15210 {
15211 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15212
15213 // display
15214
15215 char *mask = myargv[myargc - 1];
15216
15217 maskcnt = 0;
15218
15219 masks = (char **) mymalloc (1 * sizeof (char *));
15220
15221 // mod
15222
15223 struct stat file_stat;
15224
15225 if (stat (mask, &file_stat) == -1)
15226 {
15227 maskcnt = 1;
15228
15229 masks[maskcnt - 1] = mystrdup (mask);
15230 }
15231 else
15232 {
15233 uint is_file = S_ISREG (file_stat.st_mode);
15234
15235 if (is_file == 1)
15236 {
15237 FILE *mask_fp;
15238
15239 if ((mask_fp = fopen (mask, "r")) == NULL)
15240 {
15241 log_error ("ERROR: %s: %s", mask, strerror (errno));
15242
15243 return (-1);
15244 }
15245
15246 char line_buf[BUFSIZ] = { 0 };
15247
15248 uint masks_avail = 1;
15249
15250 while (!feof (mask_fp))
15251 {
15252 memset (line_buf, 0, BUFSIZ);
15253
15254 int line_len = fgetl (mask_fp, line_buf);
15255
15256 if (line_len == 0) continue;
15257
15258 if (line_buf[0] == '#') continue;
15259
15260 if (masks_avail == maskcnt)
15261 {
15262 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15263
15264 masks_avail += INCR_MASKS;
15265 }
15266
15267 masks[maskcnt] = mystrdup (line_buf);
15268
15269 maskcnt++;
15270 }
15271
15272 fclose (mask_fp);
15273
15274 mask_from_file = 1;
15275 }
15276 else
15277 {
15278 maskcnt = 1;
15279
15280 masks[maskcnt - 1] = mystrdup (mask);
15281 }
15282 }
15283
15284 // base
15285
15286 int wls_left = myargc - (optind + 2);
15287
15288 for (int i = 0; i < wls_left; i++)
15289 {
15290 char *filename = myargv[optind + 1 + i];
15291
15292 struct stat file_stat;
15293
15294 if (stat (filename, &file_stat) == -1)
15295 {
15296 log_error ("ERROR: %s: %s", filename, strerror (errno));
15297
15298 return (-1);
15299 }
15300
15301 uint is_dir = S_ISDIR (file_stat.st_mode);
15302
15303 if (is_dir == 0)
15304 {
15305 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15306
15307 dictcnt++;
15308
15309 dictfiles[dictcnt - 1] = filename;
15310 }
15311 else
15312 {
15313 // do not allow --keyspace w/ a directory
15314
15315 if (keyspace == 1)
15316 {
15317 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15318
15319 return (-1);
15320 }
15321
15322 char **dictionary_files = NULL;
15323
15324 dictionary_files = scan_directory (filename);
15325
15326 if (dictionary_files != NULL)
15327 {
15328 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15329
15330 for (int d = 0; dictionary_files[d] != NULL; d++)
15331 {
15332 char *l1_filename = dictionary_files[d];
15333
15334 struct stat l1_stat;
15335
15336 if (stat (l1_filename, &l1_stat) == -1)
15337 {
15338 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15339
15340 return (-1);
15341 }
15342
15343 if (S_ISREG (l1_stat.st_mode))
15344 {
15345 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15346
15347 dictcnt++;
15348
15349 dictfiles[dictcnt - 1] = strdup (l1_filename);
15350 }
15351 }
15352 }
15353
15354 local_free (dictionary_files);
15355 }
15356 }
15357
15358 if (dictcnt < 1)
15359 {
15360 log_error ("ERROR: No usable dictionary file found.");
15361
15362 return (-1);
15363 }
15364
15365 if (increment)
15366 {
15367 maskcnt = 0;
15368
15369 uint mask_min = increment_min; // we can't reject smaller masks here
15370 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15371
15372 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15373 {
15374 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15375
15376 if (cur_mask == NULL) break;
15377
15378 masks[maskcnt] = cur_mask;
15379
15380 maskcnt++;
15381
15382 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15383 }
15384 }
15385 }
15386 else if (attack_mode == ATTACK_MODE_HYBRID2)
15387 {
15388 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15389
15390 // display
15391
15392 char *mask = myargv[optind + 1 + 0];
15393
15394 maskcnt = 0;
15395
15396 masks = (char **) mymalloc (1 * sizeof (char *));
15397
15398 // mod
15399
15400 struct stat file_stat;
15401
15402 if (stat (mask, &file_stat) == -1)
15403 {
15404 maskcnt = 1;
15405
15406 masks[maskcnt - 1] = mystrdup (mask);
15407 }
15408 else
15409 {
15410 uint is_file = S_ISREG (file_stat.st_mode);
15411
15412 if (is_file == 1)
15413 {
15414 FILE *mask_fp;
15415
15416 if ((mask_fp = fopen (mask, "r")) == NULL)
15417 {
15418 log_error ("ERROR: %s: %s", mask, strerror (errno));
15419
15420 return (-1);
15421 }
15422
15423 char line_buf[BUFSIZ] = { 0 };
15424
15425 uint masks_avail = 1;
15426
15427 while (!feof (mask_fp))
15428 {
15429 memset (line_buf, 0, BUFSIZ);
15430
15431 int line_len = fgetl (mask_fp, line_buf);
15432
15433 if (line_len == 0) continue;
15434
15435 if (line_buf[0] == '#') continue;
15436
15437 if (masks_avail == maskcnt)
15438 {
15439 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15440
15441 masks_avail += INCR_MASKS;
15442 }
15443
15444 masks[maskcnt] = mystrdup (line_buf);
15445
15446 maskcnt++;
15447 }
15448
15449 fclose (mask_fp);
15450
15451 mask_from_file = 1;
15452 }
15453 else
15454 {
15455 maskcnt = 1;
15456
15457 masks[maskcnt - 1] = mystrdup (mask);
15458 }
15459 }
15460
15461 // base
15462
15463 int wls_left = myargc - (optind + 2);
15464
15465 for (int i = 0; i < wls_left; i++)
15466 {
15467 char *filename = myargv[optind + 2 + i];
15468
15469 struct stat file_stat;
15470
15471 if (stat (filename, &file_stat) == -1)
15472 {
15473 log_error ("ERROR: %s: %s", filename, strerror (errno));
15474
15475 return (-1);
15476 }
15477
15478 uint is_dir = S_ISDIR (file_stat.st_mode);
15479
15480 if (is_dir == 0)
15481 {
15482 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15483
15484 dictcnt++;
15485
15486 dictfiles[dictcnt - 1] = filename;
15487 }
15488 else
15489 {
15490 // do not allow --keyspace w/ a directory
15491
15492 if (keyspace == 1)
15493 {
15494 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15495
15496 return (-1);
15497 }
15498
15499 char **dictionary_files = NULL;
15500
15501 dictionary_files = scan_directory (filename);
15502
15503 if (dictionary_files != NULL)
15504 {
15505 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15506
15507 for (int d = 0; dictionary_files[d] != NULL; d++)
15508 {
15509 char *l1_filename = dictionary_files[d];
15510
15511 struct stat l1_stat;
15512
15513 if (stat (l1_filename, &l1_stat) == -1)
15514 {
15515 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15516
15517 return (-1);
15518 }
15519
15520 if (S_ISREG (l1_stat.st_mode))
15521 {
15522 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15523
15524 dictcnt++;
15525
15526 dictfiles[dictcnt - 1] = strdup (l1_filename);
15527 }
15528 }
15529 }
15530
15531 local_free (dictionary_files);
15532 }
15533 }
15534
15535 if (dictcnt < 1)
15536 {
15537 log_error ("ERROR: No usable dictionary file found.");
15538
15539 return (-1);
15540 }
15541
15542 if (increment)
15543 {
15544 maskcnt = 0;
15545
15546 uint mask_min = increment_min; // we can't reject smaller masks here
15547 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15548
15549 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15550 {
15551 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15552
15553 if (cur_mask == NULL) break;
15554
15555 masks[maskcnt] = cur_mask;
15556
15557 maskcnt++;
15558
15559 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15560 }
15561 }
15562 }
15563
15564 data.pw_min = pw_min;
15565 data.pw_max = pw_max;
15566
15567 /**
15568 * weak hash check
15569 */
15570
15571 if (weak_hash_threshold >= salts_cnt)
15572 {
15573 hc_device_param_t *device_param = NULL;
15574
15575 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15576 {
15577 device_param = &data.devices_param[device_id];
15578
15579 if (device_param->skipped) continue;
15580
15581 break;
15582 }
15583
15584 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15585
15586 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15587 {
15588 weak_hash_check (device_param, salt_pos);
15589 }
15590 }
15591
15592 // Display hack, guarantee that there is at least one \r before real start
15593
15594 if (data.quiet == 0) log_info_nn ("");
15595
15596 /**
15597 * status and monitor threads
15598 */
15599
15600 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15601
15602 hc_thread_t i_thread = 0;
15603
15604 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15605 {
15606 hc_thread_create (i_thread, thread_keypress, &benchmark);
15607 }
15608
15609 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15610
15611 uint ni_threads_cnt = 0;
15612
15613 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15614
15615 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15616
15617 ni_threads_cnt++;
15618
15619 /**
15620 * Outfile remove
15621 */
15622
15623 if (keyspace == 0)
15624 {
15625 if (outfile_check_timer != 0)
15626 {
15627 if (data.outfile_check_directory != NULL)
15628 {
15629 if ((hash_mode != 5200) &&
15630 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15631 (hash_mode != 9000))
15632 {
15633 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15634
15635 ni_threads_cnt++;
15636 }
15637 else
15638 {
15639 outfile_check_timer = 0;
15640 }
15641 }
15642 else
15643 {
15644 outfile_check_timer = 0;
15645 }
15646 }
15647 }
15648
15649 /**
15650 * Inform the user if we got some hashes remove because of the pot file remove feature
15651 */
15652
15653 if (data.quiet == 0)
15654 {
15655 if (potfile_remove_cracks > 0)
15656 {
15657 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15658 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15659 }
15660 }
15661
15662 data.outfile_check_timer = outfile_check_timer;
15663
15664 /**
15665 * main loop
15666 */
15667
15668 char **induction_dictionaries = NULL;
15669
15670 int induction_dictionaries_cnt = 0;
15671
15672 hcstat_table_t *root_table_buf = NULL;
15673 hcstat_table_t *markov_table_buf = NULL;
15674
15675 uint initial_restore_done = 0;
15676
15677 data.maskcnt = maskcnt;
15678
15679 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15680 {
15681 if (data.devices_status == STATUS_CRACKED) break;
15682
15683 data.devices_status = STATUS_INIT;
15684
15685 if (maskpos > rd->maskpos)
15686 {
15687 rd->dictpos = 0;
15688 }
15689
15690 rd->maskpos = maskpos;
15691 data.maskpos = maskpos;
15692
15693 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15694 {
15695 char *mask = masks[maskpos];
15696
15697 if (mask_from_file == 1)
15698 {
15699 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15700
15701 char *str_ptr;
15702 uint str_pos;
15703
15704 uint mask_offset = 0;
15705
15706 uint separator_cnt;
15707
15708 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15709 {
15710 str_ptr = strstr (mask + mask_offset, ",");
15711
15712 if (str_ptr == NULL) break;
15713
15714 str_pos = str_ptr - mask;
15715
15716 // escaped separator, i.e. "\,"
15717
15718 if (str_pos > 0)
15719 {
15720 if (mask[str_pos - 1] == '\\')
15721 {
15722 separator_cnt --;
15723
15724 mask_offset = str_pos + 1;
15725
15726 continue;
15727 }
15728 }
15729
15730 // reset the offset
15731
15732 mask_offset = 0;
15733
15734 mask[str_pos] = '\0';
15735
15736 switch (separator_cnt)
15737 {
15738 case 0:
15739 mp_reset_usr (mp_usr, 0);
15740
15741 custom_charset_1 = mask;
15742 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15743 break;
15744
15745 case 1:
15746 mp_reset_usr (mp_usr, 1);
15747
15748 custom_charset_2 = mask;
15749 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15750 break;
15751
15752 case 2:
15753 mp_reset_usr (mp_usr, 2);
15754
15755 custom_charset_3 = mask;
15756 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15757 break;
15758
15759 case 3:
15760 mp_reset_usr (mp_usr, 3);
15761
15762 custom_charset_4 = mask;
15763 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15764 break;
15765 }
15766
15767 mask = mask + str_pos + 1;
15768 }
15769 }
15770
15771 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15772 {
15773 if (maskpos > 0)
15774 {
15775 local_free (css_buf);
15776 local_free (data.root_css_buf);
15777 local_free (data.markov_css_buf);
15778
15779 local_free (masks[maskpos - 1]);
15780 }
15781
15782 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15783
15784 data.mask = mask;
15785 data.css_cnt = css_cnt;
15786 data.css_buf = css_buf;
15787
15788 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15789
15790 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15791
15792 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15793 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15794
15795 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15796
15797 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15798
15799 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15800 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15801
15802 data.root_css_buf = root_css_buf;
15803 data.markov_css_buf = markov_css_buf;
15804
15805 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15806
15807 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15808
15809 local_free (root_table_buf);
15810 local_free (markov_table_buf);
15811
15812 // args
15813
15814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15815 {
15816 hc_device_param_t *device_param = &data.devices_param[device_id];
15817
15818 if (device_param->skipped) continue;
15819
15820 device_param->kernel_params_mp[0] = &device_param->d_combs;
15821 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15822 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15823
15824 device_param->kernel_params_mp_buf64[3] = 0;
15825 device_param->kernel_params_mp_buf32[4] = css_cnt;
15826 device_param->kernel_params_mp_buf32[5] = 0;
15827 device_param->kernel_params_mp_buf32[6] = 0;
15828 device_param->kernel_params_mp_buf32[7] = 0;
15829
15830 if (attack_mode == ATTACK_MODE_HYBRID1)
15831 {
15832 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15833 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15834 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15835 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15836 }
15837 else if (attack_mode == ATTACK_MODE_HYBRID2)
15838 {
15839 device_param->kernel_params_mp_buf32[5] = 0;
15840 device_param->kernel_params_mp_buf32[6] = 0;
15841 device_param->kernel_params_mp_buf32[7] = 0;
15842 }
15843
15844 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]);
15845 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]);
15846 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]);
15847
15848 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);
15849 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);
15850 }
15851 }
15852 else if (attack_mode == ATTACK_MODE_BF)
15853 {
15854 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15855
15856 if (increment)
15857 {
15858 for (uint i = 0; i < dictcnt; i++)
15859 {
15860 local_free (dictfiles[i]);
15861 }
15862
15863 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15864 {
15865 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15866
15867 if (l1_filename == NULL) break;
15868
15869 dictcnt++;
15870
15871 dictfiles[dictcnt - 1] = l1_filename;
15872 }
15873 }
15874 else
15875 {
15876 dictcnt++;
15877
15878 dictfiles[dictcnt - 1] = mask;
15879 }
15880
15881 if (dictcnt == 0)
15882 {
15883 log_error ("ERROR: Mask is too small");
15884
15885 return (-1);
15886 }
15887 }
15888 }
15889
15890 free (induction_dictionaries);
15891
15892 // induction_dictionaries_cnt = 0; // implied
15893
15894 if (attack_mode != ATTACK_MODE_BF)
15895 {
15896 if (keyspace == 0)
15897 {
15898 induction_dictionaries = scan_directory (induction_directory);
15899
15900 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15901 }
15902 }
15903
15904 if (induction_dictionaries_cnt)
15905 {
15906 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15907 }
15908
15909 /**
15910 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15911 */
15912 if (keyspace == 1)
15913 {
15914 if ((maskcnt > 1) || (dictcnt > 1))
15915 {
15916 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15917
15918 return (-1);
15919 }
15920 }
15921
15922 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15923 {
15924 char *subid = logfile_generate_subid ();
15925
15926 data.subid = subid;
15927
15928 logfile_sub_msg ("START");
15929
15930 data.devices_status = STATUS_INIT;
15931
15932 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15933 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15934 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15935
15936 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15937
15938 data.cpt_pos = 0;
15939
15940 data.cpt_start = time (NULL);
15941
15942 data.cpt_total = 0;
15943
15944 if (data.restore == 0)
15945 {
15946 rd->words_cur = skip;
15947
15948 skip = 0;
15949
15950 data.skip = 0;
15951 }
15952
15953 data.ms_paused = 0;
15954
15955 data.words_cur = rd->words_cur;
15956
15957 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15958 {
15959 hc_device_param_t *device_param = &data.devices_param[device_id];
15960
15961 if (device_param->skipped) continue;
15962
15963 device_param->speed_pos = 0;
15964
15965 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15966 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15967 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15968
15969 device_param->exec_pos = 0;
15970
15971 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15972
15973 device_param->kernel_power = device_param->kernel_power_user;
15974
15975 device_param->outerloop_pos = 0;
15976 device_param->outerloop_left = 0;
15977 device_param->innerloop_pos = 0;
15978 device_param->innerloop_left = 0;
15979
15980 // some more resets:
15981
15982 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15983
15984 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15985
15986 device_param->pw_cnt = 0;
15987 device_param->pws_cnt = 0;
15988
15989 device_param->words_off = 0;
15990 device_param->words_done = 0;
15991 }
15992
15993 data.kernel_power_div = 0;
15994
15995 // figure out some workload
15996
15997 if (attack_mode == ATTACK_MODE_STRAIGHT)
15998 {
15999 if (data.wordlist_mode == WL_MODE_FILE)
16000 {
16001 char *dictfile = NULL;
16002
16003 if (induction_dictionaries_cnt)
16004 {
16005 dictfile = induction_dictionaries[0];
16006 }
16007 else
16008 {
16009 dictfile = dictfiles[dictpos];
16010 }
16011
16012 data.dictfile = dictfile;
16013
16014 logfile_sub_string (dictfile);
16015
16016 for (uint i = 0; i < rp_files_cnt; i++)
16017 {
16018 logfile_sub_var_string ("rulefile", rp_files[i]);
16019 }
16020
16021 FILE *fd2 = fopen (dictfile, "rb");
16022
16023 if (fd2 == NULL)
16024 {
16025 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16026
16027 return (-1);
16028 }
16029
16030 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16031
16032 fclose (fd2);
16033
16034 if (data.words_cnt == 0)
16035 {
16036 if (data.devices_status == STATUS_CRACKED) break;
16037 if (data.devices_status == STATUS_ABORTED) break;
16038
16039 dictpos++;
16040
16041 continue;
16042 }
16043 }
16044 }
16045 else if (attack_mode == ATTACK_MODE_COMBI)
16046 {
16047 char *dictfile = data.dictfile;
16048 char *dictfile2 = data.dictfile2;
16049
16050 logfile_sub_string (dictfile);
16051 logfile_sub_string (dictfile2);
16052
16053 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16054 {
16055 FILE *fd2 = fopen (dictfile, "rb");
16056
16057 if (fd2 == NULL)
16058 {
16059 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16060
16061 return (-1);
16062 }
16063
16064 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16065
16066 fclose (fd2);
16067 }
16068 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16069 {
16070 FILE *fd2 = fopen (dictfile2, "rb");
16071
16072 if (fd2 == NULL)
16073 {
16074 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16075
16076 return (-1);
16077 }
16078
16079 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16080
16081 fclose (fd2);
16082 }
16083
16084 if (data.words_cnt == 0)
16085 {
16086 if (data.devices_status == STATUS_CRACKED) break;
16087 if (data.devices_status == STATUS_ABORTED) break;
16088
16089 dictpos++;
16090
16091 continue;
16092 }
16093 }
16094 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16095 {
16096 char *dictfile = NULL;
16097
16098 if (induction_dictionaries_cnt)
16099 {
16100 dictfile = induction_dictionaries[0];
16101 }
16102 else
16103 {
16104 dictfile = dictfiles[dictpos];
16105 }
16106
16107 data.dictfile = dictfile;
16108
16109 char *mask = data.mask;
16110
16111 logfile_sub_string (dictfile);
16112 logfile_sub_string (mask);
16113
16114 FILE *fd2 = fopen (dictfile, "rb");
16115
16116 if (fd2 == NULL)
16117 {
16118 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16119
16120 return (-1);
16121 }
16122
16123 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16124
16125 fclose (fd2);
16126
16127 if (data.words_cnt == 0)
16128 {
16129 if (data.devices_status == STATUS_CRACKED) break;
16130 if (data.devices_status == STATUS_ABORTED) break;
16131
16132 dictpos++;
16133
16134 continue;
16135 }
16136 }
16137 else if (attack_mode == ATTACK_MODE_BF)
16138 {
16139 local_free (css_buf);
16140 local_free (data.root_css_buf);
16141 local_free (data.markov_css_buf);
16142
16143 char *mask = dictfiles[dictpos];
16144
16145 logfile_sub_string (mask);
16146
16147 // base
16148
16149 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16150
16151 if (opts_type & OPTS_TYPE_PT_UNICODE)
16152 {
16153 uint css_cnt_unicode = css_cnt * 2;
16154
16155 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16156
16157 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16158 {
16159 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16160
16161 css_buf_unicode[j + 1].cs_buf[0] = 0;
16162 css_buf_unicode[j + 1].cs_len = 1;
16163 }
16164
16165 free (css_buf);
16166
16167 css_buf = css_buf_unicode;
16168 css_cnt = css_cnt_unicode;
16169 }
16170
16171 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16172
16173 uint mask_min = pw_min;
16174 uint mask_max = pw_max;
16175
16176 if (opts_type & OPTS_TYPE_PT_UNICODE)
16177 {
16178 mask_min *= 2;
16179 mask_max *= 2;
16180 }
16181
16182 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16183 {
16184 if (css_cnt < mask_min)
16185 {
16186 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16187 }
16188
16189 if (css_cnt > mask_max)
16190 {
16191 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16192 }
16193
16194 // skip to next mask
16195
16196 dictpos++;
16197
16198 rd->dictpos = dictpos;
16199
16200 logfile_sub_msg ("STOP");
16201
16202 continue;
16203 }
16204
16205 uint save_css_cnt = css_cnt;
16206
16207 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16208 {
16209 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16210 {
16211 uint salt_len = (uint) data.salts_buf[0].salt_len;
16212 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16213
16214 uint css_cnt_salt = css_cnt + salt_len;
16215
16216 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16217
16218 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16219
16220 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16221 {
16222 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16223 css_buf_salt[j].cs_len = 1;
16224 }
16225
16226 free (css_buf);
16227
16228 css_buf = css_buf_salt;
16229 css_cnt = css_cnt_salt;
16230 }
16231 }
16232
16233 data.mask = mask;
16234 data.css_cnt = css_cnt;
16235 data.css_buf = css_buf;
16236
16237 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16238
16239 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16240
16241 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16242
16243 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16244 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16245
16246 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16247
16248 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16249
16250 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16251 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16252
16253 data.root_css_buf = root_css_buf;
16254 data.markov_css_buf = markov_css_buf;
16255
16256 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16257
16258 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16259
16260 local_free (root_table_buf);
16261 local_free (markov_table_buf);
16262
16263 // copy + args
16264
16265 uint css_cnt_l = css_cnt;
16266 uint css_cnt_r;
16267
16268 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16269 {
16270 if (save_css_cnt < 6)
16271 {
16272 css_cnt_r = 1;
16273 }
16274 else if (save_css_cnt == 6)
16275 {
16276 css_cnt_r = 2;
16277 }
16278 else
16279 {
16280 if (opts_type & OPTS_TYPE_PT_UNICODE)
16281 {
16282 if (save_css_cnt == 8 || save_css_cnt == 10)
16283 {
16284 css_cnt_r = 2;
16285 }
16286 else
16287 {
16288 css_cnt_r = 4;
16289 }
16290 }
16291 else
16292 {
16293 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16294 {
16295 css_cnt_r = 3;
16296 }
16297 else
16298 {
16299 css_cnt_r = 4;
16300 }
16301 }
16302 }
16303 }
16304 else
16305 {
16306 css_cnt_r = 1;
16307
16308 /* unfinished code?
16309 int sum = css_buf[css_cnt_r - 1].cs_len;
16310
16311 for (uint i = 1; i < 4 && i < css_cnt; i++)
16312 {
16313 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16314
16315 css_cnt_r++;
16316
16317 sum *= css_buf[css_cnt_r - 1].cs_len;
16318 }
16319 */
16320 }
16321
16322 css_cnt_l -= css_cnt_r;
16323
16324 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16325
16326 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16327 {
16328 hc_device_param_t *device_param = &data.devices_param[device_id];
16329
16330 if (device_param->skipped) continue;
16331
16332 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16333 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16334 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16335
16336 device_param->kernel_params_mp_l_buf64[3] = 0;
16337 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16338 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16339 device_param->kernel_params_mp_l_buf32[6] = 0;
16340 device_param->kernel_params_mp_l_buf32[7] = 0;
16341 device_param->kernel_params_mp_l_buf32[8] = 0;
16342
16343 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16344 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16345 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16346 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16347
16348 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16349 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16350 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16351
16352 device_param->kernel_params_mp_r_buf64[3] = 0;
16353 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16354 device_param->kernel_params_mp_r_buf32[5] = 0;
16355 device_param->kernel_params_mp_r_buf32[6] = 0;
16356 device_param->kernel_params_mp_r_buf32[7] = 0;
16357
16358 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]);
16359 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]);
16360 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]);
16361
16362 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]);
16363 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]);
16364 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]);
16365
16366 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);
16367 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);
16368 }
16369 }
16370
16371 u64 words_base = data.words_cnt;
16372
16373 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16374 {
16375 if (data.kernel_rules_cnt)
16376 {
16377 words_base /= data.kernel_rules_cnt;
16378 }
16379 }
16380 else if (data.attack_kern == ATTACK_KERN_COMBI)
16381 {
16382 if (data.combs_cnt)
16383 {
16384 words_base /= data.combs_cnt;
16385 }
16386 }
16387 else if (data.attack_kern == ATTACK_KERN_BF)
16388 {
16389 if (data.bfs_cnt)
16390 {
16391 words_base /= data.bfs_cnt;
16392 }
16393 }
16394
16395 data.words_base = words_base;
16396
16397 if (keyspace == 1)
16398 {
16399 log_info ("%llu", (unsigned long long int) words_base);
16400
16401 return (0);
16402 }
16403
16404 if (data.words_cur > data.words_base)
16405 {
16406 log_error ("ERROR: restore value greater keyspace");
16407
16408 return (-1);
16409 }
16410
16411 if (data.words_cur)
16412 {
16413 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16414 {
16415 for (uint i = 0; i < data.salts_cnt; i++)
16416 {
16417 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16418 }
16419 }
16420 else if (data.attack_kern == ATTACK_KERN_COMBI)
16421 {
16422 for (uint i = 0; i < data.salts_cnt; i++)
16423 {
16424 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16425 }
16426 }
16427 else if (data.attack_kern == ATTACK_KERN_BF)
16428 {
16429 for (uint i = 0; i < data.salts_cnt; i++)
16430 {
16431 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16432 }
16433 }
16434 }
16435
16436 /*
16437 * Inform user about possible slow speeds
16438 */
16439
16440 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16441 {
16442 if (data.words_base < kernel_power_all)
16443 {
16444 if (quiet == 0)
16445 {
16446 log_info ("");
16447 log_info ("ATTENTION!");
16448 log_info (" The wordlist or mask you are using is too small.");
16449 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16450 log_info (" The cracking speed will drop.");
16451 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16452 log_info ("");
16453 }
16454 }
16455 }
16456
16457 /*
16458 * Update loopback file
16459 */
16460
16461 if (loopback == 1)
16462 {
16463 time_t now;
16464
16465 time (&now);
16466
16467 uint random_num = get_random_num (0, 9999);
16468
16469 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16470
16471 data.loopback_file = loopback_file;
16472 }
16473
16474 /*
16475 * Update dictionary statistic
16476 */
16477
16478 if (keyspace == 0)
16479 {
16480 dictstat_fp = fopen (dictstat, "wb");
16481
16482 if (dictstat_fp)
16483 {
16484 lock_file (dictstat_fp);
16485
16486 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16487
16488 fclose (dictstat_fp);
16489 }
16490 }
16491
16492 data.devices_status = STATUS_RUNNING;
16493
16494 if (initial_restore_done == 0)
16495 {
16496 if (data.restore_disable == 0) cycle_restore ();
16497
16498 initial_restore_done = 1;
16499 }
16500
16501 hc_timer_set (&data.timer_running);
16502
16503 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16504 {
16505 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16506 {
16507 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16508 if (quiet == 0) fflush (stdout);
16509 }
16510 }
16511 else if (wordlist_mode == WL_MODE_STDIN)
16512 {
16513 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16514 if (data.quiet == 0) log_info ("");
16515 }
16516
16517 time_t runtime_start;
16518
16519 time (&runtime_start);
16520
16521 data.runtime_start = runtime_start;
16522
16523 /**
16524 * create cracker threads
16525 */
16526
16527 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16528
16529 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16530 {
16531 hc_device_param_t *device_param = &devices_param[device_id];
16532
16533 if (wordlist_mode == WL_MODE_STDIN)
16534 {
16535 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16536 }
16537 else
16538 {
16539 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16540 }
16541 }
16542
16543 // wait for crack threads to exit
16544
16545 hc_thread_wait (data.devices_cnt, c_threads);
16546
16547 local_free (c_threads);
16548
16549 data.restore = 0;
16550
16551 // finalize task
16552
16553 logfile_sub_var_uint ("status-after-work", data.devices_status);
16554
16555 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16556
16557 if (data.devices_status == STATUS_CRACKED) break;
16558 if (data.devices_status == STATUS_ABORTED) break;
16559
16560 if (data.devices_status == STATUS_BYPASS)
16561 {
16562 data.devices_status = STATUS_RUNNING;
16563 }
16564
16565 if (induction_dictionaries_cnt)
16566 {
16567 unlink (induction_dictionaries[0]);
16568 }
16569
16570 free (induction_dictionaries);
16571
16572 if (attack_mode != ATTACK_MODE_BF)
16573 {
16574 induction_dictionaries = scan_directory (induction_directory);
16575
16576 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16577 }
16578
16579 if (benchmark == 0)
16580 {
16581 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16582 {
16583 if (quiet == 0) clear_prompt ();
16584
16585 if (quiet == 0) log_info ("");
16586
16587 if (status == 1)
16588 {
16589 status_display ();
16590 }
16591 else
16592 {
16593 if (quiet == 0) status_display ();
16594 }
16595
16596 if (quiet == 0) log_info ("");
16597 }
16598 }
16599
16600 if (attack_mode == ATTACK_MODE_BF)
16601 {
16602 dictpos++;
16603
16604 rd->dictpos = dictpos;
16605 }
16606 else
16607 {
16608 if (induction_dictionaries_cnt)
16609 {
16610 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16611 }
16612 else
16613 {
16614 dictpos++;
16615
16616 rd->dictpos = dictpos;
16617 }
16618 }
16619
16620 time_t runtime_stop;
16621
16622 time (&runtime_stop);
16623
16624 data.runtime_stop = runtime_stop;
16625
16626 logfile_sub_uint (runtime_start);
16627 logfile_sub_uint (runtime_stop);
16628
16629 logfile_sub_msg ("STOP");
16630
16631 global_free (subid);
16632 }
16633
16634 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16635
16636 if (data.devices_status == STATUS_CRACKED) break;
16637 if (data.devices_status == STATUS_ABORTED) break;
16638 if (data.devices_status == STATUS_QUIT) break;
16639
16640 if (data.devices_status == STATUS_BYPASS)
16641 {
16642 data.devices_status = STATUS_RUNNING;
16643 }
16644 }
16645
16646 // 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
16647
16648 if (attack_mode == ATTACK_MODE_STRAIGHT)
16649 {
16650 if (data.wordlist_mode == WL_MODE_FILE)
16651 {
16652 if (data.dictfile == NULL)
16653 {
16654 if (dictfiles != NULL)
16655 {
16656 data.dictfile = dictfiles[0];
16657
16658 hc_timer_set (&data.timer_running);
16659 }
16660 }
16661 }
16662 }
16663 // NOTE: combi is okay because it is already set beforehand
16664 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16665 {
16666 if (data.dictfile == NULL)
16667 {
16668 if (dictfiles != NULL)
16669 {
16670 hc_timer_set (&data.timer_running);
16671
16672 data.dictfile = dictfiles[0];
16673 }
16674 }
16675 }
16676 else if (attack_mode == ATTACK_MODE_BF)
16677 {
16678 if (data.mask == NULL)
16679 {
16680 hc_timer_set (&data.timer_running);
16681
16682 data.mask = masks[0];
16683 }
16684 }
16685
16686 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16687 {
16688 data.devices_status = STATUS_EXHAUSTED;
16689 }
16690
16691 // if cracked / aborted remove last induction dictionary
16692
16693 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16694 {
16695 struct stat induct_stat;
16696
16697 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16698 {
16699 unlink (induction_dictionaries[file_pos]);
16700 }
16701 }
16702
16703 // wait for non-interactive threads
16704
16705 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16706 {
16707 hc_thread_wait (1, &ni_threads[thread_idx]);
16708 }
16709
16710 local_free (ni_threads);
16711
16712 // wait for interactive threads
16713
16714 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16715 {
16716 hc_thread_wait (1, &i_thread);
16717 }
16718
16719 // we dont need restore file anymore
16720 if (data.restore_disable == 0)
16721 {
16722 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16723 {
16724 unlink (eff_restore_file);
16725 unlink (new_restore_file);
16726 }
16727 else
16728 {
16729 cycle_restore ();
16730 }
16731 }
16732
16733 // finally save left hashes
16734
16735 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16736 {
16737 save_hash ();
16738 }
16739
16740 /**
16741 * Clean up
16742 */
16743
16744 if (benchmark == 1)
16745 {
16746 status_benchmark ();
16747
16748 log_info ("");
16749 }
16750 else
16751 {
16752 if (quiet == 0) clear_prompt ();
16753
16754 if (quiet == 0) log_info ("");
16755
16756 if (status == 1)
16757 {
16758 status_display ();
16759 }
16760 else
16761 {
16762 if (quiet == 0) status_display ();
16763 }
16764
16765 if (quiet == 0) log_info ("");
16766 }
16767
16768 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16769 {
16770 hc_device_param_t *device_param = &data.devices_param[device_id];
16771
16772 if (device_param->skipped) continue;
16773
16774 local_free (device_param->result);
16775
16776 local_free (device_param->pw_caches);
16777
16778 local_free (device_param->combs_buf);
16779
16780 local_free (device_param->hooks_buf);
16781
16782 local_free (device_param->device_name);
16783
16784 local_free (device_param->device_name_chksum);
16785
16786 local_free (device_param->device_version);
16787
16788 local_free (device_param->driver_version);
16789
16790 if (device_param->pws_buf) myfree (device_param->pws_buf);
16791 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16792 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16793 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16794 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16795 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16796 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16797 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16798 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16799 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16800 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16801 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16802 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16803 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16804 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16805 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16806 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16807 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16808 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16809 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16810 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16811 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16812 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16813 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16814 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16815 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16816 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16817 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16818 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16819
16820 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16821 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16822 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16823 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16824 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16825 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16826 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16827 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16828 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16829 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16830 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16831
16832 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16833 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16834 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16835
16836 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16837 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16838 }
16839
16840 // reset default fan speed
16841
16842 #ifdef HAVE_HWMON
16843 if (gpu_temp_disable == 0)
16844 {
16845 #ifdef HAVE_ADL
16846 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16847 {
16848 hc_thread_mutex_lock (mux_adl);
16849
16850 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16851 {
16852 hc_device_param_t *device_param = &data.devices_param[device_id];
16853
16854 if (device_param->skipped) continue;
16855
16856 if (data.hm_device[device_id].fan_supported == 1)
16857 {
16858 int fanspeed = temp_retain_fanspeed_value[device_id];
16859
16860 if (fanspeed == -1) continue;
16861
16862 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16863
16864 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16865 }
16866 }
16867
16868 hc_thread_mutex_unlock (mux_adl);
16869 }
16870 #endif // HAVE_ADL
16871 }
16872
16873 #ifdef HAVE_ADL
16874 // reset power tuning
16875
16876 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16877 {
16878 hc_thread_mutex_lock (mux_adl);
16879
16880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16881 {
16882 hc_device_param_t *device_param = &data.devices_param[device_id];
16883
16884 if (device_param->skipped) continue;
16885
16886 if (data.hm_device[device_id].od_version == 6)
16887 {
16888 // check powertune capabilities first, if not available then skip device
16889
16890 int powertune_supported = 0;
16891
16892 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16893 {
16894 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16895
16896 return (-1);
16897 }
16898
16899 if (powertune_supported != 0)
16900 {
16901 // powercontrol settings
16902
16903 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)
16904 {
16905 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16906
16907 return (-1);
16908 }
16909
16910 // clocks
16911
16912 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16913
16914 performance_state->iNumberOfPerformanceLevels = 2;
16915
16916 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16917 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16918 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16919 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16920
16921 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)
16922 {
16923 log_info ("ERROR: Failed to restore ADL performance state");
16924
16925 return (-1);
16926 }
16927
16928 local_free (performance_state);
16929 }
16930 }
16931 }
16932
16933 hc_thread_mutex_unlock (mux_adl);
16934 }
16935 #endif // HAVE_ADL
16936
16937 if (gpu_temp_disable == 0)
16938 {
16939 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16940 if (data.hm_nv)
16941 {
16942 #if defined(LINUX) && defined(HAVE_NVML)
16943
16944 hm_NVML_nvmlShutdown (data.hm_nv);
16945
16946 nvml_close (data.hm_nv);
16947
16948 #elif defined(WIN) && (HAVE_NVAPI)
16949
16950 hm_NvAPI_Unload (data.hm_nv);
16951
16952 nvapi_close (data.hm_nv);
16953
16954 #endif
16955
16956 data.hm_nv = NULL;
16957 }
16958 #endif
16959
16960 #ifdef HAVE_ADL
16961 if (data.hm_amd)
16962 {
16963 hm_ADL_Main_Control_Destroy (data.hm_amd);
16964
16965 adl_close (data.hm_amd);
16966 data.hm_amd = NULL;
16967 }
16968 #endif
16969 }
16970 #endif // HAVE_HWMON
16971
16972 // free memory
16973
16974 local_free (masks);
16975
16976 local_free (dictstat_base);
16977
16978 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16979 {
16980 pot_t *pot_ptr = &pot[pot_pos];
16981
16982 hash_t *hash = &pot_ptr->hash;
16983
16984 local_free (hash->digest);
16985
16986 if (isSalted)
16987 {
16988 local_free (hash->salt);
16989 }
16990 }
16991
16992 local_free (pot);
16993
16994 local_free (all_kernel_rules_cnt);
16995 local_free (all_kernel_rules_buf);
16996
16997 local_free (wl_data->buf);
16998 local_free (wl_data);
16999
17000 local_free (bitmap_s1_a);
17001 local_free (bitmap_s1_b);
17002 local_free (bitmap_s1_c);
17003 local_free (bitmap_s1_d);
17004 local_free (bitmap_s2_a);
17005 local_free (bitmap_s2_b);
17006 local_free (bitmap_s2_c);
17007 local_free (bitmap_s2_d);
17008
17009 #ifdef HAVE_HWMON
17010 local_free (temp_retain_fanspeed_value);
17011 #ifdef HAVE_ADL
17012 local_free (od_clock_mem_status);
17013 local_free (od_power_control_status);
17014 #endif // ADL
17015 #endif
17016
17017 global_free (devices_param);
17018
17019 global_free (kernel_rules_buf);
17020
17021 global_free (root_css_buf);
17022 global_free (markov_css_buf);
17023
17024 global_free (digests_buf);
17025 global_free (digests_shown);
17026 global_free (digests_shown_tmp);
17027
17028 global_free (salts_buf);
17029 global_free (salts_shown);
17030
17031 global_free (esalts_buf);
17032
17033 global_free (words_progress_done);
17034 global_free (words_progress_rejected);
17035 global_free (words_progress_restored);
17036
17037 if (pot_fp) fclose (pot_fp);
17038
17039 if (data.devices_status == STATUS_QUIT) break;
17040 }
17041
17042 // destroy others mutex
17043
17044 hc_thread_mutex_delete (mux_dispatcher);
17045 hc_thread_mutex_delete (mux_counter);
17046 hc_thread_mutex_delete (mux_display);
17047 hc_thread_mutex_delete (mux_adl);
17048
17049 // free memory
17050
17051 local_free (eff_restore_file);
17052 local_free (new_restore_file);
17053
17054 local_free (rd);
17055
17056 // tuning db
17057
17058 tuning_db_destroy (tuning_db);
17059
17060 // loopback
17061
17062 local_free (loopback_file);
17063
17064 if (loopback == 1) unlink (loopback_file);
17065
17066 // induction directory
17067
17068 if (induction_dir == NULL)
17069 {
17070 if (attack_mode != ATTACK_MODE_BF)
17071 {
17072 if (rmdir (induction_directory) == -1)
17073 {
17074 if (errno == ENOENT)
17075 {
17076 // good, we can ignore
17077 }
17078 else if (errno == ENOTEMPTY)
17079 {
17080 // good, we can ignore
17081 }
17082 else
17083 {
17084 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17085
17086 return (-1);
17087 }
17088 }
17089
17090 local_free (induction_directory);
17091 }
17092 }
17093
17094 // outfile-check directory
17095
17096 if (outfile_check_dir == NULL)
17097 {
17098 if (rmdir (outfile_check_directory) == -1)
17099 {
17100 if (errno == ENOENT)
17101 {
17102 // good, we can ignore
17103 }
17104 else if (errno == ENOTEMPTY)
17105 {
17106 // good, we can ignore
17107 }
17108 else
17109 {
17110 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17111
17112 return (-1);
17113 }
17114 }
17115
17116 local_free (outfile_check_directory);
17117 }
17118
17119 time_t proc_stop;
17120
17121 time (&proc_stop);
17122
17123 logfile_top_uint (proc_start);
17124 logfile_top_uint (proc_stop);
17125
17126 logfile_top_msg ("STOP");
17127
17128 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17129 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17130
17131 if (data.ocl) ocl_close (data.ocl);
17132
17133 if (data.devices_status == STATUS_ABORTED) return 2;
17134 if (data.devices_status == STATUS_QUIT) return 2;
17135 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17136 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17137 if (data.devices_status == STATUS_CRACKED) return 0;
17138
17139 return -1;
17140 }
Hashcat additions to support pwdhash