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