projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed a bug in line counter: Conditional jump or move depends on uninitialised value
[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 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
400 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Reduced performance profile (low latency desktop)",
447 " 2 = Default performance profile",
448 " 3 = Tuned performance profile (high latency desktop)",
449 "",
450 "* Benchmark Settings:",
451 "",
452 " 0 = Manual Tuning",
453 " 1 = Performance Tuning, default",
454 "",
455 "* OpenCL device-types:",
456 "",
457 " 1 = CPU devices",
458 " 2 = GPU devices",
459 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
460 "",
461 "* Outfile Formats:",
462 "",
463 " 1 = hash[:salt]",
464 " 2 = plain",
465 " 3 = hash[:salt]:plain",
466 " 4 = hex_plain",
467 " 5 = hash[:salt]:hex_plain",
468 " 6 = plain:hex_plain",
469 " 7 = hash[:salt]:plain:hex_plain",
470 " 8 = crackpos",
471 " 9 = hash[:salt]:crackpos",
472 " 10 = plain:crackpos",
473 " 11 = hash[:salt]:plain:crackpos",
474 " 12 = hex_plain:crackpos",
475 " 13 = hash[:salt]:hex_plain:crackpos",
476 " 14 = plain:hex_plain:crackpos",
477 " 15 = hash[:salt]:plain:hex_plain:crackpos",
478 "",
479 "* Debug mode output formats (for hybrid mode only, by using rules):",
480 "",
481 " 1 = save finding rule",
482 " 2 = save original word",
483 " 3 = save original word and finding rule",
484 " 4 = save original word, finding rule and modified plain",
485 "",
486 "* Built-in charsets:",
487 "",
488 " ?l = abcdefghijklmnopqrstuvwxyz",
489 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
490 " ?d = 0123456789",
491 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
492 " ?a = ?l?u?d?s",
493 " ?b = 0x00 - 0xff",
494 "",
495 "* Attack modes:",
496 "",
497 " 0 = Straight",
498 " 1 = Combination",
499 " 3 = Brute-force",
500 " 6 = Hybrid dict + mask",
501 " 7 = Hybrid mask + dict",
502 "",
503 "* Hash types:",
504 "",
505 "[[ Roll-your-own: Raw Hashes ]]",
506 "",
507 " 900 = MD4",
508 " 0 = MD5",
509 " 5100 = Half MD5",
510 " 100 = SHA1",
511 " 10800 = SHA-384",
512 " 1400 = SHA-256",
513 " 1700 = SHA-512",
514 " 5000 = SHA-3(Keccak)",
515 " 10100 = SipHash",
516 " 6000 = RipeMD160",
517 " 6100 = Whirlpool",
518 " 6900 = GOST R 34.11-94",
519 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
520 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
521 "",
522 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
523 "",
524 " 10 = md5($pass.$salt)",
525 " 20 = md5($salt.$pass)",
526 " 30 = md5(unicode($pass).$salt)",
527 " 40 = md5($salt.unicode($pass))",
528 " 3800 = md5($salt.$pass.$salt)",
529 " 3710 = md5($salt.md5($pass))",
530 " 2600 = md5(md5($pass)",
531 " 4300 = md5(strtoupper(md5($pass)))",
532 " 4400 = md5(sha1($pass))",
533 " 110 = sha1($pass.$salt)",
534 " 120 = sha1($salt.$pass)",
535 " 130 = sha1(unicode($pass).$salt)",
536 " 140 = sha1($salt.unicode($pass))",
537 " 4500 = sha1(sha1($pass)",
538 " 4700 = sha1(md5($pass))",
539 " 4900 = sha1($salt.$pass.$salt)",
540 " 1410 = sha256($pass.$salt)",
541 " 1420 = sha256($salt.$pass)",
542 " 1430 = sha256(unicode($pass).$salt)",
543 " 1440 = sha256($salt.unicode($pass))",
544 " 1710 = sha512($pass.$salt)",
545 " 1720 = sha512($salt.$pass)",
546 " 1730 = sha512(unicode($pass).$salt)",
547 " 1740 = sha512($salt.unicode($pass))",
548 "",
549 "[[ Roll-your-own: Authenticated Hashes ]]",
550 "",
551 " 50 = HMAC-MD5 (key = $pass)",
552 " 60 = HMAC-MD5 (key = $salt)",
553 " 150 = HMAC-SHA1 (key = $pass)",
554 " 160 = HMAC-SHA1 (key = $salt)",
555 " 1450 = HMAC-SHA256 (key = $pass)",
556 " 1460 = HMAC-SHA256 (key = $salt)",
557 " 1750 = HMAC-SHA512 (key = $pass)",
558 " 1760 = HMAC-SHA512 (key = $salt)",
559 "",
560 "[[ Generic KDF ]]",
561 "",
562 " 400 = phpass",
563 " 8900 = scrypt",
564 " 11900 = PBKDF2-HMAC-MD5",
565 " 12000 = PBKDF2-HMAC-SHA1",
566 " 10900 = PBKDF2-HMAC-SHA256",
567 " 12100 = PBKDF2-HMAC-SHA512",
568 "",
569 "[[ Network protocols, Challenge-Response ]]",
570 "",
571 " 23 = Skype",
572 " 2500 = WPA/WPA2",
573 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
574 " 5300 = IKE-PSK MD5",
575 " 5400 = IKE-PSK SHA1",
576 " 5500 = NetNTLMv1",
577 " 5500 = NetNTLMv1 + ESS",
578 " 5600 = NetNTLMv2",
579 " 7300 = IPMI2 RAKP HMAC-SHA1",
580 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
581 " 8300 = DNSSEC (NSEC3)",
582 " 10200 = Cram MD5",
583 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
584 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
585 " 11400 = SIP digest authentication (MD5)",
586 "",
587 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
588 "",
589 " 121 = SMF (Simple Machines Forum)",
590 " 400 = phpBB3",
591 " 2611 = vBulletin < v3.8.5",
592 " 2711 = vBulletin > v3.8.5",
593 " 2811 = MyBB",
594 " 2811 = IPB (Invison Power Board)",
595 " 8400 = WBB3 (Woltlab Burning Board)",
596 " 11 = Joomla < 2.5.18",
597 " 400 = Joomla > 2.5.18",
598 " 400 = Wordpress",
599 " 2612 = PHPS",
600 " 7900 = Drupal7",
601 " 21 = osCommerce",
602 " 21 = xt:Commerce",
603 " 11000 = PrestaShop",
604 " 124 = Django (SHA-1)",
605 " 10000 = Django (PBKDF2-SHA256)",
606 " 3711 = Mediawiki B type",
607 " 7600 = Redmine",
608 "",
609 "[[ Database Server ]]",
610 "",
611 " 12 = PostgreSQL",
612 " 131 = MSSQL(2000)",
613 " 132 = MSSQL(2005)",
614 " 1731 = MSSQL(2012)",
615 " 1731 = MSSQL(2014)",
616 " 200 = MySQL323",
617 " 300 = MySQL4.1/MySQL5",
618 " 3100 = Oracle H: Type (Oracle 7+)",
619 " 112 = Oracle S: Type (Oracle 11+)",
620 " 12300 = Oracle T: Type (Oracle 12+)",
621 " 8000 = Sybase ASE",
622 "",
623 "[[ HTTP, SMTP, LDAP Server ]]",
624 "",
625 " 141 = EPiServer 6.x < v4",
626 " 1441 = EPiServer 6.x > v4",
627 " 1600 = Apache $apr1$",
628 " 12600 = ColdFusion 10+",
629 " 1421 = hMailServer",
630 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
631 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
632 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
633 "",
634 "[[ Checksums ]]",
635 "",
636 " 11500 = CRC32",
637 "",
638 "[[ Operating-Systems ]]",
639 "",
640 " 3000 = LM",
641 " 1000 = NTLM",
642 " 1100 = Domain Cached Credentials (DCC), MS Cache",
643 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
644 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
645 " 1500 = descrypt, DES(Unix), Traditional DES",
646 " 12400 = BSDiCrypt, Extended DES",
647 " 500 = md5crypt $1$, MD5(Unix)",
648 " 3200 = bcrypt $2*$, Blowfish(Unix)",
649 " 7400 = sha256crypt $5$, SHA256(Unix)",
650 " 1800 = sha512crypt $6$, SHA512(Unix)",
651 " 122 = OSX v10.4",
652 " 122 = OSX v10.5",
653 " 122 = OSX v10.6",
654 " 1722 = OSX v10.7",
655 " 7100 = OSX v10.8",
656 " 7100 = OSX v10.9",
657 " 7100 = OSX v10.10",
658 " 6300 = AIX {smd5}",
659 " 6700 = AIX {ssha1}",
660 " 6400 = AIX {ssha256}",
661 " 6500 = AIX {ssha512}",
662 " 2400 = Cisco-PIX",
663 " 2410 = Cisco-ASA",
664 " 500 = Cisco-IOS $1$",
665 " 5700 = Cisco-IOS $4$",
666 " 9200 = Cisco-IOS $8$",
667 " 9300 = Cisco-IOS $9$",
668 " 22 = Juniper Netscreen/SSG (ScreenOS)",
669 " 501 = Juniper IVE",
670 " 5800 = Android PIN",
671 " 8100 = Citrix Netscaler",
672 " 8500 = RACF",
673 " 7200 = GRUB 2",
674 " 9900 = Radmin2",
675 "",
676 "[[ Enterprise Application Software (EAS) ]]",
677 "",
678 " 7700 = SAP CODVN B (BCODE)",
679 " 7800 = SAP CODVN F/G (PASSCODE)",
680 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
681 " 8600 = Lotus Notes/Domino 5",
682 " 8700 = Lotus Notes/Domino 6",
683 " 9100 = Lotus Notes/Domino 8",
684 " 133 = PeopleSoft",
685 "",
686 "[[ Archives ]]",
687 "",
688 " 11600 = 7-Zip",
689 " 12500 = RAR3-hp",
690 " 13000 = RAR5",
691 "",
692 "[[ Full-Disk encryptions (FDE) ]]",
693 "",
694 " 62XY = TrueCrypt 5.0+",
695 " X = 1 = PBKDF2-HMAC-RipeMD160",
696 " X = 2 = PBKDF2-HMAC-SHA512",
697 " X = 3 = PBKDF2-HMAC-Whirlpool",
698 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
699 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
700 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
701 " Y = 3 = XTS 1536 bit (Ciphers: All)",
702 " 8800 = Android FDE < v4.3",
703 " 12900 = Android FDE (Samsung DEK)",
704 " 12200 = eCryptfs",
705 "",
706 "[[ Documents ]]",
707 "",
708 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
709 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
710 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
711 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
712 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
713 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
714 " 9400 = MS Office 2007",
715 " 9500 = MS Office 2010",
716 " 9600 = MS Office 2013",
717 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
718 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
719 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
720 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
721 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
722 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
723 "",
724 "[[ Password Managers ]]",
725 "",
726 " 9000 = Password Safe v2",
727 " 5200 = Password Safe v3",
728 " 6800 = Lastpass",
729 " 6600 = 1Password, agilekeychain",
730 " 8200 = 1Password, cloudkeychain",
731 " 11300 = Bitcoin/Litecoin wallet.dat",
732 " 12700 = Blockchain, My Wallet",
733 "",
734 NULL
735 };
736
737 /**
738 * oclHashcat specific functions
739 */
740
741 void status_display_automat ()
742 {
743 FILE *out = stdout;
744
745 fprintf (out, "STATUS\t%u\t", data.devices_status);
746
747 /**
748 * speed new
749 */
750
751 fprintf (out, "SPEED\t");
752
753 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
754 {
755 hc_device_param_t *device_param = &data.devices_param[device_id];
756
757 if (device_param->skipped) continue;
758
759 u64 speed_cnt = 0;
760 float speed_ms = 0;
761
762 for (int i = 0; i < SPEED_CACHE; i++)
763 {
764 float rec_ms;
765
766 hc_timer_get (device_param->speed_rec[i], rec_ms);
767
768 if (rec_ms > SPEED_MAXAGE) continue;
769
770 speed_cnt += device_param->speed_cnt[i];
771 speed_ms += device_param->speed_ms[i];
772 }
773
774 speed_cnt /= SPEED_CACHE;
775 speed_ms /= SPEED_CACHE;
776
777 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
778 }
779
780 /**
781 * exec time
782 */
783
784 fprintf (out, "EXEC_RUNTIME\t");
785
786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
787 {
788 hc_device_param_t *device_param = &data.devices_param[device_id];
789
790 if (device_param->skipped) continue;
791
792 if (device_param->event == NULL) continue;
793
794 cl_ulong time_start;
795 cl_ulong time_end;
796
797 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
798 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
799
800 const double total_time = ((double)(time_end - time_start) * (double)(device_param->device_timer_resolution)) / 1000000.0;
801
802 fprintf (out, "%f\t", total_time);
803 }
804
805 /**
806 * words_cur
807 */
808
809 u64 words_cur = get_lowest_words_done ();
810
811 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
812
813 /**
814 * counter
815 */
816
817 uint salts_left = data.salts_cnt - data.salts_done;
818
819 if (salts_left == 0) salts_left = 1;
820
821 u64 progress_total = data.words_cnt * salts_left;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 if (salts_left > 1)
830 {
831 // otherwise the final cracked status shows 0/XXX progress
832
833 if (data.salts_shown[salt_pos] == 1) continue;
834 }
835
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * salts_left;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * salts_left;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.status_automat == 1)
925 {
926 status_display_automat ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 uint pke[25] = { 0 };
1050
1051 char *pke_ptr = (char *) pke;
1052
1053 for (uint i = 0; i < 25; i++)
1054 {
1055 pke[i] = byte_swap_32 (wpa->pke[i]);
1056 }
1057
1058 char mac1[6] = { 0 };
1059 char mac2[6] = { 0 };
1060
1061 memcpy (mac1, pke_ptr + 23, 6);
1062 memcpy (mac2, pke_ptr + 29, 6);
1063
1064 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1065 (char *) data.salts_buf[0].salt_buf,
1066 mac1[0] & 0xff,
1067 mac1[1] & 0xff,
1068 mac1[2] & 0xff,
1069 mac1[3] & 0xff,
1070 mac1[4] & 0xff,
1071 mac1[5] & 0xff,
1072 mac2[0] & 0xff,
1073 mac2[1] & 0xff,
1074 mac2[2] & 0xff,
1075 mac2[3] & 0xff,
1076 mac2[4] & 0xff,
1077 mac2[5] & 0xff);
1078 }
1079 else if (data.hash_mode == 5200)
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if (data.hash_mode == 9000)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else
1092 {
1093 char out_buf[4096] = { 0 };
1094
1095 ascii_digest (out_buf, 0, 0);
1096
1097 // limit length
1098 if (strlen (out_buf) > 40)
1099 {
1100 out_buf[41] = '.';
1101 out_buf[42] = '.';
1102 out_buf[43] = '.';
1103 out_buf[44] = 0;
1104 }
1105
1106 log_info ("Hash.Target....: %s", out_buf);
1107 }
1108 }
1109 else
1110 {
1111 if (data.hash_mode == 3000)
1112 {
1113 char out_buf1[4096] = { 0 };
1114 char out_buf2[4096] = { 0 };
1115
1116 ascii_digest (out_buf1, 0, 0);
1117 ascii_digest (out_buf2, 0, 1);
1118
1119 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120 }
1121 else
1122 {
1123 log_info ("Hash.Target....: File (%s)", data.hashfile);
1124 }
1125 }
1126
1127 log_info ("Hash.Type......: %s", hash_type);
1128
1129 /**
1130 * speed new
1131 */
1132
1133 u64 speed_cnt[DEVICES_MAX] = { 0 };
1134 float speed_ms[DEVICES_MAX] = { 0 };
1135
1136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137 {
1138 hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140 if (device_param->skipped) continue;
1141
1142 // we need to clear values (set to 0) because in case the device does
1143 // not get new candidates it idles around but speed display would
1144 // show it as working.
1145 // if we instantly set it to 0 after reading it happens that the
1146 // speed can be shown as zero if the users refreshes too fast.
1147 // therefore, we add a timestamp when a stat was recorded and if its
1148 // too old we will not use it
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 float rec_ms;
1156
1157 hc_timer_get (device_param->speed_rec[i], rec_ms);
1158
1159 if (rec_ms > SPEED_MAXAGE) continue;
1160
1161 speed_cnt[device_id] += device_param->speed_cnt[i];
1162 speed_ms[device_id] += device_param->speed_ms[i];
1163 }
1164
1165 speed_cnt[device_id] /= SPEED_CACHE;
1166 speed_ms[device_id] /= SPEED_CACHE;
1167 }
1168
1169 float hashes_all_ms = 0;
1170
1171 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1172
1173 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1174 {
1175 hc_device_param_t *device_param = &data.devices_param[device_id];
1176
1177 if (device_param->skipped) continue;
1178
1179 hashes_dev_ms[device_id] = 0;
1180
1181 if (speed_ms[device_id])
1182 {
1183 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1184
1185 hashes_all_ms += hashes_dev_ms[device_id];
1186 }
1187 }
1188
1189 /**
1190 * exec time
1191 */
1192
1193 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1194
1195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1196 {
1197 hc_device_param_t *device_param = &data.devices_param[device_id];
1198
1199 if (device_param->skipped) continue;
1200
1201 if (device_param->event == NULL) continue;
1202
1203 cl_ulong time_start;
1204 cl_ulong time_end;
1205
1206 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1207 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1208
1209 const double total_time = (time_end - time_start) / 1000000.0;
1210
1211 exec_runtime_ms[device_id] = total_time;
1212 }
1213
1214 /**
1215 * timers
1216 */
1217
1218 float ms_running = 0;
1219
1220 hc_timer_get (data.timer_running, ms_running);
1221
1222 float ms_paused = data.ms_paused;
1223
1224 if (data.devices_status == STATUS_PAUSED)
1225 {
1226 float ms_paused_tmp = 0;
1227
1228 hc_timer_get (data.timer_paused, ms_paused_tmp);
1229
1230 ms_paused += ms_paused_tmp;
1231 }
1232
1233 #ifdef WIN
1234
1235 __time64_t sec_run = ms_running / 1000;
1236
1237 #else
1238
1239 time_t sec_run = ms_running / 1000;
1240
1241 #endif
1242
1243 if (sec_run)
1244 {
1245 char display_run[32] = { 0 };
1246
1247 struct tm tm_run;
1248
1249 struct tm *tmp = NULL;
1250
1251 #ifdef WIN
1252
1253 tmp = _gmtime64 (&sec_run);
1254
1255 #else
1256
1257 tmp = gmtime (&sec_run);
1258
1259 #endif
1260
1261 if (tmp != NULL)
1262 {
1263 memset (&tm_run, 0, sizeof (tm_run));
1264
1265 memcpy (&tm_run, tmp, sizeof (tm_run));
1266
1267 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1268
1269 char *start = ctime (&data.proc_start);
1270
1271 size_t start_len = strlen (start);
1272
1273 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1274 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1275
1276 log_info ("Time.Started...: %s (%s)", start, display_run);
1277 }
1278 }
1279 else
1280 {
1281 log_info ("Time.Started...: 0 secs");
1282 }
1283
1284 /**
1285 * counters
1286 */
1287
1288 uint salts_left = data.salts_cnt - data.salts_done;
1289
1290 if (salts_left == 0) salts_left = 1;
1291
1292 u64 progress_total = data.words_cnt * salts_left;
1293
1294 u64 all_done = 0;
1295 u64 all_rejected = 0;
1296 u64 all_restored = 0;
1297
1298 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1299 {
1300 if (salts_left > 1)
1301 {
1302 // otherwise the final cracked status shows 0/XXX progress
1303
1304 if (data.salts_shown[salt_pos] == 1) continue;
1305 }
1306
1307 all_done += data.words_progress_done[salt_pos];
1308 all_rejected += data.words_progress_rejected[salt_pos];
1309 all_restored += data.words_progress_restored[salt_pos];
1310 }
1311
1312 u64 progress_cur = all_restored + all_done + all_rejected;
1313 u64 progress_end = progress_total;
1314
1315 u64 progress_skip = 0;
1316
1317 if (data.skip)
1318 {
1319 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1320
1321 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1323 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1324 }
1325
1326 if (data.limit)
1327 {
1328 progress_end = MIN (data.limit, data.words_base) * salts_left;
1329
1330 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1332 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1333 }
1334
1335 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1336 u64 progress_end_relative_skip = progress_end - progress_skip;
1337
1338 float speed_ms_real = ms_running - ms_paused;
1339 u64 speed_plains_real = all_done;
1340
1341 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1342 {
1343 if (data.devices_status != STATUS_CRACKED)
1344 {
1345 u64 words_per_ms = 0;
1346
1347 if (speed_plains_real && speed_ms_real)
1348 {
1349 words_per_ms = speed_plains_real / speed_ms_real;
1350 }
1351
1352 #ifdef WIN
1353 __time64_t sec_etc = 0;
1354 #else
1355 time_t sec_etc = 0;
1356 #endif
1357
1358 if (words_per_ms)
1359 {
1360 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1361
1362 u64 ms_left = progress_left_relative_skip / words_per_ms;
1363
1364 sec_etc = ms_left / 1000;
1365 }
1366
1367 if (sec_etc == 0)
1368 {
1369 log_info ("Time.Estimated.: 0 secs");
1370 }
1371 else if ((u64) sec_etc > ETC_MAX)
1372 {
1373 log_info ("Time.Estimated.: > 10 Years");
1374 }
1375 else
1376 {
1377 char display_etc[32] = { 0 };
1378
1379 struct tm tm_etc;
1380
1381 struct tm *tmp = NULL;
1382
1383 #ifdef WIN
1384
1385 tmp = _gmtime64 (&sec_etc);
1386
1387 #else
1388
1389 tmp = gmtime (&sec_etc);
1390
1391 #endif
1392
1393 if (tmp != NULL)
1394 {
1395 memset (&tm_etc, 0, sizeof (tm_etc));
1396
1397 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1398
1399 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1400
1401 time_t now;
1402
1403 time (&now);
1404
1405 now += sec_etc;
1406
1407 char *etc = ctime (&now);
1408
1409 size_t etc_len = strlen (etc);
1410
1411 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1412 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1413
1414 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 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);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1480 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1481 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1482
1483 if ((data.cpt_start + 86400) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_cur_hour,
1488 cpt_cur_day,
1489 cpt_avg_min,
1490 cpt_avg_hour,
1491 cpt_avg_day);
1492 }
1493 else if ((data.cpt_start + 3600) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_avg_min,
1499 cpt_avg_hour,
1500 cpt_avg_day);
1501 }
1502 else if ((data.cpt_start + 60) < now)
1503 {
1504 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1505 cpt_cur_min,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else
1511 {
1512 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 }
1518
1519 // Restore point
1520
1521 u64 restore_point = get_lowest_words_done ();
1522
1523 u64 restore_total = data.words_base;
1524
1525 float percent_restore = 0;
1526
1527 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1528
1529 if (progress_end_relative_skip)
1530 {
1531 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532 {
1533 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1534 float percent_rejected = 0.0;
1535
1536 if (progress_cur)
1537 {
1538 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1539 }
1540
1541 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);
1542 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1543
1544 if (data.restore_disable == 0)
1545 {
1546 if (percent_finished != 1)
1547 {
1548 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1549 }
1550 }
1551 }
1552 }
1553 else
1554 {
1555 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1556 {
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 }
1564 }
1565 else
1566 {
1567 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1568 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1569
1570 // --restore not allowed if stdin is used -- really? why?
1571
1572 //if (data.restore_disable == 0)
1573 //{
1574 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1575 //}
1576 }
1577 }
1578
1579 #ifdef HAVE_HWMON
1580 if (data.gpu_temp_disable == 0)
1581 {
1582 hc_thread_mutex_lock (mux_adl);
1583
1584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1585 {
1586 hc_device_param_t *device_param = &data.devices_param[device_id];
1587
1588 if (device_param->skipped) continue;
1589
1590 #define HM_STR_BUF_SIZE 255
1591
1592 if (data.hm_device[device_id].fan_supported == 1)
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 if (device_param->vendor_id == VENDOR_ID_AMD)
1602 {
1603 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1604 }
1605 else if (device_param->vendor_id == VENDOR_ID_NV)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609
1610 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1611 }
1612 else
1613 {
1614 char utilization[HM_STR_BUF_SIZE] = { 0 };
1615 char temperature[HM_STR_BUF_SIZE] = { 0 };
1616
1617 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1618 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1621 }
1622 }
1623
1624 hc_thread_mutex_unlock (mux_adl);
1625 }
1626 #endif // HAVE_HWMON
1627 }
1628
1629 static void status_benchmark ()
1630 {
1631 if (data.devices_status == STATUS_INIT) return;
1632 if (data.devices_status == STATUS_STARTING) return;
1633
1634 if (data.words_cnt == 0) return;
1635
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 float speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = 0;
1646 speed_ms[device_id] = 0;
1647
1648 for (int i = 0; i < SPEED_CACHE; i++)
1649 {
1650 speed_cnt[device_id] += device_param->speed_cnt[i];
1651 speed_ms[device_id] += device_param->speed_ms[i];
1652 }
1653
1654 speed_cnt[device_id] /= SPEED_CACHE;
1655 speed_ms[device_id] /= SPEED_CACHE;
1656 }
1657
1658 float hashes_all_ms = 0;
1659
1660 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1661
1662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1663 {
1664 hc_device_param_t *device_param = &data.devices_param[device_id];
1665
1666 if (device_param->skipped) continue;
1667
1668 hashes_dev_ms[device_id] = 0;
1669
1670 if (speed_ms[device_id])
1671 {
1672 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1673
1674 hashes_all_ms += hashes_dev_ms[device_id];
1675 }
1676 }
1677
1678 /**
1679 * exec time
1680 */
1681
1682 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 if (device_param->event == NULL) continue;
1691
1692 cl_ulong time_start;
1693 cl_ulong time_end;
1694
1695 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1696 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1697
1698 const double total_time = (time_end - time_start) / 1000000.0;
1699
1700 exec_runtime_ms[device_id] = total_time;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static uint count_lines (FILE *fd)
1841 {
1842 uint cnt = 0;
1843
1844 char *buf = (char *) mymalloc (BUFSIZ + 1);
1845
1846 char prev = '\n';
1847
1848 while (!feof (fd))
1849 {
1850 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1851
1852 if (nread < 1) continue;
1853
1854 size_t i;
1855
1856 for (i = 0; i < nread; i++)
1857 {
1858 if (prev == '\n') cnt++;
1859
1860 prev = buf[i];
1861 }
1862 }
1863
1864 myfree (buf);
1865
1866 return cnt;
1867 }
1868
1869 static void clear_prompt ()
1870 {
1871 fputc ('\r', stdout);
1872
1873 for (size_t i = 0; i < strlen (PROMPT); i++)
1874 {
1875 fputc (' ', stdout);
1876 }
1877
1878 fputc ('\r', stdout);
1879
1880 fflush (stdout);
1881 }
1882
1883 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1884 {
1885 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);
1886 }
1887
1888 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1889 {
1890 char *outfile = data.outfile;
1891 uint quiet = data.quiet;
1892 FILE *pot_fp = data.pot_fp;
1893 uint loopback = data.loopback;
1894 uint debug_mode = data.debug_mode;
1895 char *debug_file = data.debug_file;
1896
1897 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1898 int debug_rule_len = 0; // -1 error
1899 uint debug_plain_len = 0;
1900
1901 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1902
1903 // hash
1904
1905 char out_buf[4096] = { 0 };
1906
1907 ascii_digest (out_buf, salt_pos, digest_pos);
1908
1909 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1910
1911 // plain
1912
1913 plain_t plain;
1914
1915 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);
1916
1917 uint gidvid = plain.gidvid;
1918 uint il_pos = plain.il_pos;
1919
1920 u64 crackpos = device_param->words_off;
1921
1922 uint plain_buf[16] = { 0 };
1923
1924 u8 *plain_ptr = (u8 *) plain_buf;
1925 unsigned int plain_len = 0;
1926
1927 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1928 {
1929 u64 gidd = gidvid;
1930 u64 gidm = 0;
1931
1932 pw_t pw;
1933
1934 gidd_to_pw_t (device_param, gidd, &pw);
1935
1936 for (int i = 0, j = gidm; i < 16; i++, j++)
1937 {
1938 plain_buf[i] = pw.h.hi1[0][j];
1939 }
1940
1941 plain_len = pw.pw_len;
1942
1943 const uint off = device_param->innerloop_pos + il_pos;
1944
1945 if (debug_mode > 0)
1946 {
1947 debug_rule_len = 0;
1948
1949 // save rule
1950 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1951 {
1952 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1953
1954 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1955 }
1956
1957 // save plain
1958 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1959 {
1960 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1961
1962 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1963
1964 debug_plain_len = plain_len;
1965 }
1966 }
1967
1968 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1969
1970 crackpos += gidvid;
1971 crackpos *= data.kernel_rules_cnt;
1972 crackpos += device_param->innerloop_pos + il_pos;
1973
1974 if (plain_len > data.pw_max) plain_len = data.pw_max;
1975 }
1976 else if (data.attack_mode == ATTACK_MODE_COMBI)
1977 {
1978 u64 gidd = gidvid;
1979 u64 gidm = 0;
1980
1981 pw_t pw;
1982
1983 gidd_to_pw_t (device_param, gidd, &pw);
1984
1985 for (int i = 0, j = gidm; i < 16; i++, j++)
1986 {
1987 plain_buf[i] = pw.h.hi1[0][j];
1988 }
1989
1990 plain_len = pw.pw_len;
1991
1992 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1993 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1994
1995 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1996 {
1997 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1998 }
1999 else
2000 {
2001 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2002
2003 memcpy (plain_ptr, comb_buf, comb_len);
2004 }
2005
2006 plain_len += comb_len;
2007
2008 crackpos += gidvid;
2009 crackpos *= data.combs_cnt;
2010 crackpos += device_param->innerloop_pos + il_pos;
2011
2012 if (data.pw_max != PW_DICTMAX1)
2013 {
2014 if (plain_len > data.pw_max) plain_len = data.pw_max;
2015 }
2016 }
2017 else if (data.attack_mode == ATTACK_MODE_BF)
2018 {
2019 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2020 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2021
2022 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2023 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2024
2025 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2026 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2027
2028 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2029 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2030
2031 plain_len = data.css_cnt;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.bfs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036 }
2037 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
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 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2059
2060 plain_len += start + stop;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.combs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065
2066 if (data.pw_max != PW_DICTMAX1)
2067 {
2068 if (plain_len > data.pw_max) plain_len = data.pw_max;
2069 }
2070 }
2071 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2072 {
2073 u64 gidd = gidvid;
2074 u64 gidm = 0;
2075
2076 pw_t pw;
2077
2078 gidd_to_pw_t (device_param, gidd, &pw);
2079
2080 for (int i = 0, j = gidm; i < 16; i++, j++)
2081 {
2082 plain_buf[i] = pw.h.hi1[0][j];
2083 }
2084
2085 plain_len = pw.pw_len;
2086
2087 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2088
2089 uint start = 0;
2090 uint stop = device_param->kernel_params_mp_buf32[4];
2091
2092 memmove (plain_ptr + stop, plain_ptr, plain_len);
2093
2094 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2095
2096 plain_len += start + stop;
2097
2098 crackpos += gidvid;
2099 crackpos *= data.combs_cnt;
2100 crackpos += device_param->innerloop_pos + il_pos;
2101
2102 if (data.pw_max != PW_DICTMAX1)
2103 {
2104 if (plain_len > data.pw_max) plain_len = data.pw_max;
2105 }
2106 }
2107
2108 if (data.attack_mode == ATTACK_MODE_BF)
2109 {
2110 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2111 {
2112 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2113 {
2114 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2115 {
2116 plain_len = plain_len - data.salts_buf[0].salt_len;
2117 }
2118 }
2119
2120 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2121 {
2122 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2123 {
2124 plain_ptr[j] = plain_ptr[i];
2125 }
2126
2127 plain_len = plain_len / 2;
2128 }
2129 }
2130 }
2131
2132 // if enabled, update also the potfile
2133
2134 if (pot_fp)
2135 {
2136 lock_file (pot_fp);
2137
2138 fprintf (pot_fp, "%s:", out_buf);
2139
2140 format_plain (pot_fp, plain_ptr, plain_len, 1);
2141
2142 fputc ('\n', pot_fp);
2143
2144 fflush (pot_fp);
2145
2146 unlock_file (pot_fp);
2147 }
2148
2149 // outfile
2150
2151 FILE *out_fp = NULL;
2152
2153 if (outfile != NULL)
2154 {
2155 if ((out_fp = fopen (outfile, "ab")) == NULL)
2156 {
2157 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2158
2159 out_fp = stdout;
2160 }
2161 lock_file (out_fp);
2162 }
2163 else
2164 {
2165 out_fp = stdout;
2166
2167 if (quiet == 0) clear_prompt ();
2168 }
2169
2170 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2171
2172 if (outfile != NULL)
2173 {
2174 if (out_fp != stdout)
2175 {
2176 fclose (out_fp);
2177 }
2178 }
2179 else
2180 {
2181 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2182 {
2183 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2184 {
2185 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2186 if (quiet == 0) fflush (stdout);
2187 }
2188 }
2189 }
2190
2191 // loopback
2192
2193 if (loopback)
2194 {
2195 char *loopback_file = data.loopback_file;
2196
2197 FILE *fb_fp = NULL;
2198
2199 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2200 {
2201 lock_file (fb_fp);
2202
2203 format_plain (fb_fp, plain_ptr, plain_len, 1);
2204
2205 fputc ('\n', fb_fp);
2206
2207 fclose (fb_fp);
2208 }
2209 }
2210
2211 // (rule) debug mode
2212
2213 // the next check implies that:
2214 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2215 // - debug_mode > 0
2216
2217 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2218 {
2219 if (debug_rule_len < 0) debug_rule_len = 0;
2220
2221 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2222
2223 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2224
2225 if ((quiet == 0) && (debug_file == NULL))
2226 {
2227 fprintf (stdout, "%s", PROMPT);
2228 fflush (stdout);
2229 }
2230 }
2231 }
2232
2233 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2234 {
2235 salt_t *salt_buf = &data.salts_buf[salt_pos];
2236
2237 int found = 0;
2238
2239 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);
2240
2241 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2242
2243 if (found == 1)
2244 {
2245 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2246
2247 log_info_nn ("");
2248
2249 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);
2250
2251 uint cpt_cracked = 0;
2252
2253 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2254 {
2255 uint idx = salt_buf->digests_offset + digest_pos;
2256
2257 if (data.digests_shown_tmp[idx] == 0) continue;
2258
2259 if (data.digests_shown[idx] == 1) continue;
2260
2261 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2262 {
2263 data.digests_shown[idx] = 1;
2264
2265 data.digests_done++;
2266
2267 cpt_cracked++;
2268
2269 salt_buf->digests_done++;
2270
2271 if (salt_buf->digests_done == salt_buf->digests_cnt)
2272 {
2273 data.salts_shown[salt_pos] = 1;
2274
2275 data.salts_done++;
2276 }
2277 }
2278
2279 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2280
2281 check_hash (device_param, salt_pos, digest_pos);
2282 }
2283
2284 if (cpt_cracked > 0)
2285 {
2286 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2287 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2288
2289 data.cpt_pos++;
2290
2291 data.cpt_total += cpt_cracked;
2292
2293 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2294 }
2295
2296 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2297 {
2298 // we need to reset cracked state on the device
2299 // otherwise host thinks again and again the hash was cracked
2300 // and returns invalid password each time
2301
2302 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2303
2304 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);
2305 }
2306
2307 memset (device_param->result, 0, device_param->size_results);
2308
2309 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);
2310 }
2311 }
2312
2313 static void save_hash ()
2314 {
2315 char *hashfile = data.hashfile;
2316
2317 char new_hashfile[256] = { 0 };
2318 char old_hashfile[256] = { 0 };
2319
2320 snprintf (new_hashfile, 255, "%s.new", hashfile);
2321 snprintf (old_hashfile, 255, "%s.old", hashfile);
2322
2323 unlink (new_hashfile);
2324
2325 char separator = data.separator;
2326
2327 FILE *fp = fopen (new_hashfile, "wb");
2328
2329 if (fp == NULL)
2330 {
2331 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2337 {
2338 if (data.salts_shown[salt_pos] == 1) continue;
2339
2340 salt_t *salt_buf = &data.salts_buf[salt_pos];
2341
2342 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2343 {
2344 uint idx = salt_buf->digests_offset + digest_pos;
2345
2346 if (data.digests_shown[idx] == 1) continue;
2347
2348 if (data.hash_mode != 2500)
2349 {
2350 char out_buf[4096] = { 0 };
2351
2352 if (data.username == 1)
2353 {
2354 user_t *user = data.hash_info[idx]->user;
2355
2356 uint i;
2357
2358 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2359
2360 fputc (separator, fp);
2361 }
2362
2363 ascii_digest (out_buf, salt_pos, digest_pos);
2364
2365 fputs (out_buf, fp);
2366
2367 log_out (fp, "");
2368 }
2369 else
2370 {
2371 hccap_t hccap;
2372
2373 to_hccap_t (&hccap, salt_pos, digest_pos);
2374
2375 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2376 }
2377 }
2378 }
2379
2380 fflush (fp);
2381
2382 fclose (fp);
2383
2384 unlink (old_hashfile);
2385
2386 if (rename (hashfile, old_hashfile) != 0)
2387 {
2388 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2389
2390 exit (-1);
2391 }
2392
2393 unlink (hashfile);
2394
2395 if (rename (new_hashfile, hashfile) != 0)
2396 {
2397 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2398
2399 exit (-1);
2400 }
2401
2402 unlink (old_hashfile);
2403 }
2404
2405 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2406 {
2407 // function called only in case kernel_blocks_all > words_left)
2408
2409 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2410
2411 kernel_blocks_div += kernel_blocks_div / 100;
2412
2413 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2414
2415 while (kernel_blocks_new < total_left)
2416 {
2417 kernel_blocks_div += kernel_blocks_div / 100;
2418
2419 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2420 }
2421
2422 if (data.quiet == 0)
2423 {
2424 clear_prompt ();
2425
2426 log_info ("");
2427
2428 log_info ("INFO: approaching final keyspace, workload adjusted");
2429
2430 log_info ("");
2431
2432 fprintf (stdout, "%s", PROMPT);
2433
2434 fflush (stdout);
2435 }
2436
2437 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2438
2439 return kernel_blocks_div;
2440 }
2441
2442 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2443 {
2444 uint num_elements = num;
2445
2446 device_param->kernel_params_buf32[30] = data.combs_mode;
2447 device_param->kernel_params_buf32[31] = num;
2448
2449 uint kernel_threads = device_param->kernel_threads;
2450
2451 while (num_elements % kernel_threads) num_elements++;
2452
2453 cl_kernel kernel = NULL;
2454
2455 switch (kern_run)
2456 {
2457 case KERN_RUN_1: kernel = device_param->kernel1; break;
2458 case KERN_RUN_12: kernel = device_param->kernel12; break;
2459 case KERN_RUN_2: kernel = device_param->kernel2; break;
2460 case KERN_RUN_23: kernel = device_param->kernel23; break;
2461 case KERN_RUN_3: kernel = device_param->kernel3; break;
2462 }
2463
2464 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2465 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2466 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2467 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2468 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2469 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2470 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2471 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2472 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2473 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2474 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2475
2476 cl_event event;
2477
2478 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2479 {
2480 const size_t global_work_size[3] = { num_elements, 32, 1 };
2481 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2482
2483 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2484 }
2485 else
2486 {
2487 const size_t global_work_size[3] = { num_elements, 1, 1 };
2488 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2489
2490 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);
2491
2492 if (rc != CL_SUCCESS)
2493 {
2494 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2495
2496 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2497 }
2498 }
2499
2500 hc_clFlush (data.ocl, device_param->command_queue);
2501
2502 //hc_clFinish (data.ocl, device_param->command_queue);
2503
2504 hc_clWaitForEvents (data.ocl, 1, &event);
2505
2506 if (event_update) device_param->event = event;
2507 }
2508
2509 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2510 {
2511 uint num_elements = num;
2512
2513 switch (kern_run)
2514 {
2515 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2516 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2517 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2518 }
2519
2520 // causes problems with special threads like in bcrypt
2521 // const uint kernel_threads = device_param->kernel_threads;
2522
2523 const uint kernel_threads = KERNEL_THREADS;
2524
2525 while (num_elements % kernel_threads) num_elements++;
2526
2527 cl_kernel kernel = NULL;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2532 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2533 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2534 }
2535
2536 switch (kern_run)
2537 {
2538 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2544 break;
2545 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2551 break;
2552 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2553 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2554 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2555 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2556 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2557 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2558 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2559 break;
2560 }
2561
2562 const size_t global_work_size[3] = { num_elements, 1, 1 };
2563 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2564
2565 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);
2566
2567 if (rc != CL_SUCCESS)
2568 {
2569 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2570
2571 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2572 }
2573
2574 hc_clFlush (data.ocl, device_param->command_queue);
2575
2576 hc_clFinish (data.ocl, device_param->command_queue);
2577 }
2578
2579 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2580 {
2581 uint num_elements = num;
2582
2583 uint kernel_threads = device_param->kernel_threads;
2584
2585 while (num_elements % kernel_threads) num_elements++;
2586
2587 cl_kernel kernel = device_param->kernel_tb;
2588
2589 const size_t global_work_size[3] = { num_elements, 1, 1 };
2590 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2591
2592 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);
2593
2594 if (rc != CL_SUCCESS)
2595 {
2596 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2597
2598 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2599 }
2600
2601 hc_clFlush (data.ocl, device_param->command_queue);
2602
2603 hc_clFinish (data.ocl, device_param->command_queue);
2604 }
2605
2606 static void run_kernel_tm (hc_device_param_t *device_param)
2607 {
2608 const uint num_elements = 1024; // fixed
2609
2610 const uint kernel_threads = 32;
2611
2612 cl_kernel kernel = device_param->kernel_tm;
2613
2614 const size_t global_work_size[3] = { num_elements, 1, 1 };
2615 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2616
2617 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);
2618
2619 if (rc != CL_SUCCESS)
2620 {
2621 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2622
2623 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2624 }
2625
2626 hc_clFlush (data.ocl, device_param->command_queue);
2627
2628 hc_clFinish (data.ocl, device_param->command_queue);
2629 }
2630
2631 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2632 {
2633 uint num_elements = num;
2634
2635 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2636 device_param->kernel_params_amp_buf32[6] = num_elements;
2637
2638 // causes problems with special threads like in bcrypt
2639 // const uint kernel_threads = device_param->kernel_threads;
2640
2641 const uint kernel_threads = KERNEL_THREADS;
2642
2643 while (num_elements % kernel_threads) num_elements++;
2644
2645 cl_kernel kernel = device_param->kernel_amp;
2646
2647 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2648 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2649
2650 const size_t global_work_size[3] = { num_elements, 1, 1 };
2651 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2652
2653 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);
2654
2655 if (rc != CL_SUCCESS)
2656 {
2657 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2658
2659 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2660 }
2661
2662 hc_clFlush (data.ocl, device_param->command_queue);
2663
2664 hc_clFinish (data.ocl, device_param->command_queue);
2665 }
2666
2667 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2668 {
2669 int rc = -1;
2670
2671 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2672 {
2673 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2674
2675 const cl_uchar zero = 0;
2676
2677 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2678 }
2679
2680 if (rc != 0)
2681 {
2682 // NOTE: clEnqueueFillBuffer () always fails with -59
2683 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2684 // How's that possible, OpenCL 1.2 support is advertised??
2685 // We need to workaround...
2686
2687 #define FILLSZ 0x100000
2688
2689 char *tmp = (char *) mymalloc (FILLSZ);
2690
2691 for (uint i = 0; i < size; i += FILLSZ)
2692 {
2693 const int left = size - i;
2694
2695 const int fillsz = MIN (FILLSZ, left);
2696
2697 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2698 }
2699
2700 myfree (tmp);
2701 }
2702 }
2703
2704 static int run_rule_engine (const int rule_len, const char *rule_buf)
2705 {
2706 if (rule_len == 0)
2707 {
2708 return 0;
2709 }
2710 else if (rule_len == 1)
2711 {
2712 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2713 }
2714
2715 return 1;
2716 }
2717
2718 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2719 {
2720 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2721 {
2722 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);
2723 }
2724 else if (data.attack_kern == ATTACK_KERN_COMBI)
2725 {
2726 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);
2727 }
2728 else if (data.attack_kern == ATTACK_KERN_BF)
2729 {
2730 const u64 off = device_param->words_off;
2731
2732 device_param->kernel_params_mp_l_buf64[3] = off;
2733
2734 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2735 }
2736 }
2737
2738 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2739 {
2740 const uint kernel_loops = device_param->kernel_loops;
2741
2742 //only useful in debug
2743 //if (data.quiet == 0)
2744 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2745
2746 // init speed timer
2747
2748 uint speed_pos = device_param->speed_pos;
2749
2750 #ifdef _POSIX
2751 if (device_param->timer_speed.tv_sec == 0)
2752 {
2753 hc_timer_set (&device_param->timer_speed);
2754 }
2755 #endif
2756
2757 #ifdef _WIN
2758 if (device_param->timer_speed.QuadPart == 0)
2759 {
2760 hc_timer_set (&device_param->timer_speed);
2761 }
2762 #endif
2763
2764 // find higest password length, this is for optimization stuff
2765
2766 uint highest_pw_len = 0;
2767
2768 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2769 {
2770 }
2771 else if (data.attack_kern == ATTACK_KERN_COMBI)
2772 {
2773 }
2774 else if (data.attack_kern == ATTACK_KERN_BF)
2775 {
2776 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2777 + device_param->kernel_params_mp_l_buf32[5];
2778 }
2779
2780 // bitslice optimization stuff
2781
2782 if (data.attack_mode == ATTACK_MODE_BF)
2783 {
2784 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2785 {
2786 run_kernel_tb (device_param, pws_cnt);
2787 }
2788 }
2789
2790 // iteration type
2791
2792 uint innerloop_step = 0;
2793 uint innerloop_cnt = 0;
2794
2795 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2796 else innerloop_step = 1;
2797
2798 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2799 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2800 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2801
2802 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2803
2804 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2805 {
2806 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2807
2808 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2809
2810 if (data.devices_status == STATUS_CRACKED) break;
2811 if (data.devices_status == STATUS_ABORTED) break;
2812 if (data.devices_status == STATUS_QUIT) break;
2813 if (data.devices_status == STATUS_BYPASS) break;
2814
2815 if (data.salts_shown[salt_pos] == 1) continue;
2816
2817 salt_t *salt_buf = &data.salts_buf[salt_pos];
2818
2819 device_param->kernel_params_buf32[24] = salt_pos;
2820 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2821 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2822
2823 FILE *combs_fp = device_param->combs_fp;
2824
2825 if (data.attack_mode == ATTACK_MODE_COMBI)
2826 {
2827 rewind (combs_fp);
2828 }
2829
2830 // innerloops
2831
2832 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2833 {
2834 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2835
2836 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2837
2838 if (data.devices_status == STATUS_CRACKED) break;
2839 if (data.devices_status == STATUS_ABORTED) break;
2840 if (data.devices_status == STATUS_QUIT) break;
2841 if (data.devices_status == STATUS_BYPASS) break;
2842
2843 uint innerloop_left = innerloop_cnt - innerloop_pos;
2844
2845 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2846
2847 device_param->innerloop_pos = innerloop_pos;
2848 device_param->innerloop_left = innerloop_left;
2849
2850 device_param->kernel_params_buf32[27] = innerloop_left;
2851
2852 if (innerloop_left == 0) continue;
2853
2854 // initialize amplifiers
2855
2856 if (data.attack_mode == ATTACK_MODE_COMBI)
2857 {
2858 char line_buf[BUFSIZ] = { 0 };
2859
2860 uint i = 0;
2861
2862 while (i < innerloop_left)
2863 {
2864 if (feof (combs_fp)) break;
2865
2866 int line_len = fgetl (combs_fp, line_buf);
2867
2868 if (line_len >= PW_MAX1) continue;
2869
2870 line_len = convert_from_hex (line_buf, line_len);
2871
2872 char *line_buf_new = line_buf;
2873
2874 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2875 {
2876 char rule_buf_out[BLOCK_SIZE] = { 0 };
2877
2878 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2879
2880 if (rule_len_out < 0)
2881 {
2882 data.words_progress_rejected[salt_pos] += pw_cnt;
2883
2884 continue;
2885 }
2886
2887 line_len = rule_len_out;
2888
2889 line_buf_new = rule_buf_out;
2890 }
2891
2892 line_len = MIN (line_len, PW_DICTMAX);
2893
2894 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2895
2896 memcpy (ptr, line_buf_new, line_len);
2897
2898 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2899
2900 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2901 {
2902 uppercase (ptr, line_len);
2903 }
2904
2905 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2906 {
2907 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2908 {
2909 ptr[line_len] = 0x80;
2910 }
2911
2912 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2913 {
2914 ptr[line_len] = 0x01;
2915 }
2916 }
2917
2918 device_param->combs_buf[i].pw_len = line_len;
2919
2920 i++;
2921 }
2922
2923 for (uint j = i; j < innerloop_left; j++)
2924 {
2925 device_param->combs_buf[j].i[0] = 0;
2926 device_param->combs_buf[j].i[1] = 0;
2927 device_param->combs_buf[j].i[2] = 0;
2928 device_param->combs_buf[j].i[3] = 0;
2929 device_param->combs_buf[j].i[4] = 0;
2930 device_param->combs_buf[j].i[5] = 0;
2931 device_param->combs_buf[j].i[6] = 0;
2932 device_param->combs_buf[j].i[7] = 0;
2933
2934 device_param->combs_buf[j].pw_len = 0;
2935 }
2936
2937 innerloop_left = i;
2938 }
2939 else if (data.attack_mode == ATTACK_MODE_BF)
2940 {
2941 u64 off = innerloop_pos;
2942
2943 device_param->kernel_params_mp_r_buf64[3] = off;
2944
2945 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2946 }
2947 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2948 {
2949 u64 off = innerloop_pos;
2950
2951 device_param->kernel_params_mp_buf64[3] = off;
2952
2953 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2954 }
2955 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2956 {
2957 u64 off = innerloop_pos;
2958
2959 device_param->kernel_params_mp_buf64[3] = off;
2960
2961 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2962 }
2963
2964 // copy amplifiers
2965
2966 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2967 {
2968 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);
2969 }
2970 else if (data.attack_mode == ATTACK_MODE_COMBI)
2971 {
2972 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);
2973 }
2974 else if (data.attack_mode == ATTACK_MODE_BF)
2975 {
2976 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);
2977 }
2978 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2979 {
2980 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);
2981 }
2982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2983 {
2984 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);
2985 }
2986
2987 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2988 {
2989 if (data.attack_mode == ATTACK_MODE_BF)
2990 {
2991 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2992 {
2993 const uint size_tm = 32 * sizeof (bs_word_t);
2994
2995 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2996
2997 run_kernel_tm (device_param);
2998
2999 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);
3000 }
3001 }
3002
3003 if (highest_pw_len < 16)
3004 {
3005 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3006 }
3007 else if (highest_pw_len < 32)
3008 {
3009 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3010 }
3011 else
3012 {
3013 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3014 }
3015 }
3016 else
3017 {
3018 run_kernel_amp (device_param, pws_cnt);
3019
3020 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3021
3022 if (data.opts_type & OPTS_TYPE_HOOK12)
3023 {
3024 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3025 }
3026
3027 uint iter = salt_buf->salt_iter;
3028
3029 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
3030 {
3031 uint loop_left = iter - loop_pos;
3032
3033 loop_left = MIN (loop_left, kernel_loops);
3034
3035 device_param->kernel_params_buf32[25] = loop_pos;
3036 device_param->kernel_params_buf32[26] = loop_left;
3037
3038 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3039
3040 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3041
3042 if (data.devices_status == STATUS_CRACKED) break;
3043 if (data.devices_status == STATUS_ABORTED) break;
3044 if (data.devices_status == STATUS_QUIT) break;
3045 }
3046
3047 if (data.opts_type & OPTS_TYPE_HOOK23)
3048 {
3049 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3050
3051 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);
3052
3053 // do something with data
3054
3055 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);
3056 }
3057
3058 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3059 }
3060
3061 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3062
3063 if (data.devices_status == STATUS_CRACKED) break;
3064 if (data.devices_status == STATUS_ABORTED) break;
3065 if (data.devices_status == STATUS_QUIT) break;
3066
3067 /**
3068 * result
3069 */
3070
3071 hc_thread_mutex_lock (mux_display);
3072
3073 check_cracked (device_param, salt_pos);
3074
3075 hc_thread_mutex_unlock (mux_display);
3076
3077 /**
3078 * progress
3079 */
3080
3081 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3082
3083 hc_thread_mutex_lock (mux_counter);
3084
3085 data.words_progress_done[salt_pos] += perf_sum_all;
3086
3087 hc_thread_mutex_unlock (mux_counter);
3088
3089 /**
3090 * speed
3091 */
3092
3093 float speed_ms;
3094
3095 hc_timer_get (device_param->timer_speed, speed_ms);
3096
3097 hc_timer_set (&device_param->timer_speed);
3098
3099 hc_thread_mutex_lock (mux_display);
3100
3101 device_param->speed_cnt[speed_pos] = perf_sum_all;
3102
3103 device_param->speed_ms[speed_pos] = speed_ms;
3104
3105 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3106
3107 hc_thread_mutex_unlock (mux_display);
3108
3109 speed_pos++;
3110
3111 if (speed_pos == SPEED_CACHE)
3112 {
3113 speed_pos = 0;
3114 }
3115 }
3116 }
3117
3118 device_param->speed_pos = speed_pos;
3119 }
3120
3121 static void load_segment (wl_data_t *wl_data, FILE *fd)
3122 {
3123 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3124
3125 wl_data->pos = 0;
3126
3127 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3128
3129 wl_data->buf[wl_data->cnt] = 0;
3130
3131 if (wl_data->cnt == 0) return;
3132
3133 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3134
3135 while (!feof (fd))
3136 {
3137 if (wl_data->cnt == wl_data->avail)
3138 {
3139 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3140
3141 wl_data->avail += wl_data->incr;
3142 }
3143
3144 const int c = fgetc (fd);
3145
3146 if (c == EOF) break;
3147
3148 wl_data->buf[wl_data->cnt] = (char) c;
3149
3150 wl_data->cnt++;
3151
3152 if (c == '\n') break;
3153 }
3154
3155 // ensure stream ends with a newline
3156
3157 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3158 {
3159 wl_data->cnt++;
3160
3161 wl_data->buf[wl_data->cnt - 1] = '\n';
3162 }
3163
3164 return;
3165 }
3166
3167 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3168 {
3169 char *ptr = buf;
3170
3171 for (u32 i = 0; i < sz; i++, ptr++)
3172 {
3173 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3174
3175 if (i == 7)
3176 {
3177 *off = i;
3178 *len = i;
3179
3180 return;
3181 }
3182
3183 if (*ptr != '\n') continue;
3184
3185 *off = i + 1;
3186
3187 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3188
3189 *len = i;
3190
3191 return;
3192 }
3193
3194 *off = sz;
3195 *len = sz;
3196 }
3197
3198 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3199 {
3200 char *ptr = buf;
3201
3202 for (u32 i = 0; i < sz; i++, ptr++)
3203 {
3204 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3205
3206 if (*ptr != '\n') continue;
3207
3208 *off = i + 1;
3209
3210 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3211
3212 *len = i;
3213
3214 return;
3215 }
3216
3217 *off = sz;
3218 *len = sz;
3219 }
3220
3221 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3222 {
3223 char *ptr = buf;
3224
3225 for (u32 i = 0; i < sz; i++, ptr++)
3226 {
3227 if (*ptr != '\n') continue;
3228
3229 *off = i + 1;
3230
3231 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3232
3233 *len = i;
3234
3235 return;
3236 }
3237
3238 *off = sz;
3239 *len = sz;
3240 }
3241
3242 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3243 {
3244 while (wl_data->pos < wl_data->cnt)
3245 {
3246 uint off;
3247 uint len;
3248
3249 char *ptr = wl_data->buf + wl_data->pos;
3250
3251 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3252
3253 wl_data->pos += off;
3254
3255 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3256 {
3257 char rule_buf_out[BLOCK_SIZE] = { 0 };
3258
3259 int rule_len_out = -1;
3260
3261 if (len < BLOCK_SIZE)
3262 {
3263 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3264 }
3265
3266 if (rule_len_out < 0)
3267 {
3268 continue;
3269 }
3270
3271 if (rule_len_out > PW_MAX)
3272 {
3273 continue;
3274 }
3275 }
3276 else
3277 {
3278 if (len > PW_MAX)
3279 {
3280 continue;
3281 }
3282 }
3283
3284 *out_buf = ptr;
3285 *out_len = len;
3286
3287 return;
3288 }
3289
3290 if (feof (fd))
3291 {
3292 fprintf (stderr, "bug!!\n");
3293
3294 return;
3295 }
3296
3297 load_segment (wl_data, fd);
3298
3299 get_next_word (wl_data, fd, out_buf, out_len);
3300 }
3301
3302 #ifdef _POSIX
3303 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3304 #endif
3305
3306 #ifdef _WIN
3307 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3308 #endif
3309 {
3310 hc_signal (NULL);
3311
3312 dictstat_t d;
3313
3314 d.cnt = 0;
3315
3316 #ifdef _POSIX
3317 fstat (fileno (fd), &d.stat);
3318 #endif
3319
3320 #ifdef _WIN
3321 _fstat64 (fileno (fd), &d.stat);
3322 #endif
3323
3324 d.stat.st_mode = 0;
3325 d.stat.st_nlink = 0;
3326 d.stat.st_uid = 0;
3327 d.stat.st_gid = 0;
3328 d.stat.st_rdev = 0;
3329 d.stat.st_atime = 0;
3330
3331 #ifdef _POSIX
3332 d.stat.st_blksize = 0;
3333 d.stat.st_blocks = 0;
3334 #endif
3335
3336 if (d.stat.st_size == 0) return 0;
3337
3338 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3339
3340 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3341 {
3342 if (d_cache)
3343 {
3344 u64 cnt = d_cache->cnt;
3345
3346 u64 keyspace = cnt;
3347
3348 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3349 {
3350 keyspace *= data.kernel_rules_cnt;
3351 }
3352 else if (data.attack_kern == ATTACK_KERN_COMBI)
3353 {
3354 keyspace *= data.combs_cnt;
3355 }
3356
3357 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);
3358 if (data.quiet == 0) log_info ("");
3359
3360 hc_signal (sigHandler_default);
3361
3362 return (keyspace);
3363 }
3364 }
3365
3366 time_t now = 0;
3367 time_t prev = 0;
3368
3369 u64 comp = 0;
3370 u64 cnt = 0;
3371 u64 cnt2 = 0;
3372
3373 while (!feof (fd))
3374 {
3375 load_segment (wl_data, fd);
3376
3377 comp += wl_data->cnt;
3378
3379 u32 i = 0;
3380
3381 while (i < wl_data->cnt)
3382 {
3383 u32 len;
3384 u32 off;
3385
3386 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3387
3388 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3389 {
3390 char rule_buf_out[BLOCK_SIZE] = { 0 };
3391
3392 int rule_len_out = -1;
3393
3394 if (len < BLOCK_SIZE)
3395 {
3396 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3397 }
3398
3399 if (rule_len_out < 0)
3400 {
3401 len = PW_MAX1;
3402 }
3403 else
3404 {
3405 len = rule_len_out;
3406 }
3407 }
3408
3409 if (len < PW_MAX1)
3410 {
3411 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3412 {
3413 cnt += data.kernel_rules_cnt;
3414 }
3415 else if (data.attack_kern == ATTACK_KERN_COMBI)
3416 {
3417 cnt += data.combs_cnt;
3418 }
3419
3420 d.cnt++;
3421 }
3422
3423 i += off;
3424
3425 cnt2++;
3426 }
3427
3428 time (&now);
3429
3430 if ((now - prev) == 0) continue;
3431
3432 float percent = (float) comp / (float) d.stat.st_size;
3433
3434 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);
3435
3436 time (&prev);
3437 }
3438
3439 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);
3440 if (data.quiet == 0) log_info ("");
3441
3442 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3443
3444 hc_signal (sigHandler_default);
3445
3446 return (cnt);
3447 }
3448
3449 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3450 {
3451 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3452 }
3453
3454 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3455 {
3456 if (data.devices_status == STATUS_BYPASS) return 0;
3457
3458 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3459
3460 uint cache_cnt = pw_cache->cnt;
3461
3462 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3463
3464 memcpy (pw_hc1, pw_buf, pw_len);
3465
3466 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3467
3468 uint pws_cnt = device_param->pws_cnt;
3469
3470 cache_cnt++;
3471
3472 pw_t *pw = device_param->pws_buf + pws_cnt;
3473
3474 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3475
3476 pw->pw_len = pw_len;
3477
3478 pws_cnt++;
3479
3480 device_param->pws_cnt = pws_cnt;
3481 device_param->pw_cnt = pws_cnt * 1;
3482
3483 cache_cnt = 0;
3484
3485 pw_cache->cnt = cache_cnt;
3486
3487 return pws_cnt;
3488 }
3489
3490 static void *thread_monitor (void *p)
3491 {
3492 uint runtime_check = 0;
3493 uint remove_check = 0;
3494 uint status_check = 0;
3495 uint restore_check = 0;
3496
3497 uint restore_left = data.restore_timer;
3498 uint remove_left = data.remove_timer;
3499 uint status_left = data.status_timer;
3500
3501 #ifdef HAVE_HWMON
3502 uint hwmon_check = 0;
3503
3504 // these variables are mainly used for fan control (AMD only)
3505
3506 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3507
3508 // temperature controller "loopback" values
3509
3510 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3511 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3512
3513 #ifdef HAVE_ADL
3514 int temp_threshold = 1; // degrees celcius
3515
3516 int fan_speed_min = 15; // in percentage
3517 int fan_speed_max = 100;
3518 #endif // HAVE_ADL
3519
3520 time_t last_temp_check_time;
3521 #endif // HAVE_HWMON
3522
3523 uint sleep_time = 1;
3524
3525 if (data.runtime)
3526 {
3527 runtime_check = 1;
3528 }
3529
3530 if (data.restore_timer)
3531 {
3532 restore_check = 1;
3533 }
3534
3535 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3536 {
3537 remove_check = 1;
3538 }
3539
3540 if (data.status == 1)
3541 {
3542 status_check = 1;
3543 }
3544
3545 #ifdef HAVE_HWMON
3546 if (data.gpu_temp_disable == 0)
3547 {
3548 time (&last_temp_check_time);
3549
3550 hwmon_check = 1;
3551 }
3552 #endif
3553
3554 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3555 {
3556 #ifdef HAVE_HWMON
3557 if (hwmon_check == 0)
3558 #endif
3559 return (p);
3560 }
3561
3562 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3563 {
3564 hc_sleep (sleep_time);
3565
3566 if (data.devices_status != STATUS_RUNNING) continue;
3567
3568 #ifdef HAVE_HWMON
3569 if (hwmon_check == 1)
3570 {
3571 hc_thread_mutex_lock (mux_adl);
3572
3573 time_t temp_check_time;
3574
3575 time (&temp_check_time);
3576
3577 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3578
3579 if (Ta == 0) Ta = 1;
3580
3581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3582 {
3583 hc_device_param_t *device_param = &data.devices_param[device_id];
3584
3585 if (device_param->skipped) continue;
3586
3587 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3588
3589 const int temperature = hm_get_temperature_with_device_id (device_id);
3590
3591 if (temperature > (int) data.gpu_temp_abort)
3592 {
3593 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3594
3595 if (data.devices_status != STATUS_QUIT) myabort ();
3596
3597 break;
3598 }
3599
3600 #ifdef HAVE_ADL
3601 const int gpu_temp_retain = data.gpu_temp_retain;
3602
3603 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3604 {
3605 if (data.hm_device[device_id].fan_supported == 1)
3606 {
3607 int temp_cur = temperature;
3608
3609 int temp_diff_new = gpu_temp_retain - temp_cur;
3610
3611 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3612
3613 // calculate Ta value (time difference in seconds between the last check and this check)
3614
3615 last_temp_check_time = temp_check_time;
3616
3617 float Kp = 1.8;
3618 float Ki = 0.005;
3619 float Kd = 6;
3620
3621 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3622
3623 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);
3624
3625 if (abs (fan_diff_required) >= temp_threshold)
3626 {
3627 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3628
3629 int fan_speed_level = fan_speed_cur;
3630
3631 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3632
3633 int fan_speed_new = fan_speed_level - fan_diff_required;
3634
3635 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3636 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3637
3638 if (fan_speed_new != fan_speed_cur)
3639 {
3640 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3641 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3642
3643 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3644 {
3645 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3646
3647 fan_speed_chgd[device_id] = 1;
3648 }
3649
3650 temp_diff_old[device_id] = temp_diff_new;
3651 }
3652 }
3653 }
3654 }
3655 #endif // HAVE_ADL
3656 }
3657
3658 hc_thread_mutex_unlock (mux_adl);
3659 }
3660 #endif // HAVE_HWMON
3661
3662 if (restore_check == 1)
3663 {
3664 restore_left--;
3665
3666 if (restore_left == 0)
3667 {
3668 if (data.restore_disable == 0) cycle_restore ();
3669
3670 restore_left = data.restore_timer;
3671 }
3672 }
3673
3674 if ((runtime_check == 1) && (data.runtime_start > 0))
3675 {
3676 time_t runtime_cur;
3677
3678 time (&runtime_cur);
3679
3680 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3681
3682 if (runtime_left <= 0)
3683 {
3684 if (data.benchmark == 0)
3685 {
3686 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3687 }
3688
3689 if (data.devices_status != STATUS_QUIT) myabort ();
3690 }
3691 }
3692
3693 if (remove_check == 1)
3694 {
3695 remove_left--;
3696
3697 if (remove_left == 0)
3698 {
3699 if (data.digests_saved != data.digests_done)
3700 {
3701 data.digests_saved = data.digests_done;
3702
3703 save_hash ();
3704 }
3705
3706 remove_left = data.remove_timer;
3707 }
3708 }
3709
3710 if (status_check == 1)
3711 {
3712 status_left--;
3713
3714 if (status_left == 0)
3715 {
3716 hc_thread_mutex_lock (mux_display);
3717
3718 if (data.quiet == 0) clear_prompt ();
3719
3720 if (data.quiet == 0) log_info ("");
3721
3722 status_display ();
3723
3724 if (data.quiet == 0) log_info ("");
3725
3726 hc_thread_mutex_unlock (mux_display);
3727
3728 status_left = data.status_timer;
3729 }
3730 }
3731 }
3732
3733 #ifdef HAVE_HWMON
3734 myfree (fan_speed_chgd);
3735
3736 myfree (temp_diff_old);
3737 myfree (temp_diff_sum);
3738 #endif
3739
3740 p = NULL;
3741
3742 return (p);
3743 }
3744
3745 static void *thread_outfile_remove (void *p)
3746 {
3747 // some hash-dependent constants
3748 char *outfile_dir = data.outfile_check_directory;
3749 uint dgst_size = data.dgst_size;
3750 uint isSalted = data.isSalted;
3751 uint esalt_size = data.esalt_size;
3752 uint hash_mode = data.hash_mode;
3753
3754 uint outfile_check_timer = data.outfile_check_timer;
3755
3756 char separator = data.separator;
3757
3758 // some hash-dependent functions
3759 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3760 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3761
3762 // buffers
3763 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3764
3765 hash_buf.digest = mymalloc (dgst_size);
3766
3767 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3768
3769 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3770
3771 uint digest_buf[64] = { 0 };
3772
3773 outfile_data_t *out_info = NULL;
3774
3775 char **out_files = NULL;
3776
3777 time_t folder_mtime = 0;
3778
3779 int out_cnt = 0;
3780
3781 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3782
3783 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3784 {
3785 hc_sleep (1);
3786
3787 if (data.devices_status != STATUS_RUNNING) continue;
3788
3789 check_left--;
3790
3791 if (check_left == 0)
3792 {
3793 struct stat outfile_check_stat;
3794
3795 if (stat (outfile_dir, &outfile_check_stat) == 0)
3796 {
3797 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3798
3799 if (is_dir == 1)
3800 {
3801 if (outfile_check_stat.st_mtime > folder_mtime)
3802 {
3803 char **out_files_new = scan_directory (outfile_dir);
3804
3805 int out_cnt_new = count_dictionaries (out_files_new);
3806
3807 outfile_data_t *out_info_new = NULL;
3808
3809 if (out_cnt_new > 0)
3810 {
3811 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3812
3813 for (int i = 0; i < out_cnt_new; i++)
3814 {
3815 out_info_new[i].file_name = out_files_new[i];
3816
3817 // check if there are files that we have seen/checked before (and not changed)
3818
3819 for (int j = 0; j < out_cnt; j++)
3820 {
3821 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3822 {
3823 struct stat outfile_stat;
3824
3825 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3826 {
3827 if (outfile_stat.st_ctime == out_info[j].ctime)
3828 {
3829 out_info_new[i].ctime = out_info[j].ctime;
3830 out_info_new[i].seek = out_info[j].seek;
3831 }
3832 }
3833 }
3834 }
3835 }
3836 }
3837
3838 local_free (out_info);
3839 local_free (out_files);
3840
3841 out_files = out_files_new;
3842 out_cnt = out_cnt_new;
3843 out_info = out_info_new;
3844
3845 folder_mtime = outfile_check_stat.st_mtime;
3846 }
3847
3848 for (int j = 0; j < out_cnt; j++)
3849 {
3850 FILE *fp = fopen (out_info[j].file_name, "rb");
3851
3852 if (fp != NULL)
3853 {
3854 //hc_thread_mutex_lock (mux_display);
3855
3856 #ifdef _POSIX
3857 struct stat outfile_stat;
3858
3859 fstat (fileno (fp), &outfile_stat);
3860 #endif
3861
3862 #ifdef _WIN
3863 struct stat64 outfile_stat;
3864
3865 _fstat64 (fileno (fp), &outfile_stat);
3866 #endif
3867
3868 if (outfile_stat.st_ctime > out_info[j].ctime)
3869 {
3870 out_info[j].ctime = outfile_stat.st_ctime;
3871 out_info[j].seek = 0;
3872 }
3873
3874 fseek (fp, out_info[j].seek, SEEK_SET);
3875
3876 while (!feof (fp))
3877 {
3878 char line_buf[BUFSIZ] = { 0 };
3879
3880 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3881
3882 if (ptr == NULL) break;
3883
3884 int line_len = strlen (line_buf);
3885
3886 if (line_len <= 0) continue;
3887
3888 int iter = MAX_CUT_TRIES;
3889
3890 for (uint i = line_len - 1; i && iter; i--, line_len--)
3891 {
3892 if (line_buf[i] != separator) continue;
3893
3894 int parser_status = PARSER_OK;
3895
3896 if ((hash_mode != 2500) && (hash_mode != 6800))
3897 {
3898 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3899 }
3900
3901 uint found = 0;
3902
3903 if (parser_status == PARSER_OK)
3904 {
3905 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3906 {
3907 if (data.salts_shown[salt_pos] == 1) continue;
3908
3909 salt_t *salt_buf = &data.salts_buf[salt_pos];
3910
3911 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3912 {
3913 uint idx = salt_buf->digests_offset + digest_pos;
3914
3915 if (data.digests_shown[idx] == 1) continue;
3916
3917 uint cracked = 0;
3918
3919 if (hash_mode == 6800)
3920 {
3921 if (i == salt_buf->salt_len)
3922 {
3923 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3924 }
3925 }
3926 else if (hash_mode == 2500)
3927 {
3928 // BSSID : MAC1 : MAC2 (:plain)
3929 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3930 {
3931 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3932
3933 if (!cracked) continue;
3934
3935 // now compare MAC1 and MAC2 too, since we have this additional info
3936 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3937 char *mac2_pos = mac1_pos + 12 + 1;
3938
3939 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3940 wpa_t *wpa = &wpas[salt_pos];
3941
3942 uint pke[25] = { 0 };
3943
3944 char *pke_ptr = (char *) pke;
3945
3946 for (uint i = 0; i < 25; i++)
3947 {
3948 pke[i] = byte_swap_32 (wpa->pke[i]);
3949 }
3950
3951 u8 mac1[6] = { 0 };
3952 u8 mac2[6] = { 0 };
3953
3954 memcpy (mac1, pke_ptr + 23, 6);
3955 memcpy (mac2, pke_ptr + 29, 6);
3956
3957 // compare hex string(s) vs binary MAC address(es)
3958
3959 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3960 {
3961 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3962 {
3963 cracked = 0;
3964 break;
3965 }
3966 }
3967
3968 // early skip ;)
3969 if (!cracked) continue;
3970
3971 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3972 {
3973 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3974 {
3975 cracked = 0;
3976 break;
3977 }
3978 }
3979 }
3980 }
3981 else
3982 {
3983 char *digests_buf_ptr = (char *) data.digests_buf;
3984
3985 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3986
3987 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3988 }
3989
3990 if (cracked == 1)
3991 {
3992 found = 1;
3993
3994 data.digests_shown[idx] = 1;
3995
3996 data.digests_done++;
3997
3998 salt_buf->digests_done++;
3999
4000 if (salt_buf->digests_done == salt_buf->digests_cnt)
4001 {
4002 data.salts_shown[salt_pos] = 1;
4003
4004 data.salts_done++;
4005
4006 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4007 }
4008 }
4009 }
4010
4011 if (data.devices_status == STATUS_CRACKED) break;
4012 }
4013 }
4014
4015 if (found) break;
4016
4017 if (data.devices_status == STATUS_CRACKED) break;
4018
4019 iter--;
4020 }
4021
4022 if (data.devices_status == STATUS_CRACKED) break;
4023 }
4024
4025 out_info[j].seek = ftell (fp);
4026
4027 //hc_thread_mutex_unlock (mux_display);
4028
4029 fclose (fp);
4030 }
4031 }
4032 }
4033 }
4034
4035 check_left = outfile_check_timer;
4036 }
4037 }
4038
4039 if (esalt_size) local_free (hash_buf.esalt);
4040
4041 if (isSalted) local_free (hash_buf.salt);
4042
4043 local_free (hash_buf.digest);
4044
4045 local_free (out_info);
4046
4047 local_free (out_files);
4048
4049 p = NULL;
4050
4051 return (p);
4052 }
4053
4054 static uint get_work (hc_device_param_t *device_param, const u64 max)
4055 {
4056 hc_thread_mutex_lock (mux_dispatcher);
4057
4058 const u64 words_cur = data.words_cur;
4059 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4060
4061 device_param->words_off = words_cur;
4062
4063 const u64 words_left = words_base - words_cur;
4064
4065 if (data.kernel_blocks_all > words_left)
4066 {
4067 if (data.kernel_blocks_div == 0)
4068 {
4069 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4070 }
4071 }
4072
4073 if (data.kernel_blocks_div)
4074 {
4075 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4076 {
4077 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4078 const u32 kernel_power_new = kernel_blocks_new;
4079
4080 if (kernel_blocks_new < device_param->kernel_blocks)
4081 {
4082 device_param->kernel_blocks = kernel_blocks_new;
4083 device_param->kernel_power = kernel_power_new;
4084 }
4085 }
4086 }
4087
4088 const uint kernel_blocks = device_param->kernel_blocks;
4089
4090 uint work = MIN (words_left, kernel_blocks);
4091
4092 work = MIN (work, max);
4093
4094 data.words_cur += work;
4095
4096 hc_thread_mutex_unlock (mux_dispatcher);
4097
4098 return work;
4099 }
4100
4101 static void *thread_calc_stdin (void *p)
4102 {
4103 hc_device_param_t *device_param = (hc_device_param_t *) p;
4104
4105 if (device_param->skipped) return NULL;
4106
4107 const uint attack_kern = data.attack_kern;
4108
4109 const uint kernel_blocks = device_param->kernel_blocks;
4110
4111 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4112 {
4113 hc_thread_mutex_lock (mux_dispatcher);
4114
4115 if (feof (stdin) != 0)
4116 {
4117 hc_thread_mutex_unlock (mux_dispatcher);
4118
4119 break;
4120 }
4121
4122 uint words_cur = 0;
4123
4124 while (words_cur < kernel_blocks)
4125 {
4126 char buf[BUFSIZ] = { 0 };
4127
4128 char *line_buf = fgets (buf, sizeof (buf), stdin);
4129
4130 if (line_buf == NULL) break;
4131
4132 uint line_len = in_superchop (line_buf);
4133
4134 line_len = convert_from_hex (line_buf, line_len);
4135
4136 // post-process rule engine
4137
4138 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4139 {
4140 char rule_buf_out[BLOCK_SIZE] = { 0 };
4141
4142 int rule_len_out = -1;
4143
4144 if (line_len < BLOCK_SIZE)
4145 {
4146 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4147 }
4148
4149 if (rule_len_out < 0) continue;
4150
4151 line_buf = rule_buf_out;
4152 line_len = rule_len_out;
4153 }
4154
4155 if (line_len > PW_MAX)
4156 {
4157 continue;
4158 }
4159
4160 if (attack_kern == ATTACK_KERN_STRAIGHT)
4161 {
4162 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4163 {
4164 hc_thread_mutex_lock (mux_counter);
4165
4166 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4167 {
4168 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4169 }
4170
4171 hc_thread_mutex_unlock (mux_counter);
4172
4173 continue;
4174 }
4175 }
4176 else if (attack_kern == ATTACK_KERN_COMBI)
4177 {
4178 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4179 // since we still need to combine the plains
4180
4181 if (line_len > data.pw_max)
4182 {
4183 hc_thread_mutex_lock (mux_counter);
4184
4185 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4186 {
4187 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4188 }
4189
4190 hc_thread_mutex_unlock (mux_counter);
4191
4192 continue;
4193 }
4194 }
4195
4196 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4197
4198 words_cur++;
4199
4200 if (data.devices_status == STATUS_CRACKED) break;
4201 if (data.devices_status == STATUS_ABORTED) break;
4202 if (data.devices_status == STATUS_QUIT) break;
4203 if (data.devices_status == STATUS_BYPASS) break;
4204 }
4205
4206 hc_thread_mutex_unlock (mux_dispatcher);
4207
4208 if (data.devices_status == STATUS_CRACKED) break;
4209 if (data.devices_status == STATUS_ABORTED) break;
4210 if (data.devices_status == STATUS_QUIT) break;
4211 if (data.devices_status == STATUS_BYPASS) break;
4212
4213 // we need 2 flushing because we have two independant caches and it can occur
4214 // that one buffer is already at threshold plus for that length also exists
4215 // more data in the 2nd buffer so it would overflow
4216
4217 // flush session 1
4218
4219 {
4220 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4221 {
4222 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4223
4224 const uint pw_cache_cnt = pw_cache->cnt;
4225
4226 if (pw_cache_cnt == 0) continue;
4227
4228 pw_cache->cnt = 0;
4229
4230 uint pws_cnt = device_param->pws_cnt;
4231
4232 pw_t *pw = device_param->pws_buf + pws_cnt;
4233
4234 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4235
4236 pw->pw_len = pw_len;
4237
4238 uint pw_cnt = device_param->pw_cnt;
4239
4240 pw_cnt += pw_cache_cnt;
4241
4242 device_param->pw_cnt = pw_cnt;
4243
4244 pws_cnt++;
4245
4246 device_param->pws_cnt = pws_cnt;
4247
4248 if (pws_cnt == device_param->kernel_power_user) break;
4249 }
4250
4251 const uint pw_cnt = device_param->pw_cnt;
4252 const uint pws_cnt = device_param->pws_cnt;
4253
4254 if (pws_cnt)
4255 {
4256 run_copy (device_param, pws_cnt);
4257
4258 run_cracker (device_param, pw_cnt, pws_cnt);
4259
4260 device_param->pw_cnt = 0;
4261 device_param->pws_cnt = 0;
4262 }
4263 }
4264
4265 // flush session 2
4266
4267 {
4268 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4269 {
4270 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4271
4272 const uint pw_cache_cnt = pw_cache->cnt;
4273
4274 if (pw_cache_cnt == 0) continue;
4275
4276 pw_cache->cnt = 0;
4277
4278 uint pws_cnt = device_param->pws_cnt;
4279
4280 pw_t *pw = device_param->pws_buf + pws_cnt;
4281
4282 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4283
4284 pw->pw_len = pw_len;
4285
4286 uint pw_cnt = device_param->pw_cnt;
4287
4288 pw_cnt += pw_cache_cnt;
4289
4290 device_param->pw_cnt = pw_cnt;
4291
4292 pws_cnt++;
4293
4294 device_param->pws_cnt = pws_cnt;
4295 }
4296
4297 const uint pw_cnt = device_param->pw_cnt;
4298 const uint pws_cnt = device_param->pws_cnt;
4299
4300 if (pws_cnt)
4301 {
4302 run_copy (device_param, pws_cnt);
4303
4304 run_cracker (device_param, pw_cnt, pws_cnt);
4305
4306 device_param->pw_cnt = 0;
4307 device_param->pws_cnt = 0;
4308 }
4309 }
4310 }
4311
4312 return NULL;
4313 }
4314
4315 static void *thread_calc (void *p)
4316 {
4317 hc_device_param_t *device_param = (hc_device_param_t *) p;
4318
4319 if (device_param->skipped) return NULL;
4320
4321 const uint attack_mode = data.attack_mode;
4322 const uint attack_kern = data.attack_kern;
4323
4324 if (attack_mode == ATTACK_MODE_BF)
4325 {
4326 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4327 {
4328 const uint work = get_work (device_param, -1);
4329
4330 if (work == 0) break;
4331
4332 const u64 words_off = device_param->words_off;
4333 const u64 words_fin = words_off + work;
4334
4335 const uint pw_cnt = work;
4336 const uint pws_cnt = work;
4337
4338 device_param->pw_cnt = pw_cnt;
4339 device_param->pws_cnt = pws_cnt;
4340
4341 if (pws_cnt)
4342 {
4343 run_copy (device_param, pws_cnt);
4344
4345 run_cracker (device_param, pw_cnt, pws_cnt);
4346
4347 device_param->pw_cnt = 0;
4348 device_param->pws_cnt = 0;
4349 }
4350
4351 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4352
4353 if (data.devices_status == STATUS_CRACKED) break;
4354 if (data.devices_status == STATUS_ABORTED) break;
4355 if (data.devices_status == STATUS_QUIT) break;
4356 if (data.devices_status == STATUS_BYPASS) break;
4357
4358 device_param->words_done = words_fin;
4359 }
4360 }
4361 else
4362 {
4363 const uint segment_size = data.segment_size;
4364
4365 char *dictfile = data.dictfile;
4366
4367 if (attack_mode == ATTACK_MODE_COMBI)
4368 {
4369 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4370 {
4371 dictfile = data.dictfile2;
4372 }
4373 }
4374
4375 FILE *fd = fopen (dictfile, "rb");
4376
4377 if (fd == NULL)
4378 {
4379 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4380
4381 return NULL;
4382 }
4383
4384 if (attack_mode == ATTACK_MODE_COMBI)
4385 {
4386 const uint combs_mode = data.combs_mode;
4387
4388 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4389 {
4390 const char *dictfilec = data.dictfile2;
4391
4392 FILE *combs_fp = fopen (dictfilec, "rb");
4393
4394 if (combs_fp == NULL)
4395 {
4396 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4397
4398 fclose (fd);
4399
4400 return NULL;
4401 }
4402
4403 device_param->combs_fp = combs_fp;
4404 }
4405 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4406 {
4407 const char *dictfilec = data.dictfile;
4408
4409 FILE *combs_fp = fopen (dictfilec, "rb");
4410
4411 if (combs_fp == NULL)
4412 {
4413 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4414
4415 fclose (fd);
4416
4417 return NULL;
4418 }
4419
4420 device_param->combs_fp = combs_fp;
4421 }
4422 }
4423
4424 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4425
4426 wl_data->buf = (char *) mymalloc (segment_size);
4427 wl_data->avail = segment_size;
4428 wl_data->incr = segment_size;
4429 wl_data->cnt = 0;
4430 wl_data->pos = 0;
4431
4432 u64 words_cur = 0;
4433
4434 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4435 {
4436 u64 words_off = 0;
4437 u64 words_fin = 0;
4438
4439 u64 max = -1;
4440
4441 while (max)
4442 {
4443 const uint work = get_work (device_param, max);
4444
4445 if (work == 0) break;
4446
4447 words_off = device_param->words_off;
4448 words_fin = words_off + work;
4449
4450 char *line_buf;
4451 uint line_len;
4452
4453 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4454
4455 max = 0;
4456
4457 for ( ; words_cur < words_fin; words_cur++)
4458 {
4459 get_next_word (wl_data, fd, &line_buf, &line_len);
4460
4461 line_len = convert_from_hex (line_buf, line_len);
4462
4463 // post-process rule engine
4464
4465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4466 {
4467 char rule_buf_out[BLOCK_SIZE] = { 0 };
4468
4469 int rule_len_out = -1;
4470
4471 if (line_len < BLOCK_SIZE)
4472 {
4473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4474 }
4475
4476 if (rule_len_out < 0) continue;
4477
4478 line_buf = rule_buf_out;
4479 line_len = rule_len_out;
4480 }
4481
4482 if (attack_kern == ATTACK_KERN_STRAIGHT)
4483 {
4484 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4485 {
4486 max++;
4487
4488 hc_thread_mutex_lock (mux_counter);
4489
4490 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4491 {
4492 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4493 }
4494
4495 hc_thread_mutex_unlock (mux_counter);
4496
4497 continue;
4498 }
4499 }
4500 else if (attack_kern == ATTACK_KERN_COMBI)
4501 {
4502 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4503 // since we still need to combine the plains
4504
4505 if (line_len > data.pw_max)
4506 {
4507 max++;
4508
4509 hc_thread_mutex_lock (mux_counter);
4510
4511 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4512 {
4513 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4514 }
4515
4516 hc_thread_mutex_unlock (mux_counter);
4517
4518 continue;
4519 }
4520 }
4521
4522 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4523
4524 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4525
4526 if (data.devices_status == STATUS_CRACKED) break;
4527 if (data.devices_status == STATUS_ABORTED) break;
4528 if (data.devices_status == STATUS_QUIT) break;
4529 if (data.devices_status == STATUS_BYPASS) break;
4530 }
4531
4532 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4533
4534 if (data.devices_status == STATUS_CRACKED) break;
4535 if (data.devices_status == STATUS_ABORTED) break;
4536 if (data.devices_status == STATUS_QUIT) break;
4537 if (data.devices_status == STATUS_BYPASS) break;
4538 }
4539
4540 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4541
4542 if (data.devices_status == STATUS_CRACKED) break;
4543 if (data.devices_status == STATUS_ABORTED) break;
4544 if (data.devices_status == STATUS_QUIT) break;
4545 if (data.devices_status == STATUS_BYPASS) break;
4546
4547 // we need 2 flushing because we have two independant caches and it can occur
4548 // that one buffer is already at threshold plus for that length also exists
4549 // more data in the 2nd buffer so it would overflow
4550
4551 //
4552 // flush session 1
4553 //
4554
4555 {
4556 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4557 {
4558 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4559
4560 const uint pw_cache_cnt = pw_cache->cnt;
4561
4562 if (pw_cache_cnt == 0) continue;
4563
4564 pw_cache->cnt = 0;
4565
4566 uint pws_cnt = device_param->pws_cnt;
4567
4568 pw_t *pw = device_param->pws_buf + pws_cnt;
4569
4570 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4571
4572 pw->pw_len = pw_len;
4573
4574 uint pw_cnt = device_param->pw_cnt;
4575
4576 pw_cnt += pw_cache_cnt;
4577
4578 device_param->pw_cnt = pw_cnt;
4579
4580 pws_cnt++;
4581
4582 device_param->pws_cnt = pws_cnt;
4583
4584 if (pws_cnt == device_param->kernel_power_user) break;
4585 }
4586
4587 const uint pw_cnt = device_param->pw_cnt;
4588 const uint pws_cnt = device_param->pws_cnt;
4589
4590 if (pws_cnt)
4591 {
4592 run_copy (device_param, pws_cnt);
4593
4594 run_cracker (device_param, pw_cnt, pws_cnt);
4595
4596 device_param->pw_cnt = 0;
4597 device_param->pws_cnt = 0;
4598 }
4599
4600 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4601
4602 if (data.devices_status == STATUS_CRACKED) break;
4603 if (data.devices_status == STATUS_ABORTED) break;
4604 if (data.devices_status == STATUS_QUIT) break;
4605 if (data.devices_status == STATUS_BYPASS) break;
4606 }
4607
4608 //
4609 // flush session 2
4610 //
4611
4612 {
4613 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4614 {
4615 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4616
4617 const uint pw_cache_cnt = pw_cache->cnt;
4618
4619 if (pw_cache_cnt == 0) continue;
4620
4621 pw_cache->cnt = 0;
4622
4623 uint pws_cnt = device_param->pws_cnt;
4624
4625 pw_t *pw = device_param->pws_buf + pws_cnt;
4626
4627 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4628
4629 pw->pw_len = pw_len;
4630
4631 uint pw_cnt = device_param->pw_cnt;
4632
4633 pw_cnt += pw_cache_cnt;
4634
4635 device_param->pw_cnt = pw_cnt;
4636
4637 pws_cnt++;
4638
4639 device_param->pws_cnt = pws_cnt;
4640 }
4641
4642 const uint pw_cnt = device_param->pw_cnt;
4643 const uint pws_cnt = device_param->pws_cnt;
4644
4645 if (pws_cnt)
4646 {
4647 run_copy (device_param, pws_cnt);
4648
4649 run_cracker (device_param, pw_cnt, pws_cnt);
4650
4651 device_param->pw_cnt = 0;
4652 device_param->pws_cnt = 0;
4653 }
4654
4655 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4656
4657 if (data.devices_status == STATUS_CRACKED) break;
4658 if (data.devices_status == STATUS_ABORTED) break;
4659 if (data.devices_status == STATUS_QUIT) break;
4660 if (data.devices_status == STATUS_BYPASS) break;
4661 }
4662
4663 if (words_fin == 0) break;
4664
4665 device_param->words_done = words_fin;
4666 }
4667
4668 if (attack_mode == ATTACK_MODE_COMBI)
4669 {
4670 fclose (device_param->combs_fp);
4671 }
4672
4673 free (wl_data->buf);
4674 free (wl_data);
4675
4676 fclose (fd);
4677 }
4678
4679 return NULL;
4680 }
4681
4682 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4683 {
4684 if (!device_param)
4685 {
4686 log_error ("ERROR: %s : Invalid argument", __func__);
4687
4688 exit (-1);
4689 }
4690
4691 salt_t *salt_buf = &data.salts_buf[salt_pos];
4692
4693 device_param->kernel_params_buf32[24] = salt_pos;
4694 device_param->kernel_params_buf32[27] = 1;
4695 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4696 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4697 device_param->kernel_params_buf32[30] = 0;
4698 device_param->kernel_params_buf32[31] = 1;
4699
4700 char *dictfile_old = data.dictfile;
4701
4702 const char *weak_hash_check = "weak-hash-check";
4703
4704 data.dictfile = (char *) weak_hash_check;
4705
4706 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4707
4708 data.kernel_rules_buf[0].cmds[0] = 0;
4709
4710 /**
4711 * run the kernel
4712 */
4713
4714 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4715 {
4716 run_kernel (KERN_RUN_1, device_param, 1, false);
4717 }
4718 else
4719 {
4720 run_kernel (KERN_RUN_1, device_param, 1, false);
4721
4722 const uint iter = salt_buf->salt_iter;
4723
4724 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4725 {
4726 uint loop_left = iter - loop_pos;
4727
4728 loop_left = MIN (loop_left, kernel_loops);
4729
4730 device_param->kernel_params_buf32[25] = loop_pos;
4731 device_param->kernel_params_buf32[26] = loop_left;
4732
4733 run_kernel (KERN_RUN_2, device_param, 1, false);
4734 }
4735
4736 run_kernel (KERN_RUN_3, device_param, 1, false);
4737 }
4738
4739 /**
4740 * result
4741 */
4742
4743 check_cracked (device_param, salt_pos);
4744
4745 /**
4746 * cleanup
4747 */
4748
4749 device_param->kernel_params_buf32[24] = 0;
4750 device_param->kernel_params_buf32[25] = 0;
4751 device_param->kernel_params_buf32[26] = 0;
4752 device_param->kernel_params_buf32[27] = 0;
4753 device_param->kernel_params_buf32[28] = 0;
4754 device_param->kernel_params_buf32[29] = 0;
4755 device_param->kernel_params_buf32[30] = 0;
4756 device_param->kernel_params_buf32[31] = 0;
4757
4758 data.dictfile = dictfile_old;
4759
4760 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4761 }
4762
4763 // hlfmt hashcat
4764
4765 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4766 {
4767 if (data.username == 0)
4768 {
4769 *hashbuf_pos = line_buf;
4770 *hashbuf_len = line_len;
4771 }
4772 else
4773 {
4774 char *pos = line_buf;
4775 int len = line_len;
4776
4777 for (int i = 0; i < line_len; i++, pos++, len--)
4778 {
4779 if (line_buf[i] == data.separator)
4780 {
4781 pos++;
4782
4783 len--;
4784
4785 break;
4786 }
4787 }
4788
4789 *hashbuf_pos = pos;
4790 *hashbuf_len = len;
4791 }
4792 }
4793
4794 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4795 {
4796 char *pos = NULL;
4797 int len = 0;
4798
4799 int sep_cnt = 0;
4800
4801 for (int i = 0; i < line_len; i++)
4802 {
4803 if (line_buf[i] == data.separator)
4804 {
4805 sep_cnt++;
4806
4807 continue;
4808 }
4809
4810 if (sep_cnt == 0)
4811 {
4812 if (pos == NULL) pos = line_buf + i;
4813
4814 len++;
4815 }
4816 }
4817
4818 *userbuf_pos = pos;
4819 *userbuf_len = len;
4820 }
4821
4822 // hlfmt pwdump
4823
4824 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4825 {
4826 int sep_cnt = 0;
4827
4828 int sep2_len = 0;
4829 int sep3_len = 0;
4830
4831 for (int i = 0; i < line_len; i++)
4832 {
4833 if (line_buf[i] == ':')
4834 {
4835 sep_cnt++;
4836
4837 continue;
4838 }
4839
4840 if (sep_cnt == 2) sep2_len++;
4841 if (sep_cnt == 3) sep3_len++;
4842 }
4843
4844 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4845
4846 return 0;
4847 }
4848
4849 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4850 {
4851 char *pos = NULL;
4852 int len = 0;
4853
4854 int sep_cnt = 0;
4855
4856 for (int i = 0; i < line_len; i++)
4857 {
4858 if (line_buf[i] == ':')
4859 {
4860 sep_cnt++;
4861
4862 continue;
4863 }
4864
4865 if (data.hash_mode == 1000)
4866 {
4867 if (sep_cnt == 3)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874 else if (data.hash_mode == 3000)
4875 {
4876 if (sep_cnt == 2)
4877 {
4878 if (pos == NULL) pos = line_buf + i;
4879
4880 len++;
4881 }
4882 }
4883 }
4884
4885 *hashbuf_pos = pos;
4886 *hashbuf_len = len;
4887 }
4888
4889 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4890 {
4891 char *pos = NULL;
4892 int len = 0;
4893
4894 int sep_cnt = 0;
4895
4896 for (int i = 0; i < line_len; i++)
4897 {
4898 if (line_buf[i] == ':')
4899 {
4900 sep_cnt++;
4901
4902 continue;
4903 }
4904
4905 if (sep_cnt == 0)
4906 {
4907 if (pos == NULL) pos = line_buf + i;
4908
4909 len++;
4910 }
4911 }
4912
4913 *userbuf_pos = pos;
4914 *userbuf_len = len;
4915 }
4916
4917 // hlfmt passwd
4918
4919 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4920 {
4921 int sep_cnt = 0;
4922
4923 char sep5_first = 0;
4924 char sep6_first = 0;
4925
4926 for (int i = 0; i < line_len; i++)
4927 {
4928 if (line_buf[i] == ':')
4929 {
4930 sep_cnt++;
4931
4932 continue;
4933 }
4934
4935 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4936 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4937 }
4938
4939 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4940
4941 return 0;
4942 }
4943
4944 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4945 {
4946 char *pos = NULL;
4947 int len = 0;
4948
4949 int sep_cnt = 0;
4950
4951 for (int i = 0; i < line_len; i++)
4952 {
4953 if (line_buf[i] == ':')
4954 {
4955 sep_cnt++;
4956
4957 continue;
4958 }
4959
4960 if (sep_cnt == 1)
4961 {
4962 if (pos == NULL) pos = line_buf + i;
4963
4964 len++;
4965 }
4966 }
4967
4968 *hashbuf_pos = pos;
4969 *hashbuf_len = len;
4970 }
4971
4972 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4973 {
4974 char *pos = NULL;
4975 int len = 0;
4976
4977 int sep_cnt = 0;
4978
4979 for (int i = 0; i < line_len; i++)
4980 {
4981 if (line_buf[i] == ':')
4982 {
4983 sep_cnt++;
4984
4985 continue;
4986 }
4987
4988 if (sep_cnt == 0)
4989 {
4990 if (pos == NULL) pos = line_buf + i;
4991
4992 len++;
4993 }
4994 }
4995
4996 *userbuf_pos = pos;
4997 *userbuf_len = len;
4998 }
4999
5000 // hlfmt shadow
5001
5002 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5003 {
5004 int sep_cnt = 0;
5005
5006 for (int i = 0; i < line_len; i++)
5007 {
5008 if (line_buf[i] == ':') sep_cnt++;
5009 }
5010
5011 if (sep_cnt == 8) return 1;
5012
5013 return 0;
5014 }
5015
5016 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5017 {
5018 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5019 }
5020
5021 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5022 {
5023 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5024 }
5025
5026 // hlfmt main
5027
5028 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5029 {
5030 switch (hashfile_format)
5031 {
5032 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5033 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5034 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5035 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5036 }
5037 }
5038
5039 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5040 {
5041 switch (hashfile_format)
5042 {
5043 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5044 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5045 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5046 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5047 }
5048 }
5049
5050 static uint hlfmt_detect (FILE *fp, uint max_check)
5051 {
5052 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5053
5054 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5055 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5056
5057 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5058
5059 uint num_check = 0;
5060
5061 while (!feof (fp))
5062 {
5063 char line_buf[BUFSIZ] = { 0 };
5064
5065 int line_len = fgetl (fp, line_buf);
5066
5067 if (line_len == 0) continue;
5068
5069 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5070 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5071 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5072
5073 if (num_check == max_check) break;
5074
5075 num_check++;
5076 }
5077
5078 uint hashlist_format = HLFMT_HASHCAT;
5079
5080 for (int i = 1; i < HLFMTS_CNT; i++)
5081 {
5082 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5083
5084 hashlist_format = i;
5085 }
5086
5087 free (formats_cnt);
5088
5089 return hashlist_format;
5090 }
5091
5092 /**
5093 * some further helper function
5094 */
5095
5096 // wrapper around mymalloc for ADL
5097
5098 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5099 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5100 {
5101 return mymalloc (iSize);
5102 }
5103 #endif
5104
5105 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)
5106 {
5107 u64 collisions = 0;
5108
5109 const uint dgst_pos0 = data.dgst_pos0;
5110 const uint dgst_pos1 = data.dgst_pos1;
5111 const uint dgst_pos2 = data.dgst_pos2;
5112 const uint dgst_pos3 = data.dgst_pos3;
5113
5114 memset (bitmap_a, 0, bitmap_size);
5115 memset (bitmap_b, 0, bitmap_size);
5116 memset (bitmap_c, 0, bitmap_size);
5117 memset (bitmap_d, 0, bitmap_size);
5118
5119 for (uint i = 0; i < digests_cnt; i++)
5120 {
5121 uint *digest_ptr = (uint *) digests_buf_ptr;
5122
5123 digests_buf_ptr += dgst_size;
5124
5125 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5126 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5127 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5128 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5129
5130 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5131 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5132 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5133 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5134
5135 if (bitmap_a[idx0] & val0) collisions++;
5136 if (bitmap_b[idx1] & val1) collisions++;
5137 if (bitmap_c[idx2] & val2) collisions++;
5138 if (bitmap_d[idx3] & val3) collisions++;
5139
5140 bitmap_a[idx0] |= val0;
5141 bitmap_b[idx1] |= val1;
5142 bitmap_c[idx2] |= val2;
5143 bitmap_d[idx3] |= val3;
5144
5145 if (collisions >= collisions_max) return 0x7fffffff;
5146 }
5147
5148 return collisions;
5149 }
5150
5151 /**
5152 * main
5153 */
5154
5155 int main (int argc, char **argv)
5156 {
5157 /**
5158 * To help users a bit
5159 */
5160
5161 char *compute = getenv ("COMPUTE");
5162
5163 if (compute)
5164 {
5165 static char display[100];
5166
5167 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5168
5169 putenv (display);
5170 }
5171 else
5172 {
5173 if (getenv ("DISPLAY") == NULL)
5174 putenv ((char *) "DISPLAY=:0");
5175 }
5176
5177 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5178 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5179
5180 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5181 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5182
5183 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5184 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5185
5186 /**
5187 * Real init
5188 */
5189
5190 memset (&data, 0, sizeof (hc_global_data_t));
5191
5192 time_t proc_start;
5193
5194 time (&proc_start);
5195
5196 data.proc_start = proc_start;
5197
5198 int myargc = argc;
5199 char **myargv = argv;
5200
5201 hc_thread_mutex_init (mux_dispatcher);
5202 hc_thread_mutex_init (mux_counter);
5203 hc_thread_mutex_init (mux_display);
5204 hc_thread_mutex_init (mux_adl);
5205
5206 /**
5207 * commandline parameters
5208 */
5209
5210 uint usage = USAGE;
5211 uint version = VERSION;
5212 uint quiet = QUIET;
5213 uint benchmark = BENCHMARK;
5214 uint benchmark_mode = BENCHMARK_MODE;
5215 uint show = SHOW;
5216 uint left = LEFT;
5217 uint username = USERNAME;
5218 uint remove = REMOVE;
5219 uint remove_timer = REMOVE_TIMER;
5220 u64 skip = SKIP;
5221 u64 limit = LIMIT;
5222 uint keyspace = KEYSPACE;
5223 uint potfile_disable = POTFILE_DISABLE;
5224 uint debug_mode = DEBUG_MODE;
5225 char *debug_file = NULL;
5226 char *induction_dir = NULL;
5227 char *outfile_check_dir = NULL;
5228 uint force = FORCE;
5229 uint runtime = RUNTIME;
5230 uint hash_mode = HASH_MODE;
5231 uint attack_mode = ATTACK_MODE;
5232 uint markov_disable = MARKOV_DISABLE;
5233 uint markov_classic = MARKOV_CLASSIC;
5234 uint markov_threshold = MARKOV_THRESHOLD;
5235 char *markov_hcstat = NULL;
5236 char *outfile = NULL;
5237 uint outfile_format = OUTFILE_FORMAT;
5238 uint outfile_autohex = OUTFILE_AUTOHEX;
5239 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5240 uint restore = RESTORE;
5241 uint restore_timer = RESTORE_TIMER;
5242 uint restore_disable = RESTORE_DISABLE;
5243 uint status = STATUS;
5244 uint status_timer = STATUS_TIMER;
5245 uint status_automat = STATUS_AUTOMAT;
5246 uint loopback = LOOPBACK;
5247 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5248 char *session = NULL;
5249 uint hex_charset = HEX_CHARSET;
5250 uint hex_salt = HEX_SALT;
5251 uint hex_wordlist = HEX_WORDLIST;
5252 uint rp_gen = RP_GEN;
5253 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5254 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5255 uint rp_gen_seed = RP_GEN_SEED;
5256 char *rule_buf_l = (char *) RULE_BUF_L;
5257 char *rule_buf_r = (char *) RULE_BUF_R;
5258 uint increment = INCREMENT;
5259 uint increment_min = INCREMENT_MIN;
5260 uint increment_max = INCREMENT_MAX;
5261 char *cpu_affinity = NULL;
5262 OCL_PTR *ocl = NULL;
5263 char *opencl_devices = NULL;
5264 char *opencl_platforms = NULL;
5265 char *opencl_device_types = NULL;
5266 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5267 char *truecrypt_keyfiles = NULL;
5268 uint workload_profile = WORKLOAD_PROFILE;
5269 uint kernel_accel = KERNEL_ACCEL;
5270 uint kernel_loops = KERNEL_LOOPS;
5271 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5272 #ifdef HAVE_HWMON
5273 uint gpu_temp_abort = GPU_TEMP_ABORT;
5274 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5275 #ifdef HAVE_ADL
5276 uint powertune_enable = POWERTUNE_ENABLE;
5277 #endif
5278 #endif
5279 uint logfile_disable = LOGFILE_DISABLE;
5280 uint segment_size = SEGMENT_SIZE;
5281 uint scrypt_tmto = SCRYPT_TMTO;
5282 char separator = SEPARATOR;
5283 uint bitmap_min = BITMAP_MIN;
5284 uint bitmap_max = BITMAP_MAX;
5285 char *custom_charset_1 = NULL;
5286 char *custom_charset_2 = NULL;
5287 char *custom_charset_3 = NULL;
5288 char *custom_charset_4 = NULL;
5289
5290 #define IDX_HELP 'h'
5291 #define IDX_VERSION 'V'
5292 #define IDX_VERSION_LOWER 'v'
5293 #define IDX_QUIET 0xff02
5294 #define IDX_SHOW 0xff03
5295 #define IDX_LEFT 0xff04
5296 #define IDX_REMOVE 0xff05
5297 #define IDX_REMOVE_TIMER 0xff37
5298 #define IDX_SKIP 's'
5299 #define IDX_LIMIT 'l'
5300 #define IDX_KEYSPACE 0xff35
5301 #define IDX_POTFILE_DISABLE 0xff06
5302 #define IDX_DEBUG_MODE 0xff43
5303 #define IDX_DEBUG_FILE 0xff44
5304 #define IDX_INDUCTION_DIR 0xff46
5305 #define IDX_OUTFILE_CHECK_DIR 0xff47
5306 #define IDX_USERNAME 0xff07
5307 #define IDX_FORCE 0xff08
5308 #define IDX_RUNTIME 0xff09
5309 #define IDX_BENCHMARK 'b'
5310 #define IDX_BENCHMARK_MODE 0xff32
5311 #define IDX_HASH_MODE 'm'
5312 #define IDX_ATTACK_MODE 'a'
5313 #define IDX_RP_FILE 'r'
5314 #define IDX_RP_GEN 'g'
5315 #define IDX_RP_GEN_FUNC_MIN 0xff10
5316 #define IDX_RP_GEN_FUNC_MAX 0xff11
5317 #define IDX_RP_GEN_SEED 0xff34
5318 #define IDX_RULE_BUF_L 'j'
5319 #define IDX_RULE_BUF_R 'k'
5320 #define IDX_INCREMENT 'i'
5321 #define IDX_INCREMENT_MIN 0xff12
5322 #define IDX_INCREMENT_MAX 0xff13
5323 #define IDX_OUTFILE 'o'
5324 #define IDX_OUTFILE_FORMAT 0xff14
5325 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5326 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5327 #define IDX_RESTORE 0xff15
5328 #define IDX_RESTORE_DISABLE 0xff27
5329 #define IDX_STATUS 0xff17
5330 #define IDX_STATUS_TIMER 0xff18
5331 #define IDX_STATUS_AUTOMAT 0xff50
5332 #define IDX_LOOPBACK 0xff38
5333 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5334 #define IDX_SESSION 0xff19
5335 #define IDX_HEX_CHARSET 0xff20
5336 #define IDX_HEX_SALT 0xff21
5337 #define IDX_HEX_WORDLIST 0xff40
5338 #define IDX_MARKOV_DISABLE 0xff22
5339 #define IDX_MARKOV_CLASSIC 0xff23
5340 #define IDX_MARKOV_THRESHOLD 't'
5341 #define IDX_MARKOV_HCSTAT 0xff24
5342 #define IDX_CPU_AFFINITY 0xff25
5343 #define IDX_OPENCL_DEVICES 'd'
5344 #define IDX_OPENCL_PLATFORMS 0xff72
5345 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5346 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5347 #define IDX_WORKLOAD_PROFILE 'w'
5348 #define IDX_KERNEL_ACCEL 'n'
5349 #define IDX_KERNEL_LOOPS 'u'
5350 #define IDX_GPU_TEMP_DISABLE 0xff29
5351 #define IDX_GPU_TEMP_ABORT 0xff30
5352 #define IDX_GPU_TEMP_RETAIN 0xff31
5353 #define IDX_POWERTUNE_ENABLE 0xff41
5354 #define IDX_LOGFILE_DISABLE 0xff51
5355 #define IDX_TRUECRYPT_KEYFILES 0xff52
5356 #define IDX_SCRYPT_TMTO 0xff61
5357 #define IDX_SEGMENT_SIZE 'c'
5358 #define IDX_SEPARATOR 'p'
5359 #define IDX_BITMAP_MIN 0xff70
5360 #define IDX_BITMAP_MAX 0xff71
5361 #define IDX_CUSTOM_CHARSET_1 '1'
5362 #define IDX_CUSTOM_CHARSET_2 '2'
5363 #define IDX_CUSTOM_CHARSET_3 '3'
5364 #define IDX_CUSTOM_CHARSET_4 '4'
5365
5366 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5367
5368 struct option long_options[] =
5369 {
5370 {"help", no_argument, 0, IDX_HELP},
5371 {"version", no_argument, 0, IDX_VERSION},
5372 {"quiet", no_argument, 0, IDX_QUIET},
5373 {"show", no_argument, 0, IDX_SHOW},
5374 {"left", no_argument, 0, IDX_LEFT},
5375 {"username", no_argument, 0, IDX_USERNAME},
5376 {"remove", no_argument, 0, IDX_REMOVE},
5377 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5378 {"skip", required_argument, 0, IDX_SKIP},
5379 {"limit", required_argument, 0, IDX_LIMIT},
5380 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5381 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5382 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5383 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5384 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5385 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5386 {"force", no_argument, 0, IDX_FORCE},
5387 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5388 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5389 {"restore", no_argument, 0, IDX_RESTORE},
5390 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5391 {"status", no_argument, 0, IDX_STATUS},
5392 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5393 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5394 {"loopback", no_argument, 0, IDX_LOOPBACK},
5395 {"weak-hash-threshold",
5396 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5397 {"session", required_argument, 0, IDX_SESSION},
5398 {"runtime", required_argument, 0, IDX_RUNTIME},
5399 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5400 {"generate-rules-func-min",
5401 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5402 {"generate-rules-func-max",
5403 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5404 {"generate-rules-seed",
5405 required_argument, 0, IDX_RP_GEN_SEED},
5406 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5407 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5408 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5409 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5410 {"rules-file", required_argument, 0, IDX_RP_FILE},
5411 {"outfile", required_argument, 0, IDX_OUTFILE},
5412 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5413 {"outfile-autohex-disable",
5414 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5415 {"outfile-check-timer",
5416 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5417 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5418 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5419 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5420 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5421 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5422 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5423 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5424 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5425 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5426 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5427 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5428 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5429 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5430 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5431 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5432 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5433 #ifdef HAVE_HWMON
5434 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5435 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5436 #ifdef HAVE_ADL
5437 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5438 #endif
5439 #endif // HAVE_HWMON
5440 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5441 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5442 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5443 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5444 // deprecated
5445 {"seperator", required_argument, 0, IDX_SEPARATOR},
5446 {"separator", required_argument, 0, IDX_SEPARATOR},
5447 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5448 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5449 {"increment", no_argument, 0, IDX_INCREMENT},
5450 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5451 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5452 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5453 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5454 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5455 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5456
5457 {0, 0, 0, 0}
5458 };
5459
5460 uint rp_files_cnt = 0;
5461
5462 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5463
5464 int option_index = 0;
5465 int c = -1;
5466
5467 optind = 1;
5468 optopt = 0;
5469
5470 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5471 {
5472 switch (c)
5473 {
5474 case IDX_HELP: usage = 1; break;
5475 case IDX_VERSION:
5476 case IDX_VERSION_LOWER: version = 1; break;
5477 case IDX_RESTORE: restore = 1; break;
5478 case IDX_SESSION: session = optarg; break;
5479 case IDX_SHOW: show = 1; break;
5480 case IDX_LEFT: left = 1; break;
5481 case '?': return (-1);
5482 }
5483 }
5484
5485 if (optopt != 0)
5486 {
5487 log_error ("ERROR: Invalid argument specified");
5488
5489 return (-1);
5490 }
5491
5492 /**
5493 * exit functions
5494 */
5495
5496 if (version)
5497 {
5498 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5499
5500 return (0);
5501 }
5502
5503 if (usage)
5504 {
5505 usage_big_print (PROGNAME);
5506
5507 return (0);
5508 }
5509
5510 /**
5511 * session needs to be set, always!
5512 */
5513
5514 if (session == NULL) session = (char *) PROGNAME;
5515
5516 /**
5517 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5518 */
5519
5520 char *exec_path = get_exec_path ();
5521
5522 #ifdef LINUX
5523
5524 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5525 char *resolved_exec_path = realpath (exec_path, NULL);
5526
5527 char *install_dir = get_install_dir (resolved_exec_path);
5528 char *profile_dir = NULL;
5529 char *session_dir = NULL;
5530 char *shared_dir = NULL;
5531
5532 if (strcmp (install_dir, resolved_install_folder) == 0)
5533 {
5534 struct passwd *pw = getpwuid (getuid ());
5535
5536 const char *homedir = pw->pw_dir;
5537
5538 profile_dir = get_profile_dir (homedir);
5539 session_dir = get_session_dir (profile_dir);
5540 shared_dir = strdup (SHARED_FOLDER);
5541
5542 mkdir (profile_dir, 0700);
5543 mkdir (session_dir, 0700);
5544 }
5545 else
5546 {
5547 profile_dir = install_dir;
5548 session_dir = install_dir;
5549 shared_dir = install_dir;
5550 }
5551
5552 myfree (resolved_install_folder);
5553 myfree (resolved_exec_path);
5554
5555 #else
5556
5557 char *install_dir = get_install_dir (exec_path);
5558 char *profile_dir = install_dir;
5559 char *session_dir = install_dir;
5560 char *shared_dir = install_dir;
5561
5562 #endif
5563
5564 data.install_dir = install_dir;
5565 data.profile_dir = profile_dir;
5566 data.session_dir = session_dir;
5567 data.shared_dir = shared_dir;
5568
5569 myfree (exec_path);
5570
5571 /**
5572 * kernel cache, we need to make sure folder exist
5573 */
5574
5575 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5576
5577 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5578
5579 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5580
5581 mkdir (kernels_folder, 0700);
5582
5583 myfree (kernels_folder);
5584
5585 /**
5586 * session
5587 */
5588
5589 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5590
5591 data.session = session;
5592
5593 char *eff_restore_file = (char *) mymalloc (session_size);
5594 char *new_restore_file = (char *) mymalloc (session_size);
5595
5596 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5597 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5598
5599 data.eff_restore_file = eff_restore_file;
5600 data.new_restore_file = new_restore_file;
5601
5602 if (((show == 1) || (left == 1)) && (restore == 1))
5603 {
5604 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5605 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5606
5607 return (-1);
5608 }
5609
5610 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5611 if ((show == 1) || (left == 1))
5612 {
5613 restore_disable = 1;
5614
5615 restore = 0;
5616 }
5617
5618 data.restore_disable = restore_disable;
5619
5620 restore_data_t *rd = init_restore (argc, argv);
5621
5622 data.rd = rd;
5623
5624 /**
5625 * restore file
5626 */
5627
5628 if (restore == 1)
5629 {
5630 read_restore (eff_restore_file, rd);
5631
5632 if (rd->version_bin < RESTORE_MIN)
5633 {
5634 log_error ("ERROR: Incompatible restore-file version");
5635
5636 return (-1);
5637 }
5638
5639 myargc = rd->argc;
5640 myargv = rd->argv;
5641
5642 #ifdef _POSIX
5643 rd->pid = getpid ();
5644 #elif _WIN
5645 rd->pid = GetCurrentProcessId ();
5646 #endif
5647 }
5648
5649 uint hash_mode_chgd = 0;
5650 uint runtime_chgd = 0;
5651 uint kernel_loops_chgd = 0;
5652 uint kernel_accel_chgd = 0;
5653 uint attack_mode_chgd = 0;
5654 uint outfile_format_chgd = 0;
5655 uint rp_gen_seed_chgd = 0;
5656 uint remove_timer_chgd = 0;
5657 uint increment_min_chgd = 0;
5658 uint increment_max_chgd = 0;
5659 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5660 uint gpu_temp_retain_chgd = 0;
5661 uint gpu_temp_abort_chgd = 0;
5662 #endif
5663
5664 optind = 1;
5665 optopt = 0;
5666 option_index = 0;
5667
5668 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5669 {
5670 switch (c)
5671 {
5672 //case IDX_HELP: usage = 1; break;
5673 //case IDX_VERSION: version = 1; break;
5674 //case IDX_RESTORE: restore = 1; break;
5675 case IDX_QUIET: quiet = 1; break;
5676 //case IDX_SHOW: show = 1; break;
5677 case IDX_SHOW: break;
5678 //case IDX_LEFT: left = 1; break;
5679 case IDX_LEFT: break;
5680 case IDX_USERNAME: username = 1; break;
5681 case IDX_REMOVE: remove = 1; break;
5682 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5683 remove_timer_chgd = 1; break;
5684 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5685 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5686 case IDX_DEBUG_FILE: debug_file = optarg; break;
5687 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5688 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5689 case IDX_FORCE: force = 1; break;
5690 case IDX_SKIP: skip = atoll (optarg); break;
5691 case IDX_LIMIT: limit = atoll (optarg); break;
5692 case IDX_KEYSPACE: keyspace = 1; break;
5693 case IDX_BENCHMARK: benchmark = 1; break;
5694 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5695 case IDX_RESTORE: break;
5696 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5697 case IDX_STATUS: status = 1; break;
5698 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5699 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5700 case IDX_LOOPBACK: loopback = 1; break;
5701 case IDX_WEAK_HASH_THRESHOLD:
5702 weak_hash_threshold = atoi (optarg); break;
5703 //case IDX_SESSION: session = optarg; break;
5704 case IDX_SESSION: break;
5705 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5706 hash_mode_chgd = 1; break;
5707 case IDX_RUNTIME: runtime = atoi (optarg);
5708 runtime_chgd = 1; break;
5709 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5710 attack_mode_chgd = 1; break;
5711 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5712 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5713 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5714 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5715 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5716 rp_gen_seed_chgd = 1; break;
5717 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5718 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5719 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5720 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5721 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5722 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5723 case IDX_OUTFILE: outfile = optarg; break;
5724 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5725 outfile_format_chgd = 1; break;
5726 case IDX_OUTFILE_AUTOHEX_DISABLE:
5727 outfile_autohex = 0; break;
5728 case IDX_OUTFILE_CHECK_TIMER:
5729 outfile_check_timer = atoi (optarg); break;
5730 case IDX_HEX_CHARSET: hex_charset = 1; break;
5731 case IDX_HEX_SALT: hex_salt = 1; break;
5732 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5733 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5734 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5735 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5736 case IDX_OPENCL_DEVICE_TYPES:
5737 opencl_device_types = optarg; break;
5738 case IDX_OPENCL_VECTOR_WIDTH:
5739 opencl_vector_width = atoi (optarg); break;
5740 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5741 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5742 kernel_accel_chgd = 1; break;
5743 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5744 kernel_loops_chgd = 1; break;
5745 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5746 #ifdef HAVE_HWMON
5747 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5748 #ifdef HAVE_ADL
5749 gpu_temp_abort_chgd = 1;
5750 #endif
5751 break;
5752 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5753 #ifdef HAVE_ADL
5754 gpu_temp_retain_chgd = 1;
5755 #endif
5756 break;
5757 #ifdef HAVE_ADL
5758 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5759 #endif
5760 #endif // HAVE_HWMON
5761 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5762 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5763 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5764 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5765 case IDX_SEPARATOR: separator = optarg[0]; break;
5766 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5767 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5768 case IDX_INCREMENT: increment = 1; break;
5769 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5770 increment_min_chgd = 1; break;
5771 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5772 increment_max_chgd = 1; break;
5773 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5774 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5775 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5776 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5777
5778 default:
5779 log_error ("ERROR: Invalid argument specified");
5780 return (-1);
5781 }
5782 }
5783
5784 if (optopt != 0)
5785 {
5786 log_error ("ERROR: Invalid argument specified");
5787
5788 return (-1);
5789 }
5790
5791 /**
5792 * Inform user things getting started,
5793 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5794 * - we do not need to check algorithm_pos
5795 */
5796
5797 if (quiet == 0)
5798 {
5799 if (benchmark == 1)
5800 {
5801 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5802
5803 log_info ("");
5804 }
5805 else if (restore == 1)
5806 {
5807 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5808
5809 log_info ("");
5810 }
5811 else
5812 {
5813 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5814
5815 log_info ("");
5816 }
5817 }
5818
5819 /**
5820 * sanity check
5821 */
5822
5823 if (attack_mode > 7)
5824 {
5825 log_error ("ERROR: Invalid attack-mode specified");
5826
5827 return (-1);
5828 }
5829
5830 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5831 {
5832 log_error ("ERROR: Invalid runtime specified");
5833
5834 return (-1);
5835 }
5836
5837 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5838 {
5839 log_error ("ERROR: Invalid hash-type specified");
5840
5841 return (-1);
5842 }
5843
5844 // renamed hash modes
5845
5846 if (hash_mode_chgd)
5847 {
5848 int n = -1;
5849
5850 switch (hash_mode)
5851 {
5852 case 123: n = 124;
5853 break;
5854 }
5855
5856 if (n >= 0)
5857 {
5858 log_error ("Old -m specified, use -m %d instead", n);
5859
5860 return (-1);
5861 }
5862 }
5863
5864 if (username == 1)
5865 {
5866 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5867 {
5868 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5869
5870 return (-1);
5871 }
5872 }
5873
5874 if (outfile_format > 16)
5875 {
5876 log_error ("ERROR: Invalid outfile-format specified");
5877
5878 return (-1);
5879 }
5880
5881 if (left == 1)
5882 {
5883 if (outfile_format_chgd == 1)
5884 {
5885 if (outfile_format > 1)
5886 {
5887 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5888
5889 return (-1);
5890 }
5891 }
5892 else
5893 {
5894 outfile_format = OUTFILE_FMT_HASH;
5895 }
5896 }
5897
5898 if (show == 1)
5899 {
5900 if (outfile_format_chgd == 1)
5901 {
5902 if ((outfile_format > 7) && (outfile_format < 16))
5903 {
5904 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5905
5906 return (-1);
5907 }
5908 }
5909 }
5910
5911 if (increment_min < INCREMENT_MIN)
5912 {
5913 log_error ("ERROR: Invalid increment-min specified");
5914
5915 return (-1);
5916 }
5917
5918 if (increment_max > INCREMENT_MAX)
5919 {
5920 log_error ("ERROR: Invalid increment-max specified");
5921
5922 return (-1);
5923 }
5924
5925 if (increment_min > increment_max)
5926 {
5927 log_error ("ERROR: Invalid increment-min specified");
5928
5929 return (-1);
5930 }
5931
5932 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5933 {
5934 log_error ("ERROR: increment is not allowed in attack-mode 0");
5935
5936 return (-1);
5937 }
5938
5939 if ((increment == 0) && (increment_min_chgd == 1))
5940 {
5941 log_error ("ERROR: increment-min is only supported together with increment switch");
5942
5943 return (-1);
5944 }
5945
5946 if ((increment == 0) && (increment_max_chgd == 1))
5947 {
5948 log_error ("ERROR: increment-max is only supported together with increment switch");
5949
5950 return (-1);
5951 }
5952
5953 if (rp_files_cnt && rp_gen)
5954 {
5955 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5956
5957 return (-1);
5958 }
5959
5960 if (rp_files_cnt || rp_gen)
5961 {
5962 if (attack_mode != ATTACK_MODE_STRAIGHT)
5963 {
5964 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5965
5966 return (-1);
5967 }
5968 }
5969
5970 if (rp_gen_func_min > rp_gen_func_max)
5971 {
5972 log_error ("ERROR: Invalid rp-gen-func-min specified");
5973
5974 return (-1);
5975 }
5976
5977 if (kernel_accel_chgd == 1)
5978 {
5979 if (workload_profile != WORKLOAD_PROFILE)
5980 {
5981 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5982
5983 return (-1);
5984 }
5985
5986 if (kernel_accel < 1)
5987 {
5988 log_error ("ERROR: Invalid kernel-accel specified");
5989
5990 return (-1);
5991 }
5992
5993 if (kernel_accel > 1024)
5994 {
5995 log_error ("ERROR: Invalid kernel-accel specified");
5996
5997 return (-1);
5998 }
5999 }
6000
6001 if (kernel_loops_chgd == 1)
6002 {
6003 if (workload_profile != WORKLOAD_PROFILE)
6004 {
6005 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6006
6007 return (-1);
6008 }
6009
6010 if (kernel_loops < 1)
6011 {
6012 log_error ("ERROR: Invalid kernel-loops specified");
6013
6014 return (-1);
6015 }
6016
6017 if (kernel_loops > 1024)
6018 {
6019 log_error ("ERROR: Invalid kernel-loops specified");
6020
6021 return (-1);
6022 }
6023 }
6024
6025 if (benchmark == 1)
6026 {
6027 if (workload_profile != WORKLOAD_PROFILE)
6028 {
6029 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6030
6031 return (-1);
6032 }
6033 }
6034
6035 if ((workload_profile < 1) || (workload_profile > 3))
6036 {
6037 log_error ("ERROR: workload-profile %i not available", workload_profile);
6038
6039 return (-1);
6040 }
6041
6042 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6043 {
6044 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6045
6046 return (-1);
6047 }
6048
6049 if (show == 1 || left == 1)
6050 {
6051 attack_mode = ATTACK_MODE_NONE;
6052
6053 if (remove == 1)
6054 {
6055 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6056
6057 return (-1);
6058 }
6059
6060 if (potfile_disable == 1)
6061 {
6062 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6063
6064 return (-1);
6065 }
6066 }
6067
6068 uint attack_kern = ATTACK_KERN_NONE;
6069
6070 switch (attack_mode)
6071 {
6072 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6073 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6074 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6075 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6076 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6077 }
6078
6079 if (benchmark == 0)
6080 {
6081 if (keyspace == 1)
6082 {
6083 int num_additional_params = 1;
6084
6085 if (attack_kern == ATTACK_KERN_COMBI)
6086 {
6087 num_additional_params = 2;
6088 }
6089
6090 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6091
6092 if (keyspace_wordlist_specified == 0) optind--;
6093 }
6094
6095 if (attack_kern == ATTACK_KERN_NONE)
6096 {
6097 if ((optind + 1) != myargc)
6098 {
6099 usage_mini_print (myargv[0]);
6100
6101 return (-1);
6102 }
6103 }
6104 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6105 {
6106 if ((optind + 1) > myargc)
6107 {
6108 usage_mini_print (myargv[0]);
6109
6110 return (-1);
6111 }
6112 }
6113 else if (attack_kern == ATTACK_KERN_COMBI)
6114 {
6115 if ((optind + 3) != myargc)
6116 {
6117 usage_mini_print (myargv[0]);
6118
6119 return (-1);
6120 }
6121 }
6122 else if (attack_kern == ATTACK_KERN_BF)
6123 {
6124 if ((optind + 1) > myargc)
6125 {
6126 usage_mini_print (myargv[0]);
6127
6128 return (-1);
6129 }
6130 }
6131 else
6132 {
6133 usage_mini_print (myargv[0]);
6134
6135 return (-1);
6136 }
6137 }
6138 else
6139 {
6140 if (myargv[optind] != 0)
6141 {
6142 log_error ("ERROR: Invalid argument for benchmark mode specified");
6143
6144 return (-1);
6145 }
6146
6147 if (attack_mode_chgd == 1)
6148 {
6149 if (attack_mode != ATTACK_MODE_BF)
6150 {
6151 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6152
6153 return (-1);
6154 }
6155 }
6156
6157 if (benchmark_mode == 0)
6158 {
6159 // nothing to do
6160 }
6161 else if (benchmark_mode == 1)
6162 {
6163 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6164 {
6165 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6166
6167 return (-1);
6168 }
6169 }
6170 else
6171 {
6172 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (skip != 0 && limit != 0)
6179 {
6180 limit += skip;
6181 }
6182
6183 if (keyspace == 1)
6184 {
6185 if (show == 1)
6186 {
6187 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6188
6189 return (-1);
6190 }
6191 else if (left == 1)
6192 {
6193 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6194
6195 return (-1);
6196 }
6197
6198 potfile_disable = 1;
6199
6200 restore_disable = 1;
6201
6202 restore = 0;
6203
6204 weak_hash_threshold = 0;
6205
6206 quiet = 1;
6207 }
6208
6209 if (remove_timer_chgd == 1)
6210 {
6211 if (remove == 0)
6212 {
6213 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6214
6215 return (-1);
6216 }
6217
6218 if (remove_timer < 1)
6219 {
6220 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6221
6222 return (-1);
6223 }
6224 }
6225
6226 if (loopback == 1)
6227 {
6228 if (attack_mode == ATTACK_MODE_BF)
6229 {
6230 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6231
6232 return (-1);
6233 }
6234 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6235 {
6236 if ((rp_files_cnt == 0) && (rp_gen == 0))
6237 {
6238 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6239
6240 return (-1);
6241 }
6242 }
6243 }
6244
6245 if (debug_mode > 0)
6246 {
6247 if (attack_mode != ATTACK_MODE_STRAIGHT)
6248 {
6249 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6250
6251 return (-1);
6252 }
6253
6254 if ((rp_files_cnt == 0) && (rp_gen == 0))
6255 {
6256 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6257
6258 return (-1);
6259 }
6260 }
6261
6262 if (debug_mode > 4)
6263 {
6264 log_error ("ERROR: Invalid debug-mode specified");
6265
6266 return (-1);
6267 }
6268
6269 if (debug_file != NULL)
6270 {
6271 if (debug_mode < 1)
6272 {
6273 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6274
6275 return (-1);
6276 }
6277 }
6278
6279 if (induction_dir != NULL)
6280 {
6281 if (attack_mode == ATTACK_MODE_BF)
6282 {
6283 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6284
6285 return (-1);
6286 }
6287 }
6288
6289 if (attack_mode != ATTACK_MODE_STRAIGHT)
6290 {
6291 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6292 {
6293 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6294
6295 return (-1);
6296 }
6297
6298 weak_hash_threshold = 0;
6299 }
6300
6301 /**
6302 * induction directory
6303 */
6304
6305 char *induction_directory = NULL;
6306
6307 if (attack_mode != ATTACK_MODE_BF)
6308 {
6309 if (induction_dir == NULL)
6310 {
6311 induction_directory = (char *) mymalloc (session_size);
6312
6313 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6314
6315 // create induction folder if it does not already exist
6316
6317 if (keyspace == 0)
6318 {
6319 if (rmdir (induction_directory) == -1)
6320 {
6321 if (errno == ENOENT)
6322 {
6323 // good, we can ignore
6324 }
6325 else if (errno == ENOTEMPTY)
6326 {
6327 char *induction_directory_mv = (char *) mymalloc (session_size);
6328
6329 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6330
6331 if (rename (induction_directory, induction_directory_mv) != 0)
6332 {
6333 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6334
6335 return (-1);
6336 }
6337 }
6338 else
6339 {
6340 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6341
6342 return (-1);
6343 }
6344 }
6345
6346 if (mkdir (induction_directory, 0700) == -1)
6347 {
6348 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6349
6350 return (-1);
6351 }
6352 }
6353 }
6354 else
6355 {
6356 induction_directory = induction_dir;
6357 }
6358 }
6359
6360 data.induction_directory = induction_directory;
6361
6362 /**
6363 * loopback
6364 */
6365
6366 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6367
6368 char *loopback_file = (char *) mymalloc (loopback_size);
6369
6370 /**
6371 * outfile-check directory
6372 */
6373
6374 char *outfile_check_directory = NULL;
6375
6376 if (outfile_check_dir == NULL)
6377 {
6378 outfile_check_directory = (char *) mymalloc (session_size);
6379
6380 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6381 }
6382 else
6383 {
6384 outfile_check_directory = outfile_check_dir;
6385 }
6386
6387 data.outfile_check_directory = outfile_check_directory;
6388
6389 if (keyspace == 0)
6390 {
6391 struct stat outfile_check_stat;
6392
6393 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6394 {
6395 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6396
6397 if (is_dir == 0)
6398 {
6399 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6400
6401 return (-1);
6402 }
6403 }
6404 else if (outfile_check_dir == NULL)
6405 {
6406 if (mkdir (outfile_check_directory, 0700) == -1)
6407 {
6408 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6409
6410 return (-1);
6411 }
6412 }
6413 }
6414
6415 /**
6416 * special other stuff
6417 */
6418
6419 if (hash_mode == 9710)
6420 {
6421 outfile_format = 5;
6422 outfile_format_chgd = 1;
6423 }
6424
6425 if (hash_mode == 9810)
6426 {
6427 outfile_format = 5;
6428 outfile_format_chgd = 1;
6429 }
6430
6431 if (hash_mode == 10410)
6432 {
6433 outfile_format = 5;
6434 outfile_format_chgd = 1;
6435 }
6436
6437 /**
6438 * store stuff
6439 */
6440
6441 data.hash_mode = hash_mode;
6442 data.restore = restore;
6443 data.restore_timer = restore_timer;
6444 data.restore_disable = restore_disable;
6445 data.status = status;
6446 data.status_timer = status_timer;
6447 data.status_automat = status_automat;
6448 data.loopback = loopback;
6449 data.runtime = runtime;
6450 data.remove = remove;
6451 data.remove_timer = remove_timer;
6452 data.debug_mode = debug_mode;
6453 data.debug_file = debug_file;
6454 data.username = username;
6455 data.quiet = quiet;
6456 data.outfile = outfile;
6457 data.outfile_format = outfile_format;
6458 data.outfile_autohex = outfile_autohex;
6459 data.hex_charset = hex_charset;
6460 data.hex_salt = hex_salt;
6461 data.hex_wordlist = hex_wordlist;
6462 data.separator = separator;
6463 data.rp_files = rp_files;
6464 data.rp_files_cnt = rp_files_cnt;
6465 data.rp_gen = rp_gen;
6466 data.rp_gen_seed = rp_gen_seed;
6467 data.force = force;
6468 data.benchmark = benchmark;
6469 data.skip = skip;
6470 data.limit = limit;
6471 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6472 data.powertune_enable = powertune_enable;
6473 #endif
6474 data.logfile_disable = logfile_disable;
6475 data.truecrypt_keyfiles = truecrypt_keyfiles;
6476 data.scrypt_tmto = scrypt_tmto;
6477
6478 /**
6479 * cpu affinity
6480 */
6481
6482 if (cpu_affinity)
6483 {
6484 set_cpu_affinity (cpu_affinity);
6485 }
6486
6487 if (rp_gen_seed_chgd == 0)
6488 {
6489 srand (proc_start);
6490 }
6491 else
6492 {
6493 srand (rp_gen_seed);
6494 }
6495
6496 /**
6497 * logfile init
6498 */
6499
6500 if (logfile_disable == 0)
6501 {
6502 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6503
6504 char *logfile = (char *) mymalloc (logfile_size);
6505
6506 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6507
6508 data.logfile = logfile;
6509
6510 char *topid = logfile_generate_topid ();
6511
6512 data.topid = topid;
6513 }
6514
6515 // logfile_append() checks for logfile_disable internally to make it easier from here
6516
6517 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6518 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6519 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6520 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6521 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6522 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6523 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6524 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6525 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6526 #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));
6527
6528 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6529 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6530 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6531 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6532 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6533 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6534 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6535 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6536
6537 logfile_top_msg ("START");
6538
6539 logfile_top_uint (attack_mode);
6540 logfile_top_uint (attack_kern);
6541 logfile_top_uint (benchmark);
6542 logfile_top_uint (benchmark_mode);
6543 logfile_top_uint (bitmap_min);
6544 logfile_top_uint (bitmap_max);
6545 logfile_top_uint (debug_mode);
6546 logfile_top_uint (force);
6547 logfile_top_uint (kernel_accel);
6548 logfile_top_uint (kernel_loops);
6549 logfile_top_uint (gpu_temp_disable);
6550 #ifdef HAVE_HWMON
6551 logfile_top_uint (gpu_temp_abort);
6552 logfile_top_uint (gpu_temp_retain);
6553 #endif
6554 logfile_top_uint (hash_mode);
6555 logfile_top_uint (hex_charset);
6556 logfile_top_uint (hex_salt);
6557 logfile_top_uint (hex_wordlist);
6558 logfile_top_uint (increment);
6559 logfile_top_uint (increment_max);
6560 logfile_top_uint (increment_min);
6561 logfile_top_uint (keyspace);
6562 logfile_top_uint (left);
6563 logfile_top_uint (logfile_disable);
6564 logfile_top_uint (loopback);
6565 logfile_top_uint (markov_classic);
6566 logfile_top_uint (markov_disable);
6567 logfile_top_uint (markov_threshold);
6568 logfile_top_uint (outfile_autohex);
6569 logfile_top_uint (outfile_check_timer);
6570 logfile_top_uint (outfile_format);
6571 logfile_top_uint (potfile_disable);
6572 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6573 logfile_top_uint (powertune_enable);
6574 #endif
6575 logfile_top_uint (scrypt_tmto);
6576 logfile_top_uint (quiet);
6577 logfile_top_uint (remove);
6578 logfile_top_uint (remove_timer);
6579 logfile_top_uint (restore);
6580 logfile_top_uint (restore_disable);
6581 logfile_top_uint (restore_timer);
6582 logfile_top_uint (rp_gen);
6583 logfile_top_uint (rp_gen_func_max);
6584 logfile_top_uint (rp_gen_func_min);
6585 logfile_top_uint (rp_gen_seed);
6586 logfile_top_uint (runtime);
6587 logfile_top_uint (segment_size);
6588 logfile_top_uint (show);
6589 logfile_top_uint (status);
6590 logfile_top_uint (status_automat);
6591 logfile_top_uint (status_timer);
6592 logfile_top_uint (usage);
6593 logfile_top_uint (username);
6594 logfile_top_uint (version);
6595 logfile_top_uint (weak_hash_threshold);
6596 logfile_top_uint (workload_profile);
6597 logfile_top_uint64 (limit);
6598 logfile_top_uint64 (skip);
6599 logfile_top_char (separator);
6600 logfile_top_string (cpu_affinity);
6601 logfile_top_string (custom_charset_1);
6602 logfile_top_string (custom_charset_2);
6603 logfile_top_string (custom_charset_3);
6604 logfile_top_string (custom_charset_4);
6605 logfile_top_string (debug_file);
6606 logfile_top_string (opencl_devices);
6607 logfile_top_string (opencl_platforms);
6608 logfile_top_string (opencl_device_types);
6609 logfile_top_uint (opencl_vector_width);
6610 logfile_top_string (induction_dir);
6611 logfile_top_string (markov_hcstat);
6612 logfile_top_string (outfile);
6613 logfile_top_string (outfile_check_dir);
6614 logfile_top_string (rule_buf_l);
6615 logfile_top_string (rule_buf_r);
6616 logfile_top_string (session);
6617 logfile_top_string (truecrypt_keyfiles);
6618
6619 /**
6620 * Init OpenCL library loader
6621 */
6622
6623 if (keyspace == 0)
6624 {
6625 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6626
6627 ocl_init (ocl);
6628
6629 data.ocl = ocl;
6630 }
6631
6632 /**
6633 * OpenCL platform selection
6634 */
6635
6636 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6637
6638 /**
6639 * OpenCL device selection
6640 */
6641
6642 u32 devices_filter = setup_devices_filter (opencl_devices);
6643
6644 /**
6645 * OpenCL device type selection
6646 */
6647
6648 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6649
6650 /**
6651 * benchmark
6652 */
6653
6654 if (benchmark == 1)
6655 {
6656 /**
6657 * disable useless stuff for benchmark
6658 */
6659
6660 restore_timer = 0;
6661 status_timer = 0;
6662 restore_disable = 1;
6663 potfile_disable = 1;
6664 weak_hash_threshold = 0;
6665
6666 data.restore_timer = restore_timer;
6667 data.status_timer = status_timer;
6668 data.restore_disable = restore_disable;
6669
6670 if (benchmark_mode == 1)
6671 {
6672 markov_disable = 1;
6673 }
6674
6675 /**
6676 * force attack mode to be bruteforce
6677 */
6678
6679 attack_mode = ATTACK_MODE_BF;
6680 attack_kern = ATTACK_KERN_BF;
6681
6682 if (runtime_chgd == 0)
6683 {
6684 runtime = 8;
6685
6686 if (benchmark_mode == 1) runtime = 17;
6687
6688 data.runtime = runtime;
6689 }
6690 }
6691
6692 /**
6693 * config
6694 */
6695
6696 uint hash_type = 0;
6697 uint salt_type = 0;
6698 uint attack_exec = 0;
6699 uint opts_type = 0;
6700 uint kern_type = 0;
6701 uint dgst_size = 0;
6702 uint esalt_size = 0;
6703 uint opti_type = 0;
6704 uint dgst_pos0 = -1;
6705 uint dgst_pos1 = -1;
6706 uint dgst_pos2 = -1;
6707 uint dgst_pos3 = -1;
6708
6709 int (*parse_func) (char *, uint, hash_t *);
6710 int (*sort_by_digest) (const void *, const void *);
6711
6712 uint algorithm_pos = 0;
6713 uint algorithm_max = 1;
6714
6715 uint *algorithms = default_benchmark_algorithms;
6716
6717 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6718
6719 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6720 {
6721 /*
6722 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6723 * the following algos are skipped entirely
6724 */
6725
6726 if (algorithm_pos > 0)
6727 {
6728 local_free (rd);
6729
6730 rd = init_restore (argc, argv);
6731
6732 data.rd = rd;
6733 }
6734
6735 /**
6736 * update hash_mode in case of multihash benchmark
6737 */
6738
6739 if (benchmark == 1)
6740 {
6741 if (hash_mode_chgd == 0)
6742 {
6743 hash_mode = algorithms[algorithm_pos];
6744
6745 data.hash_mode = hash_mode;
6746 }
6747
6748 quiet = 1;
6749
6750 data.quiet = quiet;
6751 }
6752
6753 switch (hash_mode)
6754 {
6755 case 0: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_NONE;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_MD5;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = md5_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_PRECOMPUTE_INIT
6767 | OPTI_TYPE_PRECOMPUTE_MERKLE
6768 | OPTI_TYPE_MEET_IN_MIDDLE
6769 | OPTI_TYPE_EARLY_SKIP
6770 | OPTI_TYPE_NOT_ITERATED
6771 | OPTI_TYPE_NOT_SALTED
6772 | OPTI_TYPE_RAW_HASH;
6773 dgst_pos0 = 0;
6774 dgst_pos1 = 3;
6775 dgst_pos2 = 2;
6776 dgst_pos3 = 1;
6777 break;
6778
6779 case 10: hash_type = HASH_TYPE_MD5;
6780 salt_type = SALT_TYPE_INTERN;
6781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6782 opts_type = OPTS_TYPE_PT_GENERATE_LE
6783 | OPTS_TYPE_ST_ADD80
6784 | OPTS_TYPE_ST_ADDBITS14;
6785 kern_type = KERN_TYPE_MD5_PWSLT;
6786 dgst_size = DGST_SIZE_4_4;
6787 parse_func = md5s_parse_hash;
6788 sort_by_digest = sort_by_digest_4_4;
6789 opti_type = OPTI_TYPE_ZERO_BYTE
6790 | OPTI_TYPE_PRECOMPUTE_INIT
6791 | OPTI_TYPE_PRECOMPUTE_MERKLE
6792 | OPTI_TYPE_MEET_IN_MIDDLE
6793 | OPTI_TYPE_EARLY_SKIP
6794 | OPTI_TYPE_NOT_ITERATED
6795 | OPTI_TYPE_APPENDED_SALT
6796 | OPTI_TYPE_RAW_HASH;
6797 dgst_pos0 = 0;
6798 dgst_pos1 = 3;
6799 dgst_pos2 = 2;
6800 dgst_pos3 = 1;
6801 break;
6802
6803 case 11: hash_type = HASH_TYPE_MD5;
6804 salt_type = SALT_TYPE_INTERN;
6805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6806 opts_type = OPTS_TYPE_PT_GENERATE_LE
6807 | OPTS_TYPE_ST_ADD80
6808 | OPTS_TYPE_ST_ADDBITS14;
6809 kern_type = KERN_TYPE_MD5_PWSLT;
6810 dgst_size = DGST_SIZE_4_4;
6811 parse_func = joomla_parse_hash;
6812 sort_by_digest = sort_by_digest_4_4;
6813 opti_type = OPTI_TYPE_ZERO_BYTE
6814 | OPTI_TYPE_PRECOMPUTE_INIT
6815 | OPTI_TYPE_PRECOMPUTE_MERKLE
6816 | OPTI_TYPE_MEET_IN_MIDDLE
6817 | OPTI_TYPE_EARLY_SKIP
6818 | OPTI_TYPE_NOT_ITERATED
6819 | OPTI_TYPE_APPENDED_SALT
6820 | OPTI_TYPE_RAW_HASH;
6821 dgst_pos0 = 0;
6822 dgst_pos1 = 3;
6823 dgst_pos2 = 2;
6824 dgst_pos3 = 1;
6825 break;
6826
6827 case 12: hash_type = HASH_TYPE_MD5;
6828 salt_type = SALT_TYPE_INTERN;
6829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6830 opts_type = OPTS_TYPE_PT_GENERATE_LE
6831 | OPTS_TYPE_ST_ADD80
6832 | OPTS_TYPE_ST_ADDBITS14;
6833 kern_type = KERN_TYPE_MD5_PWSLT;
6834 dgst_size = DGST_SIZE_4_4;
6835 parse_func = postgresql_parse_hash;
6836 sort_by_digest = sort_by_digest_4_4;
6837 opti_type = OPTI_TYPE_ZERO_BYTE
6838 | OPTI_TYPE_PRECOMPUTE_INIT
6839 | OPTI_TYPE_PRECOMPUTE_MERKLE
6840 | OPTI_TYPE_MEET_IN_MIDDLE
6841 | OPTI_TYPE_EARLY_SKIP
6842 | OPTI_TYPE_NOT_ITERATED
6843 | OPTI_TYPE_APPENDED_SALT
6844 | OPTI_TYPE_RAW_HASH;
6845 dgst_pos0 = 0;
6846 dgst_pos1 = 3;
6847 dgst_pos2 = 2;
6848 dgst_pos3 = 1;
6849 break;
6850
6851 case 20: hash_type = HASH_TYPE_MD5;
6852 salt_type = SALT_TYPE_INTERN;
6853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6854 opts_type = OPTS_TYPE_PT_GENERATE_LE
6855 | OPTS_TYPE_PT_ADD80
6856 | OPTS_TYPE_PT_ADDBITS14;
6857 kern_type = KERN_TYPE_MD5_SLTPW;
6858 dgst_size = DGST_SIZE_4_4;
6859 parse_func = md5s_parse_hash;
6860 sort_by_digest = sort_by_digest_4_4;
6861 opti_type = OPTI_TYPE_ZERO_BYTE
6862 | OPTI_TYPE_PRECOMPUTE_INIT
6863 | OPTI_TYPE_PRECOMPUTE_MERKLE
6864 | OPTI_TYPE_EARLY_SKIP
6865 | OPTI_TYPE_NOT_ITERATED
6866 | OPTI_TYPE_PREPENDED_SALT
6867 | OPTI_TYPE_RAW_HASH;
6868 dgst_pos0 = 0;
6869 dgst_pos1 = 3;
6870 dgst_pos2 = 2;
6871 dgst_pos3 = 1;
6872 break;
6873
6874 case 21: hash_type = HASH_TYPE_MD5;
6875 salt_type = SALT_TYPE_INTERN;
6876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6877 opts_type = OPTS_TYPE_PT_GENERATE_LE
6878 | OPTS_TYPE_PT_ADD80
6879 | OPTS_TYPE_PT_ADDBITS14;
6880 kern_type = KERN_TYPE_MD5_SLTPW;
6881 dgst_size = DGST_SIZE_4_4;
6882 parse_func = osc_parse_hash;
6883 sort_by_digest = sort_by_digest_4_4;
6884 opti_type = OPTI_TYPE_ZERO_BYTE
6885 | OPTI_TYPE_PRECOMPUTE_INIT
6886 | OPTI_TYPE_PRECOMPUTE_MERKLE
6887 | OPTI_TYPE_EARLY_SKIP
6888 | OPTI_TYPE_NOT_ITERATED
6889 | OPTI_TYPE_PREPENDED_SALT
6890 | OPTI_TYPE_RAW_HASH;
6891 dgst_pos0 = 0;
6892 dgst_pos1 = 3;
6893 dgst_pos2 = 2;
6894 dgst_pos3 = 1;
6895 break;
6896
6897 case 22: hash_type = HASH_TYPE_MD5;
6898 salt_type = SALT_TYPE_EMBEDDED;
6899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6900 opts_type = OPTS_TYPE_PT_GENERATE_LE
6901 | OPTS_TYPE_PT_ADD80
6902 | OPTS_TYPE_PT_ADDBITS14;
6903 kern_type = KERN_TYPE_MD5_SLTPW;
6904 dgst_size = DGST_SIZE_4_4;
6905 parse_func = netscreen_parse_hash;
6906 sort_by_digest = sort_by_digest_4_4;
6907 opti_type = OPTI_TYPE_ZERO_BYTE
6908 | OPTI_TYPE_PRECOMPUTE_INIT
6909 | OPTI_TYPE_PRECOMPUTE_MERKLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_PREPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 23: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_EMBEDDED;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_PT_ADD80
6925 | OPTS_TYPE_PT_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_SLTPW;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = skype_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_EARLY_SKIP
6934 | OPTI_TYPE_NOT_ITERATED
6935 | OPTI_TYPE_PREPENDED_SALT
6936 | OPTI_TYPE_RAW_HASH;
6937 dgst_pos0 = 0;
6938 dgst_pos1 = 3;
6939 dgst_pos2 = 2;
6940 dgst_pos3 = 1;
6941 break;
6942
6943 case 30: hash_type = HASH_TYPE_MD5;
6944 salt_type = SALT_TYPE_INTERN;
6945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6946 opts_type = OPTS_TYPE_PT_GENERATE_LE
6947 | OPTS_TYPE_PT_UNICODE
6948 | OPTS_TYPE_ST_ADD80
6949 | OPTS_TYPE_ST_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_PWUSLT;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = md5s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_MEET_IN_MIDDLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_APPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 0;
6963 dgst_pos1 = 3;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 40: hash_type = HASH_TYPE_MD5;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_LE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS14
6974 | OPTS_TYPE_PT_UNICODE;
6975 kern_type = KERN_TYPE_MD5_SLTPWU;
6976 dgst_size = DGST_SIZE_4_4;
6977 parse_func = md5s_parse_hash;
6978 sort_by_digest = sort_by_digest_4_4;
6979 opti_type = OPTI_TYPE_ZERO_BYTE
6980 | OPTI_TYPE_PRECOMPUTE_INIT
6981 | OPTI_TYPE_PRECOMPUTE_MERKLE
6982 | OPTI_TYPE_EARLY_SKIP
6983 | OPTI_TYPE_NOT_ITERATED
6984 | OPTI_TYPE_PREPENDED_SALT
6985 | OPTI_TYPE_RAW_HASH;
6986 dgst_pos0 = 0;
6987 dgst_pos1 = 3;
6988 dgst_pos2 = 2;
6989 dgst_pos3 = 1;
6990 break;
6991
6992 case 50: hash_type = HASH_TYPE_MD5;
6993 salt_type = SALT_TYPE_INTERN;
6994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6995 opts_type = OPTS_TYPE_PT_GENERATE_LE
6996 | OPTS_TYPE_ST_ADD80
6997 | OPTS_TYPE_ST_ADDBITS14;
6998 kern_type = KERN_TYPE_HMACMD5_PW;
6999 dgst_size = DGST_SIZE_4_4;
7000 parse_func = hmacmd5_parse_hash;
7001 sort_by_digest = sort_by_digest_4_4;
7002 opti_type = OPTI_TYPE_ZERO_BYTE
7003 | OPTI_TYPE_NOT_ITERATED;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 60: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_INTERN;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS14;
7016 kern_type = KERN_TYPE_HMACMD5_SLT;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = hmacmd5_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_NOT_ITERATED;
7022 dgst_pos0 = 0;
7023 dgst_pos1 = 3;
7024 dgst_pos2 = 2;
7025 dgst_pos3 = 1;
7026 break;
7027
7028 case 100: hash_type = HASH_TYPE_SHA1;
7029 salt_type = SALT_TYPE_NONE;
7030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7031 opts_type = OPTS_TYPE_PT_GENERATE_BE
7032 | OPTS_TYPE_PT_ADD80
7033 | OPTS_TYPE_PT_ADDBITS15;
7034 kern_type = KERN_TYPE_SHA1;
7035 dgst_size = DGST_SIZE_4_5;
7036 parse_func = sha1_parse_hash;
7037 sort_by_digest = sort_by_digest_4_5;
7038 opti_type = OPTI_TYPE_ZERO_BYTE
7039 | OPTI_TYPE_PRECOMPUTE_INIT
7040 | OPTI_TYPE_PRECOMPUTE_MERKLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_NOT_SALTED
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 3;
7046 dgst_pos1 = 4;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 101: hash_type = HASH_TYPE_SHA1;
7052 salt_type = SALT_TYPE_NONE;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_BE
7055 | OPTS_TYPE_PT_ADD80
7056 | OPTS_TYPE_PT_ADDBITS15;
7057 kern_type = KERN_TYPE_SHA1;
7058 dgst_size = DGST_SIZE_4_5;
7059 parse_func = sha1b64_parse_hash;
7060 sort_by_digest = sort_by_digest_4_5;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_PRECOMPUTE_INIT
7063 | OPTI_TYPE_PRECOMPUTE_MERKLE
7064 | OPTI_TYPE_EARLY_SKIP
7065 | OPTI_TYPE_NOT_ITERATED
7066 | OPTI_TYPE_NOT_SALTED
7067 | OPTI_TYPE_RAW_HASH;
7068 dgst_pos0 = 3;
7069 dgst_pos1 = 4;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 110: hash_type = HASH_TYPE_SHA1;
7075 salt_type = SALT_TYPE_INTERN;
7076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7077 opts_type = OPTS_TYPE_PT_GENERATE_BE
7078 | OPTS_TYPE_ST_ADD80
7079 | OPTS_TYPE_ST_ADDBITS15;
7080 kern_type = KERN_TYPE_SHA1_PWSLT;
7081 dgst_size = DGST_SIZE_4_5;
7082 parse_func = sha1s_parse_hash;
7083 sort_by_digest = sort_by_digest_4_5;
7084 opti_type = OPTI_TYPE_ZERO_BYTE
7085 | OPTI_TYPE_PRECOMPUTE_INIT
7086 | OPTI_TYPE_PRECOMPUTE_MERKLE
7087 | OPTI_TYPE_EARLY_SKIP
7088 | OPTI_TYPE_NOT_ITERATED
7089 | OPTI_TYPE_APPENDED_SALT
7090 | OPTI_TYPE_RAW_HASH;
7091 dgst_pos0 = 3;
7092 dgst_pos1 = 4;
7093 dgst_pos2 = 2;
7094 dgst_pos3 = 1;
7095 break;
7096
7097 case 111: hash_type = HASH_TYPE_SHA1;
7098 salt_type = SALT_TYPE_EMBEDDED;
7099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7100 opts_type = OPTS_TYPE_PT_GENERATE_BE
7101 | OPTS_TYPE_ST_ADD80
7102 | OPTS_TYPE_ST_ADDBITS15;
7103 kern_type = KERN_TYPE_SHA1_PWSLT;
7104 dgst_size = DGST_SIZE_4_5;
7105 parse_func = sha1b64s_parse_hash;
7106 sort_by_digest = sort_by_digest_4_5;
7107 opti_type = OPTI_TYPE_ZERO_BYTE
7108 | OPTI_TYPE_PRECOMPUTE_INIT
7109 | OPTI_TYPE_PRECOMPUTE_MERKLE
7110 | OPTI_TYPE_EARLY_SKIP
7111 | OPTI_TYPE_NOT_ITERATED
7112 | OPTI_TYPE_APPENDED_SALT
7113 | OPTI_TYPE_RAW_HASH;
7114 dgst_pos0 = 3;
7115 dgst_pos1 = 4;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 112: hash_type = HASH_TYPE_SHA1;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_BE
7124 | OPTS_TYPE_ST_ADD80
7125 | OPTS_TYPE_ST_ADDBITS15
7126 | OPTS_TYPE_ST_HEX;
7127 kern_type = KERN_TYPE_SHA1_PWSLT;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = oracles_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_APPENDED_SALT
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 120: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_INTERN;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1_SLTPW;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1s_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_PREPENDED_SALT
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 121: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_PT_ADD80
7172 | OPTS_TYPE_PT_ADDBITS15
7173 | OPTS_TYPE_ST_LOWER;
7174 kern_type = KERN_TYPE_SHA1_SLTPW;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = smf_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_PREPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 122: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_EMBEDDED;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_PT_ADD80
7196 | OPTS_TYPE_PT_ADDBITS15
7197 | OPTS_TYPE_ST_HEX;
7198 kern_type = KERN_TYPE_SHA1_SLTPW;
7199 dgst_size = DGST_SIZE_4_5;
7200 parse_func = osx1_parse_hash;
7201 sort_by_digest = sort_by_digest_4_5;
7202 opti_type = OPTI_TYPE_ZERO_BYTE
7203 | OPTI_TYPE_PRECOMPUTE_INIT
7204 | OPTI_TYPE_PRECOMPUTE_MERKLE
7205 | OPTI_TYPE_EARLY_SKIP
7206 | OPTI_TYPE_NOT_ITERATED
7207 | OPTI_TYPE_PREPENDED_SALT
7208 | OPTI_TYPE_RAW_HASH;
7209 dgst_pos0 = 3;
7210 dgst_pos1 = 4;
7211 dgst_pos2 = 2;
7212 dgst_pos3 = 1;
7213 break;
7214
7215 case 124: hash_type = HASH_TYPE_SHA1;
7216 salt_type = SALT_TYPE_EMBEDDED;
7217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7218 opts_type = OPTS_TYPE_PT_GENERATE_BE
7219 | OPTS_TYPE_PT_ADD80
7220 | OPTS_TYPE_PT_ADDBITS15;
7221 kern_type = KERN_TYPE_SHA1_SLTPW;
7222 dgst_size = DGST_SIZE_4_5;
7223 parse_func = djangosha1_parse_hash;
7224 sort_by_digest = sort_by_digest_4_5;
7225 opti_type = OPTI_TYPE_ZERO_BYTE
7226 | OPTI_TYPE_PRECOMPUTE_INIT
7227 | OPTI_TYPE_PRECOMPUTE_MERKLE
7228 | OPTI_TYPE_EARLY_SKIP
7229 | OPTI_TYPE_NOT_ITERATED
7230 | OPTI_TYPE_PREPENDED_SALT
7231 | OPTI_TYPE_RAW_HASH;
7232 dgst_pos0 = 3;
7233 dgst_pos1 = 4;
7234 dgst_pos2 = 2;
7235 dgst_pos3 = 1;
7236 break;
7237
7238 case 130: hash_type = HASH_TYPE_SHA1;
7239 salt_type = SALT_TYPE_INTERN;
7240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7241 opts_type = OPTS_TYPE_PT_GENERATE_BE
7242 | OPTS_TYPE_PT_UNICODE
7243 | OPTS_TYPE_ST_ADD80
7244 | OPTS_TYPE_ST_ADDBITS15;
7245 kern_type = KERN_TYPE_SHA1_PWUSLT;
7246 dgst_size = DGST_SIZE_4_5;
7247 parse_func = sha1s_parse_hash;
7248 sort_by_digest = sort_by_digest_4_5;
7249 opti_type = OPTI_TYPE_ZERO_BYTE
7250 | OPTI_TYPE_PRECOMPUTE_INIT
7251 | OPTI_TYPE_PRECOMPUTE_MERKLE
7252 | OPTI_TYPE_EARLY_SKIP
7253 | OPTI_TYPE_NOT_ITERATED
7254 | OPTI_TYPE_APPENDED_SALT
7255 | OPTI_TYPE_RAW_HASH;
7256 dgst_pos0 = 3;
7257 dgst_pos1 = 4;
7258 dgst_pos2 = 2;
7259 dgst_pos3 = 1;
7260 break;
7261
7262 case 131: hash_type = HASH_TYPE_SHA1;
7263 salt_type = SALT_TYPE_EMBEDDED;
7264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7265 opts_type = OPTS_TYPE_PT_GENERATE_BE
7266 | OPTS_TYPE_PT_UNICODE
7267 | OPTS_TYPE_PT_UPPER
7268 | OPTS_TYPE_ST_ADD80
7269 | OPTS_TYPE_ST_ADDBITS15
7270 | OPTS_TYPE_ST_HEX;
7271 kern_type = KERN_TYPE_SHA1_PWUSLT;
7272 dgst_size = DGST_SIZE_4_5;
7273 parse_func = mssql2000_parse_hash;
7274 sort_by_digest = sort_by_digest_4_5;
7275 opti_type = OPTI_TYPE_ZERO_BYTE
7276 | OPTI_TYPE_PRECOMPUTE_INIT
7277 | OPTI_TYPE_PRECOMPUTE_MERKLE
7278 | OPTI_TYPE_EARLY_SKIP
7279 | OPTI_TYPE_NOT_ITERATED
7280 | OPTI_TYPE_APPENDED_SALT
7281 | OPTI_TYPE_RAW_HASH;
7282 dgst_pos0 = 3;
7283 dgst_pos1 = 4;
7284 dgst_pos2 = 2;
7285 dgst_pos3 = 1;
7286 break;
7287
7288 case 132: hash_type = HASH_TYPE_SHA1;
7289 salt_type = SALT_TYPE_EMBEDDED;
7290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7291 opts_type = OPTS_TYPE_PT_GENERATE_BE
7292 | OPTS_TYPE_PT_UNICODE
7293 | OPTS_TYPE_ST_ADD80
7294 | OPTS_TYPE_ST_ADDBITS15
7295 | OPTS_TYPE_ST_HEX;
7296 kern_type = KERN_TYPE_SHA1_PWUSLT;
7297 dgst_size = DGST_SIZE_4_5;
7298 parse_func = mssql2005_parse_hash;
7299 sort_by_digest = sort_by_digest_4_5;
7300 opti_type = OPTI_TYPE_ZERO_BYTE
7301 | OPTI_TYPE_PRECOMPUTE_INIT
7302 | OPTI_TYPE_PRECOMPUTE_MERKLE
7303 | OPTI_TYPE_EARLY_SKIP
7304 | OPTI_TYPE_NOT_ITERATED
7305 | OPTI_TYPE_APPENDED_SALT
7306 | OPTI_TYPE_RAW_HASH;
7307 dgst_pos0 = 3;
7308 dgst_pos1 = 4;
7309 dgst_pos2 = 2;
7310 dgst_pos3 = 1;
7311 break;
7312
7313 case 133: hash_type = HASH_TYPE_SHA1;
7314 salt_type = SALT_TYPE_EMBEDDED;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_BE
7317 | OPTS_TYPE_PT_UNICODE
7318 | OPTS_TYPE_ST_ADD80
7319 | OPTS_TYPE_ST_ADDBITS15;
7320 kern_type = KERN_TYPE_SHA1_PWUSLT;
7321 dgst_size = DGST_SIZE_4_5;
7322 parse_func = peoplesoft_parse_hash;
7323 sort_by_digest = sort_by_digest_4_5;
7324 opti_type = OPTI_TYPE_ZERO_BYTE
7325 | OPTI_TYPE_PRECOMPUTE_INIT
7326 | OPTI_TYPE_PRECOMPUTE_MERKLE
7327 | OPTI_TYPE_EARLY_SKIP
7328 | OPTI_TYPE_NOT_ITERATED
7329 | OPTI_TYPE_APPENDED_SALT
7330 | OPTI_TYPE_RAW_HASH;
7331 dgst_pos0 = 3;
7332 dgst_pos1 = 4;
7333 dgst_pos2 = 2;
7334 dgst_pos3 = 1;
7335 break;
7336
7337 case 140: hash_type = HASH_TYPE_SHA1;
7338 salt_type = SALT_TYPE_INTERN;
7339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7340 opts_type = OPTS_TYPE_PT_GENERATE_BE
7341 | OPTS_TYPE_PT_ADD80
7342 | OPTS_TYPE_PT_ADDBITS15
7343 | OPTS_TYPE_PT_UNICODE;
7344 kern_type = KERN_TYPE_SHA1_SLTPWU;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = sha1s_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_PREPENDED_SALT
7354 | OPTI_TYPE_RAW_HASH;
7355 dgst_pos0 = 3;
7356 dgst_pos1 = 4;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 141: hash_type = HASH_TYPE_SHA1;
7362 salt_type = SALT_TYPE_EMBEDDED;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_BE
7365 | OPTS_TYPE_PT_ADD80
7366 | OPTS_TYPE_PT_ADDBITS15
7367 | OPTS_TYPE_PT_UNICODE
7368 | OPTS_TYPE_ST_BASE64;
7369 kern_type = KERN_TYPE_SHA1_SLTPWU;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = episerver_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_PREPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 150: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_INTERN;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_ST_ADD80
7391 | OPTS_TYPE_ST_ADDBITS15;
7392 kern_type = KERN_TYPE_HMACSHA1_PW;
7393 dgst_size = DGST_SIZE_4_5;
7394 parse_func = hmacsha1_parse_hash;
7395 sort_by_digest = sort_by_digest_4_5;
7396 opti_type = OPTI_TYPE_ZERO_BYTE
7397 | OPTI_TYPE_NOT_ITERATED;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 4;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 1;
7402 break;
7403
7404 case 160: hash_type = HASH_TYPE_SHA1;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_PT_ADD80
7409 | OPTS_TYPE_PT_ADDBITS15;
7410 kern_type = KERN_TYPE_HMACSHA1_SLT;
7411 dgst_size = DGST_SIZE_4_5;
7412 parse_func = hmacsha1_parse_hash;
7413 sort_by_digest = sort_by_digest_4_5;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_NOT_ITERATED;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 190: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_NONE;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_ADD80
7427 | OPTS_TYPE_PT_ADDBITS15;
7428 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7429 dgst_size = DGST_SIZE_4_5;
7430 parse_func = sha1linkedin_parse_hash;
7431 sort_by_digest = sort_by_digest_4_5;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_NOT_SALTED;
7437 dgst_pos0 = 0;
7438 dgst_pos1 = 4;
7439 dgst_pos2 = 3;
7440 dgst_pos3 = 2;
7441 break;
7442
7443 case 200: hash_type = HASH_TYPE_MYSQL;
7444 salt_type = SALT_TYPE_NONE;
7445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7446 opts_type = 0;
7447 kern_type = KERN_TYPE_MYSQL;
7448 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7449 parse_func = mysql323_parse_hash;
7450 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7451 opti_type = OPTI_TYPE_ZERO_BYTE;
7452 dgst_pos0 = 0;
7453 dgst_pos1 = 1;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 3;
7456 break;
7457
7458 case 300: hash_type = HASH_TYPE_SHA1;
7459 salt_type = SALT_TYPE_NONE;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_BE
7462 | OPTS_TYPE_PT_ADD80
7463 | OPTS_TYPE_PT_ADDBITS15;
7464 kern_type = KERN_TYPE_MYSQL41;
7465 dgst_size = DGST_SIZE_4_5;
7466 parse_func = sha1_parse_hash;
7467 sort_by_digest = sort_by_digest_4_5;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_EARLY_SKIP
7472 | OPTI_TYPE_NOT_ITERATED
7473 | OPTI_TYPE_NOT_SALTED;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 4;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 400: hash_type = HASH_TYPE_MD5;
7481 salt_type = SALT_TYPE_EMBEDDED;
7482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7484 kern_type = KERN_TYPE_PHPASS;
7485 dgst_size = DGST_SIZE_4_4;
7486 parse_func = phpass_parse_hash;
7487 sort_by_digest = sort_by_digest_4_4;
7488 opti_type = OPTI_TYPE_ZERO_BYTE;
7489 dgst_pos0 = 0;
7490 dgst_pos1 = 1;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 3;
7493 break;
7494
7495 case 500: hash_type = HASH_TYPE_MD5;
7496 salt_type = SALT_TYPE_EMBEDDED;
7497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7499 kern_type = KERN_TYPE_MD5CRYPT;
7500 dgst_size = DGST_SIZE_4_4;
7501 parse_func = md5crypt_parse_hash;
7502 sort_by_digest = sort_by_digest_4_4;
7503 opti_type = OPTI_TYPE_ZERO_BYTE;
7504 dgst_pos0 = 0;
7505 dgst_pos1 = 1;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 3;
7508 break;
7509
7510 case 501: hash_type = HASH_TYPE_MD5;
7511 salt_type = SALT_TYPE_EMBEDDED;
7512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_LE
7514 | OPTS_TYPE_HASH_COPY;
7515 kern_type = KERN_TYPE_MD5CRYPT;
7516 dgst_size = DGST_SIZE_4_4;
7517 parse_func = juniper_parse_hash;
7518 sort_by_digest = sort_by_digest_4_4;
7519 opti_type = OPTI_TYPE_ZERO_BYTE;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 1;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 3;
7524 break;
7525
7526 case 900: hash_type = HASH_TYPE_MD4;
7527 salt_type = SALT_TYPE_NONE;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_LE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS14;
7532 kern_type = KERN_TYPE_MD4;
7533 dgst_size = DGST_SIZE_4_4;
7534 parse_func = md4_parse_hash;
7535 sort_by_digest = sort_by_digest_4_4;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_MEET_IN_MIDDLE
7540 | OPTI_TYPE_EARLY_SKIP
7541 | OPTI_TYPE_NOT_ITERATED
7542 | OPTI_TYPE_NOT_SALTED
7543 | OPTI_TYPE_RAW_HASH;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 3;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 1;
7548 break;
7549
7550 case 1000: hash_type = HASH_TYPE_MD4;
7551 salt_type = SALT_TYPE_NONE;
7552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_LE
7554 | OPTS_TYPE_PT_ADD80
7555 | OPTS_TYPE_PT_ADDBITS14
7556 | OPTS_TYPE_PT_UNICODE;
7557 kern_type = KERN_TYPE_MD4_PWU;
7558 dgst_size = DGST_SIZE_4_4;
7559 parse_func = md4_parse_hash;
7560 sort_by_digest = sort_by_digest_4_4;
7561 opti_type = OPTI_TYPE_ZERO_BYTE
7562 | OPTI_TYPE_PRECOMPUTE_INIT
7563 | OPTI_TYPE_PRECOMPUTE_MERKLE
7564 | OPTI_TYPE_MEET_IN_MIDDLE
7565 | OPTI_TYPE_EARLY_SKIP
7566 | OPTI_TYPE_NOT_ITERATED
7567 | OPTI_TYPE_NOT_SALTED
7568 | OPTI_TYPE_RAW_HASH;
7569 dgst_pos0 = 0;
7570 dgst_pos1 = 3;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 1;
7573 break;
7574
7575 case 1100: hash_type = HASH_TYPE_MD4;
7576 salt_type = SALT_TYPE_INTERN;
7577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_LE
7579 | OPTS_TYPE_PT_ADD80
7580 | OPTS_TYPE_PT_ADDBITS14
7581 | OPTS_TYPE_PT_UNICODE
7582 | OPTS_TYPE_ST_ADD80
7583 | OPTS_TYPE_ST_UNICODE
7584 | OPTS_TYPE_ST_LOWER;
7585 kern_type = KERN_TYPE_MD44_PWUSLT;
7586 dgst_size = DGST_SIZE_4_4;
7587 parse_func = dcc_parse_hash;
7588 sort_by_digest = sort_by_digest_4_4;
7589 opti_type = OPTI_TYPE_ZERO_BYTE
7590 | OPTI_TYPE_PRECOMPUTE_INIT
7591 | OPTI_TYPE_PRECOMPUTE_MERKLE
7592 | OPTI_TYPE_EARLY_SKIP
7593 | OPTI_TYPE_NOT_ITERATED;
7594 dgst_pos0 = 0;
7595 dgst_pos1 = 3;
7596 dgst_pos2 = 2;
7597 dgst_pos3 = 1;
7598 break;
7599
7600 case 1400: hash_type = HASH_TYPE_SHA256;
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_SHA256;
7607 dgst_size = DGST_SIZE_4_8;
7608 parse_func = sha256_parse_hash;
7609 sort_by_digest = sort_by_digest_4_8;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_NOT_SALTED
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 3;
7618 dgst_pos1 = 7;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 6;
7621 break;
7622
7623 case 1410: hash_type = HASH_TYPE_SHA256;
7624 salt_type = SALT_TYPE_INTERN;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA256_PWSLT;
7630 dgst_size = DGST_SIZE_4_8;
7631 parse_func = sha256s_parse_hash;
7632 sort_by_digest = sort_by_digest_4_8;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 3;
7641 dgst_pos1 = 7;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 6;
7644 break;
7645
7646 case 1420: hash_type = HASH_TYPE_SHA256;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_PT_ADD80
7651 | OPTS_TYPE_PT_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA256_SLTPW;
7653 dgst_size = DGST_SIZE_4_8;
7654 parse_func = sha256s_parse_hash;
7655 sort_by_digest = sort_by_digest_4_8;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_PREPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 3;
7664 dgst_pos1 = 7;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 6;
7667 break;
7668
7669 case 1421: hash_type = HASH_TYPE_SHA256;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15;
7675 kern_type = KERN_TYPE_SHA256_SLTPW;
7676 dgst_size = DGST_SIZE_4_8;
7677 parse_func = hmailserver_parse_hash;
7678 sort_by_digest = sort_by_digest_4_8;
7679 opti_type = OPTI_TYPE_ZERO_BYTE
7680 | OPTI_TYPE_PRECOMPUTE_INIT
7681 | OPTI_TYPE_PRECOMPUTE_MERKLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_PREPENDED_SALT
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 3;
7687 dgst_pos1 = 7;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 6;
7690 break;
7691
7692 case 1430: hash_type = HASH_TYPE_SHA256;
7693 salt_type = SALT_TYPE_INTERN;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_BE
7696 | OPTS_TYPE_PT_UNICODE
7697 | OPTS_TYPE_ST_ADD80
7698 | OPTS_TYPE_ST_ADDBITS15;
7699 kern_type = KERN_TYPE_SHA256_PWUSLT;
7700 dgst_size = DGST_SIZE_4_8;
7701 parse_func = sha256s_parse_hash;
7702 sort_by_digest = sort_by_digest_4_8;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_APPENDED_SALT
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 7;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 6;
7714 break;
7715
7716 case 1440: hash_type = HASH_TYPE_SHA256;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_PT_ADD80
7721 | OPTS_TYPE_PT_ADDBITS15
7722 | OPTS_TYPE_PT_UNICODE;
7723 kern_type = KERN_TYPE_SHA256_SLTPWU;
7724 dgst_size = DGST_SIZE_4_8;
7725 parse_func = sha256s_parse_hash;
7726 sort_by_digest = sort_by_digest_4_8;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_PREPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 7;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 6;
7738 break;
7739
7740 case 1441: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS15
7746 | OPTS_TYPE_PT_UNICODE
7747 | OPTS_TYPE_ST_BASE64;
7748 kern_type = KERN_TYPE_SHA256_SLTPWU;
7749 dgst_size = DGST_SIZE_4_8;
7750 parse_func = episerver4_parse_hash;
7751 sort_by_digest = sort_by_digest_4_8;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1450: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_ST_ADD80;
7770 kern_type = KERN_TYPE_HMACSHA256_PW;
7771 dgst_size = DGST_SIZE_4_8;
7772 parse_func = hmacsha256_parse_hash;
7773 sort_by_digest = sort_by_digest_4_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_NOT_ITERATED;
7776 dgst_pos0 = 3;
7777 dgst_pos1 = 7;
7778 dgst_pos2 = 2;
7779 dgst_pos3 = 6;
7780 break;
7781
7782 case 1460: hash_type = HASH_TYPE_SHA256;
7783 salt_type = SALT_TYPE_INTERN;
7784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_BE
7786 | OPTS_TYPE_PT_ADD80
7787 | OPTS_TYPE_PT_ADDBITS15;
7788 kern_type = KERN_TYPE_HMACSHA256_SLT;
7789 dgst_size = DGST_SIZE_4_8;
7790 parse_func = hmacsha256_parse_hash;
7791 sort_by_digest = sort_by_digest_4_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_NOT_ITERATED;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 7;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 6;
7798 break;
7799
7800 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7801 salt_type = SALT_TYPE_EMBEDDED;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_LE
7804 | OPTS_TYPE_PT_BITSLICE;
7805 kern_type = KERN_TYPE_DESCRYPT;
7806 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7807 parse_func = descrypt_parse_hash;
7808 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7811 dgst_pos0 = 0;
7812 dgst_pos1 = 1;
7813 dgst_pos2 = 2;
7814 dgst_pos3 = 3;
7815 break;
7816
7817 case 1600: hash_type = HASH_TYPE_MD5;
7818 salt_type = SALT_TYPE_EMBEDDED;
7819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7821 kern_type = KERN_TYPE_APR1CRYPT;
7822 dgst_size = DGST_SIZE_4_4;
7823 parse_func = md5apr1_parse_hash;
7824 sort_by_digest = sort_by_digest_4_4;
7825 opti_type = OPTI_TYPE_ZERO_BYTE;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 1;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 3;
7830 break;
7831
7832 case 1700: hash_type = HASH_TYPE_SHA512;
7833 salt_type = SALT_TYPE_NONE;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_BE
7836 | OPTS_TYPE_PT_ADD80
7837 | OPTS_TYPE_PT_ADDBITS15;
7838 kern_type = KERN_TYPE_SHA512;
7839 dgst_size = DGST_SIZE_8_8;
7840 parse_func = sha512_parse_hash;
7841 sort_by_digest = sort_by_digest_8_8;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED
7847 | OPTI_TYPE_NOT_SALTED
7848 | OPTI_TYPE_USES_BITS_64
7849 | OPTI_TYPE_RAW_HASH;
7850 dgst_pos0 = 14;
7851 dgst_pos1 = 15;
7852 dgst_pos2 = 6;
7853 dgst_pos3 = 7;
7854 break;
7855
7856 case 1710: hash_type = HASH_TYPE_SHA512;
7857 salt_type = SALT_TYPE_INTERN;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_BE
7860 | OPTS_TYPE_ST_ADD80
7861 | OPTS_TYPE_ST_ADDBITS15;
7862 kern_type = KERN_TYPE_SHA512_PWSLT;
7863 dgst_size = DGST_SIZE_8_8;
7864 parse_func = sha512s_parse_hash;
7865 sort_by_digest = sort_by_digest_8_8;
7866 opti_type = OPTI_TYPE_ZERO_BYTE
7867 | OPTI_TYPE_PRECOMPUTE_INIT
7868 | OPTI_TYPE_PRECOMPUTE_MERKLE
7869 | OPTI_TYPE_EARLY_SKIP
7870 | OPTI_TYPE_NOT_ITERATED
7871 | OPTI_TYPE_APPENDED_SALT
7872 | OPTI_TYPE_USES_BITS_64
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 14;
7875 dgst_pos1 = 15;
7876 dgst_pos2 = 6;
7877 dgst_pos3 = 7;
7878 break;
7879
7880 case 1711: hash_type = HASH_TYPE_SHA512;
7881 salt_type = SALT_TYPE_EMBEDDED;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_ST_ADD80
7885 | OPTS_TYPE_ST_ADDBITS15;
7886 kern_type = KERN_TYPE_SHA512_PWSLT;
7887 dgst_size = DGST_SIZE_8_8;
7888 parse_func = sha512b64s_parse_hash;
7889 sort_by_digest = sort_by_digest_8_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_PRECOMPUTE_INIT
7892 | OPTI_TYPE_PRECOMPUTE_MERKLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_APPENDED_SALT
7896 | OPTI_TYPE_USES_BITS_64
7897 | OPTI_TYPE_RAW_HASH;
7898 dgst_pos0 = 14;
7899 dgst_pos1 = 15;
7900 dgst_pos2 = 6;
7901 dgst_pos3 = 7;
7902 break;
7903
7904 case 1720: hash_type = HASH_TYPE_SHA512;
7905 salt_type = SALT_TYPE_INTERN;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_BE
7908 | OPTS_TYPE_PT_ADD80
7909 | OPTS_TYPE_PT_ADDBITS15;
7910 kern_type = KERN_TYPE_SHA512_SLTPW;
7911 dgst_size = DGST_SIZE_8_8;
7912 parse_func = sha512s_parse_hash;
7913 sort_by_digest = sort_by_digest_8_8;
7914 opti_type = OPTI_TYPE_ZERO_BYTE
7915 | OPTI_TYPE_PRECOMPUTE_INIT
7916 | OPTI_TYPE_PRECOMPUTE_MERKLE
7917 | OPTI_TYPE_EARLY_SKIP
7918 | OPTI_TYPE_NOT_ITERATED
7919 | OPTI_TYPE_PREPENDED_SALT
7920 | OPTI_TYPE_USES_BITS_64
7921 | OPTI_TYPE_RAW_HASH;
7922 dgst_pos0 = 14;
7923 dgst_pos1 = 15;
7924 dgst_pos2 = 6;
7925 dgst_pos3 = 7;
7926 break;
7927
7928 case 1722: hash_type = HASH_TYPE_SHA512;
7929 salt_type = SALT_TYPE_EMBEDDED;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15
7934 | OPTS_TYPE_ST_HEX;
7935 kern_type = KERN_TYPE_SHA512_SLTPW;
7936 dgst_size = DGST_SIZE_8_8;
7937 parse_func = osx512_parse_hash;
7938 sort_by_digest = sort_by_digest_8_8;
7939 opti_type = OPTI_TYPE_ZERO_BYTE
7940 | OPTI_TYPE_PRECOMPUTE_INIT
7941 | OPTI_TYPE_PRECOMPUTE_MERKLE
7942 | OPTI_TYPE_EARLY_SKIP
7943 | OPTI_TYPE_NOT_ITERATED
7944 | OPTI_TYPE_PREPENDED_SALT
7945 | OPTI_TYPE_USES_BITS_64
7946 | OPTI_TYPE_RAW_HASH;
7947 dgst_pos0 = 14;
7948 dgst_pos1 = 15;
7949 dgst_pos2 = 6;
7950 dgst_pos3 = 7;
7951 break;
7952
7953 case 1730: hash_type = HASH_TYPE_SHA512;
7954 salt_type = SALT_TYPE_INTERN;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_PT_UNICODE
7958 | OPTS_TYPE_ST_ADD80
7959 | OPTS_TYPE_ST_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA512_PWSLTU;
7961 dgst_size = DGST_SIZE_8_8;
7962 parse_func = sha512s_parse_hash;
7963 sort_by_digest = sort_by_digest_8_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_APPENDED_SALT
7970 | OPTI_TYPE_USES_BITS_64
7971 | OPTI_TYPE_RAW_HASH;
7972 dgst_pos0 = 14;
7973 dgst_pos1 = 15;
7974 dgst_pos2 = 6;
7975 dgst_pos3 = 7;
7976 break;
7977
7978 case 1731: hash_type = HASH_TYPE_SHA512;
7979 salt_type = SALT_TYPE_EMBEDDED;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_BE
7982 | OPTS_TYPE_PT_UNICODE
7983 | OPTS_TYPE_ST_ADD80
7984 | OPTS_TYPE_ST_ADDBITS15
7985 | OPTS_TYPE_ST_HEX;
7986 kern_type = KERN_TYPE_SHA512_PWSLTU;
7987 dgst_size = DGST_SIZE_8_8;
7988 parse_func = mssql2012_parse_hash;
7989 sort_by_digest = sort_by_digest_8_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_APPENDED_SALT
7996 | OPTI_TYPE_USES_BITS_64
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 14;
7999 dgst_pos1 = 15;
8000 dgst_pos2 = 6;
8001 dgst_pos3 = 7;
8002 break;
8003
8004 case 1740: hash_type = HASH_TYPE_SHA512;
8005 salt_type = SALT_TYPE_INTERN;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_PT_ADD80
8009 | OPTS_TYPE_PT_ADDBITS15
8010 | OPTS_TYPE_PT_UNICODE;
8011 kern_type = KERN_TYPE_SHA512_SLTPWU;
8012 dgst_size = DGST_SIZE_8_8;
8013 parse_func = sha512s_parse_hash;
8014 sort_by_digest = sort_by_digest_8_8;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP
8019 | OPTI_TYPE_NOT_ITERATED
8020 | OPTI_TYPE_PREPENDED_SALT
8021 | OPTI_TYPE_USES_BITS_64
8022 | OPTI_TYPE_RAW_HASH;
8023 dgst_pos0 = 14;
8024 dgst_pos1 = 15;
8025 dgst_pos2 = 6;
8026 dgst_pos3 = 7;
8027 break;
8028
8029 case 1750: hash_type = HASH_TYPE_SHA512;
8030 salt_type = SALT_TYPE_INTERN;
8031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8032 opts_type = OPTS_TYPE_PT_GENERATE_BE
8033 | OPTS_TYPE_ST_ADD80;
8034 kern_type = KERN_TYPE_HMACSHA512_PW;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = hmacsha512_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_USES_BITS_64
8040 | OPTI_TYPE_NOT_ITERATED;
8041 dgst_pos0 = 14;
8042 dgst_pos1 = 15;
8043 dgst_pos2 = 6;
8044 dgst_pos3 = 7;
8045 break;
8046
8047 case 1760: hash_type = HASH_TYPE_SHA512;
8048 salt_type = SALT_TYPE_INTERN;
8049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_BE
8051 | OPTS_TYPE_PT_ADD80
8052 | OPTS_TYPE_PT_ADDBITS15;
8053 kern_type = KERN_TYPE_HMACSHA512_SLT;
8054 dgst_size = DGST_SIZE_8_8;
8055 parse_func = hmacsha512_parse_hash;
8056 sort_by_digest = sort_by_digest_8_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_USES_BITS_64
8059 | OPTI_TYPE_NOT_ITERATED;
8060 dgst_pos0 = 14;
8061 dgst_pos1 = 15;
8062 dgst_pos2 = 6;
8063 dgst_pos3 = 7;
8064 break;
8065
8066 case 1800: hash_type = HASH_TYPE_SHA512;
8067 salt_type = SALT_TYPE_EMBEDDED;
8068 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8069 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8070 kern_type = KERN_TYPE_SHA512CRYPT;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = sha512crypt_parse_hash;
8073 sort_by_digest = sort_by_digest_8_8;
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_USES_BITS_64;
8076 dgst_pos0 = 0;
8077 dgst_pos1 = 1;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 3;
8080 break;
8081
8082 case 2100: hash_type = HASH_TYPE_DCC2;
8083 salt_type = SALT_TYPE_EMBEDDED;
8084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_ST_LOWER
8087 | OPTS_TYPE_ST_UNICODE;
8088 kern_type = KERN_TYPE_DCC2;
8089 dgst_size = DGST_SIZE_4_4;
8090 parse_func = dcc2_parse_hash;
8091 sort_by_digest = sort_by_digest_4_4;
8092 opti_type = OPTI_TYPE_ZERO_BYTE;
8093 dgst_pos0 = 0;
8094 dgst_pos1 = 1;
8095 dgst_pos2 = 2;
8096 dgst_pos3 = 3;
8097 break;
8098
8099 case 2400: hash_type = HASH_TYPE_MD5;
8100 salt_type = SALT_TYPE_NONE;
8101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8103 kern_type = KERN_TYPE_MD5PIX;
8104 dgst_size = DGST_SIZE_4_4;
8105 parse_func = md5pix_parse_hash;
8106 sort_by_digest = sort_by_digest_4_4;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_EARLY_SKIP
8111 | OPTI_TYPE_NOT_ITERATED
8112 | OPTI_TYPE_NOT_SALTED;
8113 dgst_pos0 = 0;
8114 dgst_pos1 = 3;
8115 dgst_pos2 = 2;
8116 dgst_pos3 = 1;
8117 break;
8118
8119 case 2410: hash_type = HASH_TYPE_MD5;
8120 salt_type = SALT_TYPE_INTERN;
8121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8123 kern_type = KERN_TYPE_MD5ASA;
8124 dgst_size = DGST_SIZE_4_4;
8125 parse_func = md5asa_parse_hash;
8126 sort_by_digest = sort_by_digest_4_4;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_PRECOMPUTE_INIT
8129 | OPTI_TYPE_PRECOMPUTE_MERKLE
8130 | OPTI_TYPE_EARLY_SKIP
8131 | OPTI_TYPE_NOT_ITERATED;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 3;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 1;
8136 break;
8137
8138 case 2500: hash_type = HASH_TYPE_WPA;
8139 salt_type = SALT_TYPE_EMBEDDED;
8140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8142 kern_type = KERN_TYPE_WPA;
8143 dgst_size = DGST_SIZE_4_4;
8144 parse_func = wpa_parse_hash;
8145 sort_by_digest = sort_by_digest_4_4;
8146 opti_type = OPTI_TYPE_ZERO_BYTE;
8147 dgst_pos0 = 0;
8148 dgst_pos1 = 1;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 3;
8151 break;
8152
8153 case 2600: hash_type = HASH_TYPE_MD5;
8154 salt_type = SALT_TYPE_VIRTUAL;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_LE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS14
8159 | OPTS_TYPE_ST_ADD80;
8160 kern_type = KERN_TYPE_MD55_PWSLT1;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md5md5_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_EARLY_SKIP;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174 case 2611: hash_type = HASH_TYPE_MD5;
8175 salt_type = SALT_TYPE_INTERN;
8176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_LE
8178 | OPTS_TYPE_PT_ADD80
8179 | OPTS_TYPE_PT_ADDBITS14
8180 | OPTS_TYPE_ST_ADD80;
8181 kern_type = KERN_TYPE_MD55_PWSLT1;
8182 dgst_size = DGST_SIZE_4_4;
8183 parse_func = vb3_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_PRECOMPUTE_INIT
8187 | OPTI_TYPE_PRECOMPUTE_MERKLE
8188 | OPTI_TYPE_EARLY_SKIP;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 3;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 1;
8193 break;
8194
8195 case 2612: hash_type = HASH_TYPE_MD5;
8196 salt_type = SALT_TYPE_EMBEDDED;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_LE
8199 | OPTS_TYPE_PT_ADD80
8200 | OPTS_TYPE_PT_ADDBITS14
8201 | OPTS_TYPE_ST_ADD80
8202 | OPTS_TYPE_ST_HEX;
8203 kern_type = KERN_TYPE_MD55_PWSLT1;
8204 dgst_size = DGST_SIZE_4_4;
8205 parse_func = phps_parse_hash;
8206 sort_by_digest = sort_by_digest_4_4;
8207 opti_type = OPTI_TYPE_ZERO_BYTE
8208 | OPTI_TYPE_PRECOMPUTE_INIT
8209 | OPTI_TYPE_PRECOMPUTE_MERKLE
8210 | OPTI_TYPE_EARLY_SKIP;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 3;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 1;
8215 break;
8216
8217 case 2711: hash_type = HASH_TYPE_MD5;
8218 salt_type = SALT_TYPE_INTERN;
8219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE
8221 | OPTS_TYPE_PT_ADD80
8222 | OPTS_TYPE_PT_ADDBITS14
8223 | OPTS_TYPE_ST_ADD80;
8224 kern_type = KERN_TYPE_MD55_PWSLT2;
8225 dgst_size = DGST_SIZE_4_4;
8226 parse_func = vb30_parse_hash;
8227 sort_by_digest = sort_by_digest_4_4;
8228 opti_type = OPTI_TYPE_ZERO_BYTE
8229 | OPTI_TYPE_PRECOMPUTE_INIT
8230 | OPTI_TYPE_EARLY_SKIP;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 3;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 1;
8235 break;
8236
8237 case 2811: hash_type = HASH_TYPE_MD5;
8238 salt_type = SALT_TYPE_INTERN;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS14;
8243 kern_type = KERN_TYPE_MD55_SLTPW;
8244 dgst_size = DGST_SIZE_4_4;
8245 parse_func = ipb2_parse_hash;
8246 sort_by_digest = sort_by_digest_4_4;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_EARLY_SKIP;
8250 dgst_pos0 = 0;
8251 dgst_pos1 = 3;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 1;
8254 break;
8255
8256 case 3000: hash_type = HASH_TYPE_LM;
8257 salt_type = SALT_TYPE_NONE;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_LE
8260 | OPTS_TYPE_PT_UPPER
8261 | OPTS_TYPE_PT_BITSLICE;
8262 kern_type = KERN_TYPE_LM;
8263 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8264 parse_func = lm_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8268 dgst_pos0 = 0;
8269 dgst_pos1 = 1;
8270 dgst_pos2 = 2;
8271 dgst_pos3 = 3;
8272 break;
8273
8274 case 3100: hash_type = HASH_TYPE_ORACLEH;
8275 salt_type = SALT_TYPE_INTERN;
8276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_LE
8278 | OPTS_TYPE_PT_UPPER
8279 | OPTS_TYPE_ST_UPPER;
8280 kern_type = KERN_TYPE_ORACLEH;
8281 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8282 parse_func = oracleh_parse_hash;
8283 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8284 opti_type = OPTI_TYPE_ZERO_BYTE;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 1;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 3;
8289 break;
8290
8291 case 3200: hash_type = HASH_TYPE_BCRYPT;
8292 salt_type = SALT_TYPE_EMBEDDED;
8293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_LE
8295 | OPTS_TYPE_ST_GENERATE_LE;
8296 kern_type = KERN_TYPE_BCRYPT;
8297 dgst_size = DGST_SIZE_4_6;
8298 parse_func = bcrypt_parse_hash;
8299 sort_by_digest = sort_by_digest_4_6;
8300 opti_type = OPTI_TYPE_ZERO_BYTE;
8301 dgst_pos0 = 0;
8302 dgst_pos1 = 1;
8303 dgst_pos2 = 2;
8304 dgst_pos3 = 3;
8305 break;
8306
8307 case 3710: hash_type = HASH_TYPE_MD5;
8308 salt_type = SALT_TYPE_INTERN;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_LE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS14;
8313 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8314 dgst_size = DGST_SIZE_4_4;
8315 parse_func = md5s_parse_hash;
8316 sort_by_digest = sort_by_digest_4_4;
8317 opti_type = OPTI_TYPE_ZERO_BYTE
8318 | OPTI_TYPE_PRECOMPUTE_INIT
8319 | OPTI_TYPE_PRECOMPUTE_MERKLE
8320 | OPTI_TYPE_EARLY_SKIP;
8321 dgst_pos0 = 0;
8322 dgst_pos1 = 3;
8323 dgst_pos2 = 2;
8324 dgst_pos3 = 1;
8325 break;
8326
8327 case 3711: hash_type = HASH_TYPE_MD5;
8328 salt_type = SALT_TYPE_EMBEDDED;
8329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8330 opts_type = OPTS_TYPE_PT_GENERATE_LE
8331 | OPTS_TYPE_PT_ADD80
8332 | OPTS_TYPE_PT_ADDBITS14;
8333 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8334 dgst_size = DGST_SIZE_4_4;
8335 parse_func = mediawiki_b_parse_hash;
8336 sort_by_digest = sort_by_digest_4_4;
8337 opti_type = OPTI_TYPE_ZERO_BYTE
8338 | OPTI_TYPE_PRECOMPUTE_INIT
8339 | OPTI_TYPE_PRECOMPUTE_MERKLE
8340 | OPTI_TYPE_EARLY_SKIP;
8341 dgst_pos0 = 0;
8342 dgst_pos1 = 3;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 1;
8345 break;
8346
8347 case 3800: hash_type = HASH_TYPE_MD5;
8348 salt_type = SALT_TYPE_INTERN;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_LE
8351 | OPTS_TYPE_ST_ADDBITS14;
8352 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = md5s_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_PRECOMPUTE_MERKLE
8359 | OPTI_TYPE_EARLY_SKIP
8360 | OPTI_TYPE_NOT_ITERATED
8361 | OPTI_TYPE_RAW_HASH;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 3;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 1;
8366 break;
8367
8368 case 4300: hash_type = HASH_TYPE_MD5;
8369 salt_type = SALT_TYPE_VIRTUAL;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_ADD80
8373 | OPTS_TYPE_PT_ADDBITS14
8374 | OPTS_TYPE_ST_ADD80;
8375 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8376 dgst_size = DGST_SIZE_4_4;
8377 parse_func = md5md5_parse_hash;
8378 sort_by_digest = sort_by_digest_4_4;
8379 opti_type = OPTI_TYPE_ZERO_BYTE
8380 | OPTI_TYPE_PRECOMPUTE_INIT
8381 | OPTI_TYPE_PRECOMPUTE_MERKLE
8382 | OPTI_TYPE_EARLY_SKIP;
8383 dgst_pos0 = 0;
8384 dgst_pos1 = 3;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 1;
8387 break;
8388
8389
8390 case 4400: hash_type = HASH_TYPE_MD5;
8391 salt_type = SALT_TYPE_NONE;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_BE
8394 | OPTS_TYPE_PT_ADD80
8395 | OPTS_TYPE_PT_ADDBITS15;
8396 kern_type = KERN_TYPE_MD5_SHA1;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = md5_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_INIT
8402 | OPTI_TYPE_PRECOMPUTE_MERKLE
8403 | OPTI_TYPE_EARLY_SKIP
8404 | OPTI_TYPE_NOT_ITERATED
8405 | OPTI_TYPE_NOT_SALTED
8406 | OPTI_TYPE_RAW_HASH;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 3;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 1;
8411 break;
8412
8413 case 4500: hash_type = HASH_TYPE_SHA1;
8414 salt_type = SALT_TYPE_NONE;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_BE
8417 | OPTS_TYPE_PT_ADD80
8418 | OPTS_TYPE_PT_ADDBITS15;
8419 kern_type = KERN_TYPE_SHA11;
8420 dgst_size = DGST_SIZE_4_5;
8421 parse_func = sha1_parse_hash;
8422 sort_by_digest = sort_by_digest_4_5;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP
8427 | OPTI_TYPE_NOT_SALTED;
8428 dgst_pos0 = 3;
8429 dgst_pos1 = 4;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 1;
8432 break;
8433
8434 case 4700: hash_type = HASH_TYPE_SHA1;
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_ADD80
8439 | OPTS_TYPE_PT_ADDBITS14;
8440 kern_type = KERN_TYPE_SHA1_MD5;
8441 dgst_size = DGST_SIZE_4_5;
8442 parse_func = sha1_parse_hash;
8443 sort_by_digest = sort_by_digest_4_5;
8444 opti_type = OPTI_TYPE_ZERO_BYTE
8445 | OPTI_TYPE_PRECOMPUTE_INIT
8446 | OPTI_TYPE_PRECOMPUTE_MERKLE
8447 | OPTI_TYPE_EARLY_SKIP
8448 | OPTI_TYPE_NOT_ITERATED
8449 | OPTI_TYPE_NOT_SALTED
8450 | OPTI_TYPE_RAW_HASH;
8451 dgst_pos0 = 3;
8452 dgst_pos1 = 4;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 1;
8455 break;
8456
8457 case 4800: hash_type = HASH_TYPE_MD5;
8458 salt_type = SALT_TYPE_EMBEDDED;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_LE
8461 | OPTS_TYPE_PT_ADDBITS14;
8462 kern_type = KERN_TYPE_MD5_CHAP;
8463 dgst_size = DGST_SIZE_4_4;
8464 parse_func = chap_parse_hash;
8465 sort_by_digest = sort_by_digest_4_4;
8466 opti_type = OPTI_TYPE_ZERO_BYTE
8467 | OPTI_TYPE_PRECOMPUTE_INIT
8468 | OPTI_TYPE_PRECOMPUTE_MERKLE
8469 | OPTI_TYPE_MEET_IN_MIDDLE
8470 | OPTI_TYPE_EARLY_SKIP
8471 | OPTI_TYPE_NOT_ITERATED
8472 | OPTI_TYPE_RAW_HASH;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 3;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 1;
8477 break;
8478
8479 case 4900: hash_type = HASH_TYPE_SHA1;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8483 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8484 dgst_size = DGST_SIZE_4_5;
8485 parse_func = sha1s_parse_hash;
8486 sort_by_digest = sort_by_digest_4_5;
8487 opti_type = OPTI_TYPE_ZERO_BYTE
8488 | OPTI_TYPE_PRECOMPUTE_INIT
8489 | OPTI_TYPE_PRECOMPUTE_MERKLE
8490 | OPTI_TYPE_EARLY_SKIP;
8491 dgst_pos0 = 3;
8492 dgst_pos1 = 4;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 5000: hash_type = HASH_TYPE_KECCAK;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_PT_ADD01;
8502 kern_type = KERN_TYPE_KECCAK;
8503 dgst_size = DGST_SIZE_8_25;
8504 parse_func = keccak_parse_hash;
8505 sort_by_digest = sort_by_digest_8_25;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_USES_BITS_64
8508 | OPTI_TYPE_RAW_HASH;
8509 dgst_pos0 = 2;
8510 dgst_pos1 = 3;
8511 dgst_pos2 = 4;
8512 dgst_pos3 = 5;
8513 break;
8514
8515 case 5100: hash_type = HASH_TYPE_MD5H;
8516 salt_type = SALT_TYPE_NONE;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_LE
8519 | OPTS_TYPE_PT_ADD80
8520 | OPTS_TYPE_PT_ADDBITS14;
8521 kern_type = KERN_TYPE_MD5H;
8522 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8523 parse_func = md5half_parse_hash;
8524 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_RAW_HASH;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 5200: hash_type = HASH_TYPE_SHA256;
8534 salt_type = SALT_TYPE_EMBEDDED;
8535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8537 kern_type = KERN_TYPE_PSAFE3;
8538 dgst_size = DGST_SIZE_4_8;
8539 parse_func = psafe3_parse_hash;
8540 sort_by_digest = sort_by_digest_4_8;
8541 opti_type = OPTI_TYPE_ZERO_BYTE;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 5300: hash_type = HASH_TYPE_MD5;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE
8552 | OPTS_TYPE_ST_ADD80;
8553 kern_type = KERN_TYPE_IKEPSK_MD5;
8554 dgst_size = DGST_SIZE_4_4;
8555 parse_func = ikepsk_md5_parse_hash;
8556 sort_by_digest = sort_by_digest_4_4;
8557 opti_type = OPTI_TYPE_ZERO_BYTE;
8558 dgst_pos0 = 0;
8559 dgst_pos1 = 3;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 5400: hash_type = HASH_TYPE_SHA1;
8565 salt_type = SALT_TYPE_EMBEDDED;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_BE
8568 | OPTS_TYPE_ST_ADD80;
8569 kern_type = KERN_TYPE_IKEPSK_SHA1;
8570 dgst_size = DGST_SIZE_4_5;
8571 parse_func = ikepsk_sha1_parse_hash;
8572 sort_by_digest = sort_by_digest_4_5;
8573 opti_type = OPTI_TYPE_ZERO_BYTE;
8574 dgst_pos0 = 3;
8575 dgst_pos1 = 4;
8576 dgst_pos2 = 2;
8577 dgst_pos3 = 1;
8578 break;
8579
8580 case 5500: hash_type = HASH_TYPE_NETNTLM;
8581 salt_type = SALT_TYPE_EMBEDDED;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_LE
8584 | OPTS_TYPE_PT_ADD80
8585 | OPTS_TYPE_PT_ADDBITS14
8586 | OPTS_TYPE_PT_UNICODE
8587 | OPTS_TYPE_ST_HEX;
8588 kern_type = KERN_TYPE_NETNTLMv1;
8589 dgst_size = DGST_SIZE_4_4;
8590 parse_func = netntlmv1_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4;
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8594 dgst_pos0 = 0;
8595 dgst_pos1 = 1;
8596 dgst_pos2 = 2;
8597 dgst_pos3 = 3;
8598 break;
8599
8600 case 5600: hash_type = HASH_TYPE_MD5;
8601 salt_type = SALT_TYPE_EMBEDDED;
8602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8603 opts_type = OPTS_TYPE_PT_GENERATE_LE
8604 | OPTS_TYPE_PT_ADD80
8605 | OPTS_TYPE_PT_ADDBITS14
8606 | OPTS_TYPE_PT_UNICODE;
8607 kern_type = KERN_TYPE_NETNTLMv2;
8608 dgst_size = DGST_SIZE_4_4;
8609 parse_func = netntlmv2_parse_hash;
8610 sort_by_digest = sort_by_digest_4_4;
8611 opti_type = OPTI_TYPE_ZERO_BYTE;
8612 dgst_pos0 = 0;
8613 dgst_pos1 = 3;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 1;
8616 break;
8617
8618 case 5700: hash_type = HASH_TYPE_SHA256;
8619 salt_type = SALT_TYPE_NONE;
8620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_BE
8622 | OPTS_TYPE_PT_ADD80
8623 | OPTS_TYPE_PT_ADDBITS15;
8624 kern_type = KERN_TYPE_SHA256;
8625 dgst_size = DGST_SIZE_4_8;
8626 parse_func = cisco4_parse_hash;
8627 sort_by_digest = sort_by_digest_4_8;
8628 opti_type = OPTI_TYPE_ZERO_BYTE
8629 | OPTI_TYPE_PRECOMPUTE_INIT
8630 | OPTI_TYPE_PRECOMPUTE_MERKLE
8631 | OPTI_TYPE_EARLY_SKIP
8632 | OPTI_TYPE_NOT_ITERATED
8633 | OPTI_TYPE_NOT_SALTED
8634 | OPTI_TYPE_RAW_HASH;
8635 dgst_pos0 = 3;
8636 dgst_pos1 = 7;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 6;
8639 break;
8640
8641 case 5800: hash_type = HASH_TYPE_SHA1;
8642 salt_type = SALT_TYPE_INTERN;
8643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8645 | OPTS_TYPE_ST_ADD80;
8646 kern_type = KERN_TYPE_ANDROIDPIN;
8647 dgst_size = DGST_SIZE_4_5;
8648 parse_func = androidpin_parse_hash;
8649 sort_by_digest = sort_by_digest_4_5;
8650 opti_type = OPTI_TYPE_ZERO_BYTE;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 1;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 3;
8655 break;
8656
8657 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8658 salt_type = SALT_TYPE_NONE;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_PT_ADD80;
8662 kern_type = KERN_TYPE_RIPEMD160;
8663 dgst_size = DGST_SIZE_4_5;
8664 parse_func = ripemd160_parse_hash;
8665 sort_by_digest = sort_by_digest_4_5;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 1;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 3;
8671 break;
8672
8673 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8674 salt_type = SALT_TYPE_NONE;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_BE
8677 | OPTS_TYPE_PT_ADD80;
8678 kern_type = KERN_TYPE_WHIRLPOOL;
8679 dgst_size = DGST_SIZE_4_16;
8680 parse_func = whirlpool_parse_hash;
8681 sort_by_digest = sort_by_digest_4_16;
8682 opti_type = OPTI_TYPE_ZERO_BYTE;
8683 dgst_pos0 = 0;
8684 dgst_pos1 = 1;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 3;
8687 break;
8688
8689 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8690 salt_type = SALT_TYPE_EMBEDDED;
8691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8693 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = truecrypt_parse_hash_2k;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 1;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 3;
8702 break;
8703
8704 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8708 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8709 dgst_size = DGST_SIZE_4_5;
8710 parse_func = truecrypt_parse_hash_2k;
8711 sort_by_digest = sort_by_digest_4_5;
8712 opti_type = OPTI_TYPE_ZERO_BYTE;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 1;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 3;
8717 break;
8718
8719 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8723 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8724 dgst_size = DGST_SIZE_4_5;
8725 parse_func = truecrypt_parse_hash_2k;
8726 sort_by_digest = sort_by_digest_4_5;
8727 opti_type = OPTI_TYPE_ZERO_BYTE;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 1;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 3;
8732 break;
8733
8734 case 6221: hash_type = HASH_TYPE_SHA512;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8738 kern_type = KERN_TYPE_TCSHA512_XTS512;
8739 dgst_size = DGST_SIZE_8_8;
8740 parse_func = truecrypt_parse_hash_1k;
8741 sort_by_digest = sort_by_digest_8_8;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_USES_BITS_64;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 6222: hash_type = HASH_TYPE_SHA512;
8751 salt_type = SALT_TYPE_EMBEDDED;
8752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8754 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8755 dgst_size = DGST_SIZE_8_8;
8756 parse_func = truecrypt_parse_hash_1k;
8757 sort_by_digest = sort_by_digest_8_8;
8758 opti_type = OPTI_TYPE_ZERO_BYTE
8759 | OPTI_TYPE_USES_BITS_64;
8760 dgst_pos0 = 0;
8761 dgst_pos1 = 1;
8762 dgst_pos2 = 2;
8763 dgst_pos3 = 3;
8764 break;
8765
8766 case 6223: hash_type = HASH_TYPE_SHA512;
8767 salt_type = SALT_TYPE_EMBEDDED;
8768 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8769 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8770 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8771 dgst_size = DGST_SIZE_8_8;
8772 parse_func = truecrypt_parse_hash_1k;
8773 sort_by_digest = sort_by_digest_8_8;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_USES_BITS_64;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8786 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8787 dgst_size = DGST_SIZE_4_8;
8788 parse_func = truecrypt_parse_hash_1k;
8789 sort_by_digest = sort_by_digest_4_8;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8801 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8802 dgst_size = DGST_SIZE_4_8;
8803 parse_func = truecrypt_parse_hash_1k;
8804 sort_by_digest = sort_by_digest_4_8;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8813 salt_type = SALT_TYPE_EMBEDDED;
8814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8816 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8817 dgst_size = DGST_SIZE_4_8;
8818 parse_func = truecrypt_parse_hash_1k;
8819 sort_by_digest = sort_by_digest_4_8;
8820 opti_type = OPTI_TYPE_ZERO_BYTE;
8821 dgst_pos0 = 0;
8822 dgst_pos1 = 1;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 3;
8825 break;
8826
8827 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8831 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8832 dgst_size = DGST_SIZE_4_5;
8833 parse_func = truecrypt_parse_hash_1k;
8834 sort_by_digest = sort_by_digest_4_5;
8835 opti_type = OPTI_TYPE_ZERO_BYTE;
8836 dgst_pos0 = 0;
8837 dgst_pos1 = 1;
8838 dgst_pos2 = 2;
8839 dgst_pos3 = 3;
8840 break;
8841
8842 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8843 salt_type = SALT_TYPE_EMBEDDED;
8844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8846 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8847 dgst_size = DGST_SIZE_4_5;
8848 parse_func = truecrypt_parse_hash_1k;
8849 sort_by_digest = sort_by_digest_4_5;
8850 opti_type = OPTI_TYPE_ZERO_BYTE;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 1;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 3;
8855 break;
8856
8857 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8858 salt_type = SALT_TYPE_EMBEDDED;
8859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8861 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8862 dgst_size = DGST_SIZE_4_5;
8863 parse_func = truecrypt_parse_hash_1k;
8864 sort_by_digest = sort_by_digest_4_5;
8865 opti_type = OPTI_TYPE_ZERO_BYTE;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 1;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 3;
8870 break;
8871
8872 case 6300: hash_type = HASH_TYPE_MD5;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8876 kern_type = KERN_TYPE_MD5AIX;
8877 dgst_size = DGST_SIZE_4_4;
8878 parse_func = md5aix_parse_hash;
8879 sort_by_digest = sort_by_digest_4_4;
8880 opti_type = OPTI_TYPE_ZERO_BYTE;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 1;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 3;
8885 break;
8886
8887 case 6400: hash_type = HASH_TYPE_SHA256;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8891 kern_type = KERN_TYPE_SHA256AIX;
8892 dgst_size = DGST_SIZE_4_8;
8893 parse_func = sha256aix_parse_hash;
8894 sort_by_digest = sort_by_digest_4_8;
8895 opti_type = OPTI_TYPE_ZERO_BYTE;
8896 dgst_pos0 = 0;
8897 dgst_pos1 = 1;
8898 dgst_pos2 = 2;
8899 dgst_pos3 = 3;
8900 break;
8901
8902 case 6500: hash_type = HASH_TYPE_SHA512;
8903 salt_type = SALT_TYPE_EMBEDDED;
8904 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8905 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8906 kern_type = KERN_TYPE_SHA512AIX;
8907 dgst_size = DGST_SIZE_8_8;
8908 parse_func = sha512aix_parse_hash;
8909 sort_by_digest = sort_by_digest_8_8;
8910 opti_type = OPTI_TYPE_ZERO_BYTE
8911 | OPTI_TYPE_USES_BITS_64;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 6600: hash_type = HASH_TYPE_AES;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8922 kern_type = KERN_TYPE_AGILEKEY;
8923 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8924 parse_func = agilekey_parse_hash;
8925 sort_by_digest = sort_by_digest_4_5;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6700: hash_type = HASH_TYPE_SHA1;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8937 kern_type = KERN_TYPE_SHA1AIX;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = sha1aix_parse_hash;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6800: hash_type = HASH_TYPE_AES;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_LASTPASS;
8953 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8954 parse_func = lastpass_parse_hash;
8955 sort_by_digest = sort_by_digest_4_8;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6900: hash_type = HASH_TYPE_GOST;
8964 salt_type = SALT_TYPE_NONE;
8965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8967 kern_type = KERN_TYPE_GOST;
8968 dgst_size = DGST_SIZE_4_8;
8969 parse_func = gost_parse_hash;
8970 sort_by_digest = sort_by_digest_4_8;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 7100: hash_type = HASH_TYPE_SHA512;
8979 salt_type = SALT_TYPE_EMBEDDED;
8980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8982 kern_type = KERN_TYPE_PBKDF2_SHA512;
8983 dgst_size = DGST_SIZE_8_16;
8984 parse_func = sha512osx_parse_hash;
8985 sort_by_digest = sort_by_digest_8_16;
8986 opti_type = OPTI_TYPE_ZERO_BYTE
8987 | OPTI_TYPE_USES_BITS_64;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 7200: hash_type = HASH_TYPE_SHA512;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8998 kern_type = KERN_TYPE_PBKDF2_SHA512;
8999 dgst_size = DGST_SIZE_8_16;
9000 parse_func = sha512grub_parse_hash;
9001 sort_by_digest = sort_by_digest_8_16;
9002 opti_type = OPTI_TYPE_ZERO_BYTE
9003 | OPTI_TYPE_USES_BITS_64;
9004 dgst_pos0 = 0;
9005 dgst_pos1 = 1;
9006 dgst_pos2 = 2;
9007 dgst_pos3 = 3;
9008 break;
9009
9010 case 7300: hash_type = HASH_TYPE_SHA1;
9011 salt_type = SALT_TYPE_EMBEDDED;
9012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9013 opts_type = OPTS_TYPE_PT_GENERATE_BE
9014 | OPTS_TYPE_ST_ADD80
9015 | OPTS_TYPE_ST_ADDBITS15;
9016 kern_type = KERN_TYPE_RAKP;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = rakp_parse_hash;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE
9021 | OPTI_TYPE_NOT_ITERATED;
9022 dgst_pos0 = 3;
9023 dgst_pos1 = 4;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 1;
9026 break;
9027
9028 case 7400: hash_type = HASH_TYPE_SHA256;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9032 kern_type = KERN_TYPE_SHA256CRYPT;
9033 dgst_size = DGST_SIZE_4_8;
9034 parse_func = sha256crypt_parse_hash;
9035 sort_by_digest = sort_by_digest_4_8;
9036 opti_type = OPTI_TYPE_ZERO_BYTE;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 7500: hash_type = HASH_TYPE_KRB5PA;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9047 kern_type = KERN_TYPE_KRB5PA;
9048 dgst_size = DGST_SIZE_4_4;
9049 parse_func = krb5pa_parse_hash;
9050 sort_by_digest = sort_by_digest_4_4;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_NOT_ITERATED;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 7600: hash_type = HASH_TYPE_SHA1;
9060 salt_type = SALT_TYPE_INTERN;
9061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_BE
9063 | OPTS_TYPE_PT_ADD80
9064 | OPTS_TYPE_PT_ADDBITS15;
9065 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9066 dgst_size = DGST_SIZE_4_5;
9067 parse_func = redmine_parse_hash;
9068 sort_by_digest = sort_by_digest_4_5;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_PRECOMPUTE_INIT
9071 | OPTI_TYPE_EARLY_SKIP
9072 | OPTI_TYPE_NOT_ITERATED
9073 | OPTI_TYPE_PREPENDED_SALT;
9074 dgst_pos0 = 3;
9075 dgst_pos1 = 4;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 1;
9078 break;
9079
9080 case 7700: hash_type = HASH_TYPE_SAPB;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE
9084 | OPTS_TYPE_PT_UPPER
9085 | OPTS_TYPE_ST_UPPER;
9086 kern_type = KERN_TYPE_SAPB;
9087 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9088 parse_func = sapb_parse_hash;
9089 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9090 opti_type = OPTI_TYPE_ZERO_BYTE
9091 | OPTI_TYPE_PRECOMPUTE_INIT
9092 | OPTI_TYPE_NOT_ITERATED;
9093 dgst_pos0 = 0;
9094 dgst_pos1 = 1;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 3;
9097 break;
9098
9099 case 7800: hash_type = HASH_TYPE_SAPG;
9100 salt_type = SALT_TYPE_EMBEDDED;
9101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_BE
9103 | OPTS_TYPE_ST_ADD80
9104 | OPTS_TYPE_ST_UPPER;
9105 kern_type = KERN_TYPE_SAPG;
9106 dgst_size = DGST_SIZE_4_5;
9107 parse_func = sapg_parse_hash;
9108 sort_by_digest = sort_by_digest_4_5;
9109 opti_type = OPTI_TYPE_ZERO_BYTE
9110 | OPTI_TYPE_PRECOMPUTE_INIT
9111 | OPTI_TYPE_NOT_ITERATED;
9112 dgst_pos0 = 3;
9113 dgst_pos1 = 4;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 1;
9116 break;
9117
9118 case 7900: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_DRUPAL7;
9123 dgst_size = DGST_SIZE_8_8;
9124 parse_func = drupal7_parse_hash;
9125 sort_by_digest = sort_by_digest_8_8;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 8000: hash_type = HASH_TYPE_SHA256;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_BE
9138 | OPTS_TYPE_PT_UNICODE
9139 | OPTS_TYPE_ST_ADD80
9140 | OPTS_TYPE_ST_HEX;
9141 kern_type = KERN_TYPE_SYBASEASE;
9142 dgst_size = DGST_SIZE_4_8;
9143 parse_func = sybasease_parse_hash;
9144 sort_by_digest = sort_by_digest_4_8;
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_PRECOMPUTE_INIT
9147 | OPTI_TYPE_EARLY_SKIP
9148 | OPTI_TYPE_NOT_ITERATED
9149 | OPTI_TYPE_RAW_HASH;
9150 dgst_pos0 = 3;
9151 dgst_pos1 = 7;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 6;
9154 break;
9155
9156 case 8100: hash_type = HASH_TYPE_SHA1;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9160 kern_type = KERN_TYPE_NETSCALER;
9161 dgst_size = DGST_SIZE_4_5;
9162 parse_func = netscaler_parse_hash;
9163 sort_by_digest = sort_by_digest_4_5;
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_PRECOMPUTE_INIT
9166 | OPTI_TYPE_PRECOMPUTE_MERKLE
9167 | OPTI_TYPE_EARLY_SKIP
9168 | OPTI_TYPE_NOT_ITERATED
9169 | OPTI_TYPE_PREPENDED_SALT
9170 | OPTI_TYPE_RAW_HASH;
9171 dgst_pos0 = 3;
9172 dgst_pos1 = 4;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 1;
9175 break;
9176
9177 case 8200: hash_type = HASH_TYPE_SHA256;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9181 kern_type = KERN_TYPE_CLOUDKEY;
9182 dgst_size = DGST_SIZE_4_8;
9183 parse_func = cloudkey_parse_hash;
9184 sort_by_digest = sort_by_digest_4_8;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 8300: hash_type = HASH_TYPE_SHA1;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE
9196 | OPTS_TYPE_ST_HEX
9197 | OPTS_TYPE_ST_ADD80;
9198 kern_type = KERN_TYPE_NSEC3;
9199 dgst_size = DGST_SIZE_4_5;
9200 parse_func = nsec3_parse_hash;
9201 sort_by_digest = sort_by_digest_4_5;
9202 opti_type = OPTI_TYPE_ZERO_BYTE;
9203 dgst_pos0 = 3;
9204 dgst_pos1 = 4;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 1;
9207 break;
9208
9209 case 8400: hash_type = HASH_TYPE_SHA1;
9210 salt_type = SALT_TYPE_INTERN;
9211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9212 opts_type = OPTS_TYPE_PT_GENERATE_BE
9213 | OPTS_TYPE_PT_ADD80
9214 | OPTS_TYPE_PT_ADDBITS15;
9215 kern_type = KERN_TYPE_WBB3;
9216 dgst_size = DGST_SIZE_4_5;
9217 parse_func = wbb3_parse_hash;
9218 sort_by_digest = sort_by_digest_4_5;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_PRECOMPUTE_INIT
9221 | OPTI_TYPE_NOT_ITERATED;
9222 dgst_pos0 = 3;
9223 dgst_pos1 = 4;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 1;
9226 break;
9227
9228 case 8500: hash_type = HASH_TYPE_DESRACF;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE
9232 | OPTS_TYPE_ST_UPPER;
9233 kern_type = KERN_TYPE_RACF;
9234 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9235 parse_func = racf_parse_hash;
9236 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9237 opti_type = OPTI_TYPE_ZERO_BYTE
9238 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 1;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 3;
9243 break;
9244
9245 case 8600: hash_type = HASH_TYPE_LOTUS5;
9246 salt_type = SALT_TYPE_NONE;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9249 kern_type = KERN_TYPE_LOTUS5;
9250 dgst_size = DGST_SIZE_4_4;
9251 parse_func = lotus5_parse_hash;
9252 sort_by_digest = sort_by_digest_4_4;
9253 opti_type = OPTI_TYPE_EARLY_SKIP
9254 | OPTI_TYPE_NOT_ITERATED
9255 | OPTI_TYPE_NOT_SALTED
9256 | OPTI_TYPE_RAW_HASH;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 8700: hash_type = HASH_TYPE_LOTUS6;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9267 kern_type = KERN_TYPE_LOTUS6;
9268 dgst_size = DGST_SIZE_4_4;
9269 parse_func = lotus6_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4;
9271 opti_type = OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_RAW_HASH;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9284 kern_type = KERN_TYPE_ANDROIDFDE;
9285 dgst_size = DGST_SIZE_4_4;
9286 parse_func = androidfde_parse_hash;
9287 sort_by_digest = sort_by_digest_4_4;
9288 opti_type = OPTI_TYPE_ZERO_BYTE;
9289 dgst_pos0 = 0;
9290 dgst_pos1 = 1;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 3;
9293 break;
9294
9295 case 8900: hash_type = HASH_TYPE_SCRYPT;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9299 kern_type = KERN_TYPE_SCRYPT;
9300 dgst_size = DGST_SIZE_4_8;
9301 parse_func = scrypt_parse_hash;
9302 sort_by_digest = sort_by_digest_4_8;
9303 opti_type = OPTI_TYPE_ZERO_BYTE;
9304 dgst_pos0 = 0;
9305 dgst_pos1 = 1;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 3;
9308 break;
9309
9310 case 9000: hash_type = HASH_TYPE_SHA1;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_LE
9314 | OPTS_TYPE_ST_GENERATE_LE;
9315 kern_type = KERN_TYPE_PSAFE2;
9316 dgst_size = DGST_SIZE_4_5;
9317 parse_func = psafe2_parse_hash;
9318 sort_by_digest = sort_by_digest_4_5;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 0;
9321 dgst_pos1 = 1;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 3;
9324 break;
9325
9326 case 9100: hash_type = HASH_TYPE_LOTUS8;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9330 kern_type = KERN_TYPE_LOTUS8;
9331 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9332 parse_func = lotus8_parse_hash;
9333 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9334 opti_type = OPTI_TYPE_ZERO_BYTE;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 9200: hash_type = HASH_TYPE_SHA256;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9345 kern_type = KERN_TYPE_PBKDF2_SHA256;
9346 dgst_size = DGST_SIZE_4_32;
9347 parse_func = cisco8_parse_hash;
9348 sort_by_digest = sort_by_digest_4_32;
9349 opti_type = OPTI_TYPE_ZERO_BYTE;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 9300: hash_type = HASH_TYPE_SCRYPT;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9360 kern_type = KERN_TYPE_SCRYPT;
9361 dgst_size = DGST_SIZE_4_8;
9362 parse_func = cisco9_parse_hash;
9363 sort_by_digest = sort_by_digest_4_8;
9364 opti_type = OPTI_TYPE_ZERO_BYTE;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9375 kern_type = KERN_TYPE_OFFICE2007;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = office2007_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_ZERO_BYTE;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9387 salt_type = SALT_TYPE_EMBEDDED;
9388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9390 kern_type = KERN_TYPE_OFFICE2010;
9391 dgst_size = DGST_SIZE_4_4;
9392 parse_func = office2010_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4;
9394 opti_type = OPTI_TYPE_ZERO_BYTE;
9395 dgst_pos0 = 0;
9396 dgst_pos1 = 1;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 3;
9399 break;
9400
9401 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9405 kern_type = KERN_TYPE_OFFICE2013;
9406 dgst_size = DGST_SIZE_4_4;
9407 parse_func = office2013_parse_hash;
9408 sort_by_digest = sort_by_digest_4_4;
9409 opti_type = OPTI_TYPE_ZERO_BYTE;
9410 dgst_pos0 = 0;
9411 dgst_pos1 = 1;
9412 dgst_pos2 = 2;
9413 dgst_pos3 = 3;
9414 break;
9415
9416 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9417 salt_type = SALT_TYPE_EMBEDDED;
9418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9419 opts_type = OPTS_TYPE_PT_GENERATE_LE
9420 | OPTS_TYPE_PT_ADD80
9421 | OPTS_TYPE_PT_UNICODE;
9422 kern_type = KERN_TYPE_OLDOFFICE01;
9423 dgst_size = DGST_SIZE_4_4;
9424 parse_func = oldoffice01_parse_hash;
9425 sort_by_digest = sort_by_digest_4_4;
9426 opti_type = OPTI_TYPE_ZERO_BYTE
9427 | OPTI_TYPE_PRECOMPUTE_INIT
9428 | OPTI_TYPE_NOT_ITERATED;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE
9439 | OPTS_TYPE_PT_ADD80;
9440 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9441 dgst_size = DGST_SIZE_4_4;
9442 parse_func = oldoffice01cm1_parse_hash;
9443 sort_by_digest = sort_by_digest_4_4;
9444 opti_type = OPTI_TYPE_ZERO_BYTE
9445 | OPTI_TYPE_PRECOMPUTE_INIT
9446 | OPTI_TYPE_NOT_ITERATED;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE
9457 | OPTS_TYPE_PT_ADD80
9458 | OPTS_TYPE_PT_UNICODE
9459 | OPTS_TYPE_PT_NEVERCRACK;
9460 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9461 dgst_size = DGST_SIZE_4_4;
9462 parse_func = oldoffice01cm2_parse_hash;
9463 sort_by_digest = sort_by_digest_4_4;
9464 opti_type = OPTI_TYPE_ZERO_BYTE
9465 | OPTI_TYPE_PRECOMPUTE_INIT
9466 | OPTI_TYPE_NOT_ITERATED;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_BE
9477 | OPTS_TYPE_PT_ADD80
9478 | OPTS_TYPE_PT_UNICODE;
9479 kern_type = KERN_TYPE_OLDOFFICE34;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = oldoffice34_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_PRECOMPUTE_INIT
9485 | OPTI_TYPE_NOT_ITERATED;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9496 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = oldoffice34cm1_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_ZERO_BYTE
9501 | OPTI_TYPE_PRECOMPUTE_INIT
9502 | OPTI_TYPE_NOT_ITERATED;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_BE
9513 | OPTS_TYPE_PT_ADD80
9514 | OPTS_TYPE_PT_UNICODE
9515 | OPTS_TYPE_PT_NEVERCRACK;
9516 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = oldoffice34cm2_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_PRECOMPUTE_INIT
9522 | OPTI_TYPE_NOT_ITERATED;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9900: hash_type = HASH_TYPE_MD5;
9530 salt_type = SALT_TYPE_NONE;
9531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_RADMIN2;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = radmin2_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE
9538 | OPTI_TYPE_PRECOMPUTE_INIT
9539 | OPTI_TYPE_EARLY_SKIP
9540 | OPTI_TYPE_NOT_ITERATED
9541 | OPTI_TYPE_NOT_SALTED;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 3;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 1;
9546 break;
9547
9548 case 10000: hash_type = HASH_TYPE_SHA256;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9552 kern_type = KERN_TYPE_PBKDF2_SHA256;
9553 dgst_size = DGST_SIZE_4_32;
9554 parse_func = djangopbkdf2_parse_hash;
9555 sort_by_digest = sort_by_digest_4_32;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 10100: hash_type = HASH_TYPE_SIPHASH;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9567 kern_type = KERN_TYPE_SIPHASH;
9568 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9569 parse_func = siphash_parse_hash;
9570 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9571 opti_type = OPTI_TYPE_ZERO_BYTE
9572 | OPTI_TYPE_NOT_ITERATED
9573 | OPTI_TYPE_RAW_HASH;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 10200: hash_type = HASH_TYPE_MD5;
9581 salt_type = SALT_TYPE_EMBEDDED;
9582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_LE
9584 | OPTS_TYPE_ST_ADD80
9585 | OPTS_TYPE_ST_ADDBITS14;
9586 kern_type = KERN_TYPE_HMACMD5_PW;
9587 dgst_size = DGST_SIZE_4_4;
9588 parse_func = crammd5_parse_hash;
9589 sort_by_digest = sort_by_digest_4_4;
9590 opti_type = OPTI_TYPE_ZERO_BYTE
9591 | OPTI_TYPE_NOT_ITERATED;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 3;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 1;
9596 break;
9597
9598 case 10300: hash_type = HASH_TYPE_SHA1;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9602 kern_type = KERN_TYPE_SAPH_SHA1;
9603 dgst_size = DGST_SIZE_4_5;
9604 parse_func = saph_sha1_parse_hash;
9605 sort_by_digest = sort_by_digest_4_5;
9606 opti_type = OPTI_TYPE_ZERO_BYTE;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 10400: hash_type = HASH_TYPE_PDFU16;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9617 kern_type = KERN_TYPE_PDF11;
9618 dgst_size = DGST_SIZE_4_4;
9619 parse_func = pdf11_parse_hash;
9620 sort_by_digest = sort_by_digest_4_4;
9621 opti_type = OPTI_TYPE_ZERO_BYTE
9622 | OPTI_TYPE_NOT_ITERATED;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 10410: hash_type = HASH_TYPE_PDFU16;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9633 kern_type = KERN_TYPE_PDF11CM1;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = pdf11cm1_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_NOT_ITERATED;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 10420: hash_type = HASH_TYPE_PDFU16;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9649 kern_type = KERN_TYPE_PDF11CM2;
9650 dgst_size = DGST_SIZE_4_4;
9651 parse_func = pdf11cm2_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4;
9653 opti_type = OPTI_TYPE_ZERO_BYTE
9654 | OPTI_TYPE_NOT_ITERATED;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 10500: hash_type = HASH_TYPE_PDFU16;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9665 kern_type = KERN_TYPE_PDF14;
9666 dgst_size = DGST_SIZE_4_4;
9667 parse_func = pdf14_parse_hash;
9668 sort_by_digest = sort_by_digest_4_4;
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_NOT_ITERATED;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 10600: hash_type = HASH_TYPE_SHA256;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_BE
9681 | OPTS_TYPE_ST_ADD80
9682 | OPTS_TYPE_ST_ADDBITS15
9683 | OPTS_TYPE_HASH_COPY;
9684 kern_type = KERN_TYPE_SHA256_PWSLT;
9685 dgst_size = DGST_SIZE_4_8;
9686 parse_func = pdf17l3_parse_hash;
9687 sort_by_digest = sort_by_digest_4_8;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_PRECOMPUTE_INIT
9690 | OPTI_TYPE_PRECOMPUTE_MERKLE
9691 | OPTI_TYPE_EARLY_SKIP
9692 | OPTI_TYPE_NOT_ITERATED
9693 | OPTI_TYPE_APPENDED_SALT
9694 | OPTI_TYPE_RAW_HASH;
9695 dgst_pos0 = 3;
9696 dgst_pos1 = 7;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 6;
9699 break;
9700
9701 case 10700: hash_type = HASH_TYPE_PDFU32;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE
9705 | OPTS_TYPE_HASH_COPY;
9706 kern_type = KERN_TYPE_PDF17L8;
9707 dgst_size = DGST_SIZE_4_8;
9708 parse_func = pdf17l8_parse_hash;
9709 sort_by_digest = sort_by_digest_4_8;
9710 opti_type = OPTI_TYPE_ZERO_BYTE
9711 | OPTI_TYPE_NOT_ITERATED;
9712 dgst_pos0 = 0;
9713 dgst_pos1 = 1;
9714 dgst_pos2 = 2;
9715 dgst_pos3 = 3;
9716 break;
9717
9718 case 10800: hash_type = HASH_TYPE_SHA384;
9719 salt_type = SALT_TYPE_NONE;
9720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9721 opts_type = OPTS_TYPE_PT_GENERATE_BE
9722 | OPTS_TYPE_PT_ADD80
9723 | OPTS_TYPE_PT_ADDBITS15;
9724 kern_type = KERN_TYPE_SHA384;
9725 dgst_size = DGST_SIZE_8_8;
9726 parse_func = sha384_parse_hash;
9727 sort_by_digest = sort_by_digest_8_8;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_PRECOMPUTE_INIT
9730 | OPTI_TYPE_PRECOMPUTE_MERKLE
9731 | OPTI_TYPE_EARLY_SKIP
9732 | OPTI_TYPE_NOT_ITERATED
9733 | OPTI_TYPE_NOT_SALTED
9734 | OPTI_TYPE_USES_BITS_64
9735 | OPTI_TYPE_RAW_HASH;
9736 dgst_pos0 = 6;
9737 dgst_pos1 = 7;
9738 dgst_pos2 = 4;
9739 dgst_pos3 = 5;
9740 break;
9741
9742 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE
9746 | OPTS_TYPE_ST_BASE64
9747 | OPTS_TYPE_HASH_COPY;
9748 kern_type = KERN_TYPE_PBKDF2_SHA256;
9749 dgst_size = DGST_SIZE_4_32;
9750 parse_func = pbkdf2_sha256_parse_hash;
9751 sort_by_digest = sort_by_digest_4_32;
9752 opti_type = OPTI_TYPE_ZERO_BYTE;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 11000: hash_type = HASH_TYPE_MD5;
9760 salt_type = SALT_TYPE_INTERN;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE
9763 | OPTS_TYPE_PT_ADD80;
9764 kern_type = KERN_TYPE_PRESTASHOP;
9765 dgst_size = DGST_SIZE_4_4;
9766 parse_func = prestashop_parse_hash;
9767 sort_by_digest = sort_by_digest_4_4;
9768 opti_type = OPTI_TYPE_ZERO_BYTE
9769 | OPTI_TYPE_PRECOMPUTE_INIT
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_PREPENDED_SALT;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 3;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 1;
9776 break;
9777
9778 case 11100: hash_type = HASH_TYPE_MD5;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE
9782 | OPTS_TYPE_ST_ADD80;
9783 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9784 dgst_size = DGST_SIZE_4_4;
9785 parse_func = postgresql_auth_parse_hash;
9786 sort_by_digest = sort_by_digest_4_4;
9787 opti_type = OPTI_TYPE_ZERO_BYTE
9788 | OPTI_TYPE_PRECOMPUTE_INIT
9789 | OPTI_TYPE_PRECOMPUTE_MERKLE
9790 | OPTI_TYPE_EARLY_SKIP;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 3;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 1;
9795 break;
9796
9797 case 11200: hash_type = HASH_TYPE_SHA1;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_BE
9801 | OPTS_TYPE_PT_ADD80
9802 | OPTS_TYPE_ST_HEX;
9803 kern_type = KERN_TYPE_MYSQL_AUTH;
9804 dgst_size = DGST_SIZE_4_5;
9805 parse_func = mysql_auth_parse_hash;
9806 sort_by_digest = sort_by_digest_4_5;
9807 opti_type = OPTI_TYPE_ZERO_BYTE
9808 | OPTI_TYPE_EARLY_SKIP;
9809 dgst_pos0 = 3;
9810 dgst_pos1 = 4;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 1;
9813 break;
9814
9815 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE
9819 | OPTS_TYPE_ST_HEX
9820 | OPTS_TYPE_ST_ADD80;
9821 kern_type = KERN_TYPE_BITCOIN_WALLET;
9822 dgst_size = DGST_SIZE_4_4;
9823 parse_func = bitcoin_wallet_parse_hash;
9824 sort_by_digest = sort_by_digest_4_4;
9825 opti_type = OPTI_TYPE_ZERO_BYTE;
9826 dgst_pos0 = 0;
9827 dgst_pos1 = 1;
9828 dgst_pos2 = 2;
9829 dgst_pos3 = 3;
9830 break;
9831
9832 case 11400: hash_type = HASH_TYPE_MD5;
9833 salt_type = SALT_TYPE_EMBEDDED;
9834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9835 opts_type = OPTS_TYPE_PT_GENERATE_LE
9836 | OPTS_TYPE_PT_ADD80
9837 | OPTS_TYPE_HASH_COPY;
9838 kern_type = KERN_TYPE_SIP_AUTH;
9839 dgst_size = DGST_SIZE_4_4;
9840 parse_func = sip_auth_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4;
9842 opti_type = OPTI_TYPE_ZERO_BYTE;
9843 dgst_pos0 = 0;
9844 dgst_pos1 = 3;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 1;
9847 break;
9848
9849 case 11500: hash_type = HASH_TYPE_CRC32;
9850 salt_type = SALT_TYPE_INTERN;
9851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE
9853 | OPTS_TYPE_ST_GENERATE_LE
9854 | OPTS_TYPE_ST_HEX;
9855 kern_type = KERN_TYPE_CRC32;
9856 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9857 parse_func = crc32_parse_hash;
9858 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9859 opti_type = OPTI_TYPE_ZERO_BYTE;
9860 dgst_pos0 = 0;
9861 dgst_pos1 = 1;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 3;
9864 break;
9865
9866 case 11600: hash_type = HASH_TYPE_AES;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE
9870 | OPTS_TYPE_PT_NEVERCRACK;
9871 kern_type = KERN_TYPE_SEVEN_ZIP;
9872 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9873 parse_func = seven_zip_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9883 salt_type = SALT_TYPE_NONE;
9884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_PT_ADD01;
9887 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9888 dgst_size = DGST_SIZE_4_8;
9889 parse_func = gost2012sbog_256_parse_hash;
9890 sort_by_digest = sort_by_digest_4_8;
9891 opti_type = OPTI_TYPE_ZERO_BYTE;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9899 salt_type = SALT_TYPE_NONE;
9900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE
9902 | OPTS_TYPE_PT_ADD01;
9903 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9904 dgst_size = DGST_SIZE_4_16;
9905 parse_func = gost2012sbog_512_parse_hash;
9906 sort_by_digest = sort_by_digest_4_16;
9907 opti_type = OPTI_TYPE_ZERO_BYTE;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_ST_BASE64
9919 | OPTS_TYPE_HASH_COPY;
9920 kern_type = KERN_TYPE_PBKDF2_MD5;
9921 dgst_size = DGST_SIZE_4_32;
9922 parse_func = pbkdf2_md5_parse_hash;
9923 sort_by_digest = sort_by_digest_4_32;
9924 opti_type = OPTI_TYPE_ZERO_BYTE;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 1;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 3;
9929 break;
9930
9931 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE
9935 | OPTS_TYPE_ST_BASE64
9936 | OPTS_TYPE_HASH_COPY;
9937 kern_type = KERN_TYPE_PBKDF2_SHA1;
9938 dgst_size = DGST_SIZE_4_32;
9939 parse_func = pbkdf2_sha1_parse_hash;
9940 sort_by_digest = sort_by_digest_4_32;
9941 opti_type = OPTI_TYPE_ZERO_BYTE;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE
9952 | OPTS_TYPE_ST_BASE64
9953 | OPTS_TYPE_HASH_COPY;
9954 kern_type = KERN_TYPE_PBKDF2_SHA512;
9955 dgst_size = DGST_SIZE_8_16;
9956 parse_func = pbkdf2_sha512_parse_hash;
9957 sort_by_digest = sort_by_digest_8_16;
9958 opti_type = OPTI_TYPE_ZERO_BYTE
9959 | OPTI_TYPE_USES_BITS_64;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9970 kern_type = KERN_TYPE_ECRYPTFS;
9971 dgst_size = DGST_SIZE_8_8;
9972 parse_func = ecryptfs_parse_hash;
9973 sort_by_digest = sort_by_digest_8_8;
9974 opti_type = OPTI_TYPE_ZERO_BYTE
9975 | OPTI_TYPE_USES_BITS_64;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 12300: hash_type = HASH_TYPE_ORACLET;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_ORACLET;
9987 dgst_size = DGST_SIZE_8_16;
9988 parse_func = oraclet_parse_hash;
9989 sort_by_digest = sort_by_digest_8_16;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_USES_BITS_64;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_BSDICRYPT;
10003 dgst_size = DGST_SIZE_4_4;
10004 parse_func = bsdicrypt_parse_hash;
10005 sort_by_digest = sort_by_digest_4_4;
10006 opti_type = OPTI_TYPE_ZERO_BYTE
10007 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 12500: hash_type = HASH_TYPE_RAR3HP;
10015 salt_type = SALT_TYPE_EMBEDDED;
10016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10018 kern_type = KERN_TYPE_RAR3;
10019 dgst_size = DGST_SIZE_4_4;
10020 parse_func = rar3hp_parse_hash;
10021 sort_by_digest = sort_by_digest_4_4;
10022 opti_type = OPTI_TYPE_ZERO_BYTE;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 12600: hash_type = HASH_TYPE_SHA256;
10030 salt_type = SALT_TYPE_INTERN;
10031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_BE
10033 | OPTS_TYPE_PT_ADD80;
10034 kern_type = KERN_TYPE_CF10;
10035 dgst_size = DGST_SIZE_4_8;
10036 parse_func = cf10_parse_hash;
10037 sort_by_digest = sort_by_digest_4_8;
10038 opti_type = OPTI_TYPE_ZERO_BYTE
10039 | OPTI_TYPE_PRECOMPUTE_INIT
10040 | OPTI_TYPE_EARLY_SKIP
10041 | OPTI_TYPE_NOT_ITERATED;
10042 dgst_pos0 = 3;
10043 dgst_pos1 = 7;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 6;
10046 break;
10047
10048 case 12700: hash_type = HASH_TYPE_AES;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE
10052 | OPTS_TYPE_HASH_COPY;
10053 kern_type = KERN_TYPE_MYWALLET;
10054 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10055 parse_func = mywallet_parse_hash;
10056 sort_by_digest = sort_by_digest_4_5;
10057 opti_type = OPTI_TYPE_ZERO_BYTE;
10058 dgst_pos0 = 0;
10059 dgst_pos1 = 1;
10060 dgst_pos2 = 2;
10061 dgst_pos3 = 3;
10062 break;
10063
10064 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10065 salt_type = SALT_TYPE_EMBEDDED;
10066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10068 kern_type = KERN_TYPE_MS_DRSR;
10069 dgst_size = DGST_SIZE_4_8;
10070 parse_func = ms_drsr_parse_hash;
10071 sort_by_digest = sort_by_digest_4_8;
10072 opti_type = OPTI_TYPE_ZERO_BYTE;
10073 dgst_pos0 = 0;
10074 dgst_pos1 = 1;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 3;
10077 break;
10078
10079 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10083 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10084 dgst_size = DGST_SIZE_4_8;
10085 parse_func = androidfde_samsung_parse_hash;
10086 sort_by_digest = sort_by_digest_4_8;
10087 opti_type = OPTI_TYPE_ZERO_BYTE;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10095 salt_type = SALT_TYPE_EMBEDDED;
10096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10098 kern_type = KERN_TYPE_RAR5;
10099 dgst_size = DGST_SIZE_4_4;
10100 parse_func = rar5_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4;
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 default: usage_mini_print (PROGNAME); return (-1);
10110 }
10111
10112 /**
10113 * transpose
10114 */
10115
10116 data.parse_func = parse_func;
10117
10118 /**
10119 * misc stuff
10120 */
10121
10122 if (hex_salt)
10123 {
10124 if (salt_type == SALT_TYPE_INTERN)
10125 {
10126 opts_type |= OPTS_TYPE_ST_HEX;
10127 }
10128 else
10129 {
10130 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10131
10132 return (-1);
10133 }
10134 }
10135
10136 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10137 | (salt_type == SALT_TYPE_EXTERN)
10138 | (salt_type == SALT_TYPE_EMBEDDED)
10139 | (salt_type == SALT_TYPE_VIRTUAL));
10140
10141 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10142
10143 data.hash_type = hash_type;
10144 data.attack_mode = attack_mode;
10145 data.attack_kern = attack_kern;
10146 data.attack_exec = attack_exec;
10147 data.kern_type = kern_type;
10148 data.opts_type = opts_type;
10149 data.dgst_size = dgst_size;
10150 data.salt_type = salt_type;
10151 data.isSalted = isSalted;
10152 data.sort_by_digest = sort_by_digest;
10153 data.dgst_pos0 = dgst_pos0;
10154 data.dgst_pos1 = dgst_pos1;
10155 data.dgst_pos2 = dgst_pos2;
10156 data.dgst_pos3 = dgst_pos3;
10157
10158 esalt_size = 0;
10159
10160 switch (hash_mode)
10161 {
10162 case 2500: esalt_size = sizeof (wpa_t); break;
10163 case 5300: esalt_size = sizeof (ikepsk_t); break;
10164 case 5400: esalt_size = sizeof (ikepsk_t); break;
10165 case 5500: esalt_size = sizeof (netntlm_t); break;
10166 case 5600: esalt_size = sizeof (netntlm_t); break;
10167 case 6211:
10168 case 6212:
10169 case 6213:
10170 case 6221:
10171 case 6222:
10172 case 6223:
10173 case 6231:
10174 case 6232:
10175 case 6233:
10176 case 6241:
10177 case 6242:
10178 case 6243: esalt_size = sizeof (tc_t); break;
10179 case 6600: esalt_size = sizeof (agilekey_t); break;
10180 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10181 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10182 case 7300: esalt_size = sizeof (rakp_t); break;
10183 case 7500: esalt_size = sizeof (krb5pa_t); break;
10184 case 8200: esalt_size = sizeof (cloudkey_t); break;
10185 case 8800: esalt_size = sizeof (androidfde_t); break;
10186 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10187 case 9400: esalt_size = sizeof (office2007_t); break;
10188 case 9500: esalt_size = sizeof (office2010_t); break;
10189 case 9600: esalt_size = sizeof (office2013_t); break;
10190 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10191 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10192 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10193 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10194 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10195 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10196 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10197 case 10200: esalt_size = sizeof (cram_md5_t); break;
10198 case 10400: esalt_size = sizeof (pdf_t); break;
10199 case 10410: esalt_size = sizeof (pdf_t); break;
10200 case 10420: esalt_size = sizeof (pdf_t); break;
10201 case 10500: esalt_size = sizeof (pdf_t); break;
10202 case 10600: esalt_size = sizeof (pdf_t); break;
10203 case 10700: esalt_size = sizeof (pdf_t); break;
10204 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10205 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10206 case 11400: esalt_size = sizeof (sip_t); break;
10207 case 11600: esalt_size = sizeof (seven_zip_t); break;
10208 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10209 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10210 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10211 case 13000: esalt_size = sizeof (rar5_t); break;
10212 }
10213
10214 data.esalt_size = esalt_size;
10215
10216 /**
10217 * choose dictionary parser
10218 */
10219
10220 if (hash_type == HASH_TYPE_LM)
10221 {
10222 get_next_word_func = get_next_word_lm;
10223 }
10224 else if (opts_type & OPTS_TYPE_PT_UPPER)
10225 {
10226 get_next_word_func = get_next_word_uc;
10227 }
10228 else
10229 {
10230 get_next_word_func = get_next_word_std;
10231 }
10232
10233 /**
10234 * dictstat
10235 */
10236
10237 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10238
10239 #ifdef _POSIX
10240 size_t dictstat_nmemb = 0;
10241 #endif
10242
10243 #ifdef _WIN
10244 uint dictstat_nmemb = 0;
10245 #endif
10246
10247 char dictstat[256] = { 0 };
10248
10249 FILE *dictstat_fp = NULL;
10250
10251 if (keyspace == 0)
10252 {
10253 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10254
10255 dictstat_fp = fopen (dictstat, "rb");
10256
10257 if (dictstat_fp)
10258 {
10259 #ifdef _POSIX
10260 struct stat tmpstat;
10261
10262 fstat (fileno (dictstat_fp), &tmpstat);
10263 #endif
10264
10265 #ifdef _WIN
10266 struct stat64 tmpstat;
10267
10268 _fstat64 (fileno (dictstat_fp), &tmpstat);
10269 #endif
10270
10271 if (tmpstat.st_mtime < COMPTIME)
10272 {
10273 /* with v0.15 the format changed so we have to ensure user is using a good version
10274 since there is no version-header in the dictstat file */
10275
10276 fclose (dictstat_fp);
10277
10278 unlink (dictstat);
10279 }
10280 else
10281 {
10282 while (!feof (dictstat_fp))
10283 {
10284 dictstat_t d;
10285
10286 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10287
10288 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10289
10290 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10291 {
10292 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10293
10294 return -1;
10295 }
10296 }
10297
10298 fclose (dictstat_fp);
10299 }
10300 }
10301 }
10302
10303 /**
10304 * potfile
10305 */
10306
10307 char potfile[256] = { 0 };
10308
10309 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10310
10311 data.pot_fp = NULL;
10312
10313 FILE *out_fp = NULL;
10314 FILE *pot_fp = NULL;
10315
10316 if (show == 1 || left == 1)
10317 {
10318 pot_fp = fopen (potfile, "rb");
10319
10320 if (pot_fp == NULL)
10321 {
10322 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10323
10324 return (-1);
10325 }
10326
10327 if (outfile != NULL)
10328 {
10329 if ((out_fp = fopen (outfile, "ab")) == NULL)
10330 {
10331 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10332
10333 fclose (pot_fp);
10334
10335 return (-1);
10336 }
10337 }
10338 else
10339 {
10340 out_fp = stdout;
10341 }
10342 }
10343 else
10344 {
10345 if (potfile_disable == 0)
10346 {
10347 pot_fp = fopen (potfile, "ab");
10348
10349 if (pot_fp == NULL)
10350 {
10351 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10352
10353 return (-1);
10354 }
10355
10356 data.pot_fp = pot_fp;
10357 }
10358 }
10359
10360 pot_t *pot = NULL;
10361
10362 uint pot_cnt = 0;
10363 uint pot_avail = 0;
10364
10365 if (show == 1 || left == 1)
10366 {
10367 SUPPRESS_OUTPUT = 1;
10368
10369 pot_avail = count_lines (pot_fp);
10370
10371 rewind (pot_fp);
10372
10373 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10374
10375 uint pot_hashes_avail = 0;
10376
10377 uint line_num = 0;
10378
10379 while (!feof (pot_fp))
10380 {
10381 line_num++;
10382
10383 char line_buf[BUFSIZ] = { 0 };
10384
10385 int line_len = fgetl (pot_fp, line_buf);
10386
10387 if (line_len == 0) continue;
10388
10389 char *plain_buf = line_buf + line_len;
10390
10391 pot_t *pot_ptr = &pot[pot_cnt];
10392
10393 hash_t *hashes_buf = &pot_ptr->hash;
10394
10395 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10396 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10397
10398 if (pot_cnt == pot_hashes_avail)
10399 {
10400 uint pos = 0;
10401
10402 for (pos = 0; pos < INCR_POT; pos++)
10403 {
10404 if ((pot_cnt + pos) >= pot_avail) break;
10405
10406 pot_t *tmp_pot = &pot[pot_cnt + pos];
10407
10408 hash_t *tmp_hash = &tmp_pot->hash;
10409
10410 tmp_hash->digest = mymalloc (dgst_size);
10411
10412 if (isSalted)
10413 {
10414 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10415 }
10416
10417 if (esalt_size)
10418 {
10419 tmp_hash->esalt = mymalloc (esalt_size);
10420 }
10421
10422 pot_hashes_avail++;
10423 }
10424 }
10425
10426 int plain_len = 0;
10427
10428 int parser_status;
10429
10430 int iter = MAX_CUT_TRIES;
10431
10432 do
10433 {
10434 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10435 {
10436 if (line_buf[i] == ':')
10437 {
10438 line_len--;
10439
10440 break;
10441 }
10442 }
10443
10444 if (data.hash_mode != 2500)
10445 {
10446 parser_status = parse_func (line_buf, line_len, hashes_buf);
10447 }
10448 else
10449 {
10450 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10451
10452 if (line_len > max_salt_size)
10453 {
10454 parser_status = PARSER_GLOBAL_LENGTH;
10455 }
10456 else
10457 {
10458 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10459
10460 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10461
10462 hashes_buf->salt->salt_len = line_len;
10463
10464 parser_status = PARSER_OK;
10465 }
10466 }
10467
10468 // if NOT parsed without error, we add the ":" to the plain
10469
10470 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10471 {
10472 plain_len++;
10473 plain_buf--;
10474 }
10475
10476 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10477
10478 if (parser_status < PARSER_GLOBAL_ZERO)
10479 {
10480 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10481
10482 continue;
10483 }
10484
10485 if (plain_len >= 255) continue;
10486
10487 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10488
10489 pot_ptr->plain_len = plain_len;
10490
10491 pot_cnt++;
10492 }
10493
10494 fclose (pot_fp);
10495
10496 SUPPRESS_OUTPUT = 0;
10497
10498 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10499 }
10500
10501 /**
10502 * word len
10503 */
10504
10505 uint pw_min = PW_MIN;
10506 uint pw_max = PW_MAX;
10507
10508 switch (hash_mode)
10509 {
10510 case 400: if (pw_max > 40) pw_max = 40;
10511 break;
10512 case 500: if (pw_max > 16) pw_max = 16;
10513 break;
10514 case 1500: if (pw_max > 8) pw_max = 8;
10515 break;
10516 case 1600: if (pw_max > 16) pw_max = 16;
10517 break;
10518 case 1800: if (pw_max > 16) pw_max = 16;
10519 break;
10520 case 2100: if (pw_max > 16) pw_max = 16;
10521 break;
10522 case 2500: if (pw_min < 8) pw_min = 8;
10523 break;
10524 case 3000: if (pw_max > 7) pw_max = 7;
10525 break;
10526 case 5200: if (pw_max > 24) pw_max = 24;
10527 break;
10528 case 5800: if (pw_max > 16) pw_max = 16;
10529 break;
10530 case 6300: if (pw_max > 16) pw_max = 16;
10531 break;
10532 case 7400: if (pw_max > 16) pw_max = 16;
10533 break;
10534 case 7900: if (pw_max > 48) pw_max = 48;
10535 break;
10536 case 8500: if (pw_max > 8) pw_max = 8;
10537 break;
10538 case 8600: if (pw_max > 16) pw_max = 16;
10539 break;
10540 case 9710: pw_min = 5;
10541 pw_max = 5;
10542 break;
10543 case 9810: pw_min = 5;
10544 pw_max = 5;
10545 break;
10546 case 10410: pw_min = 5;
10547 pw_max = 5;
10548 break;
10549 case 10300: if (pw_max < 3) pw_min = 3;
10550 if (pw_max > 40) pw_max = 40;
10551 break;
10552 case 10500: if (pw_max < 3) pw_min = 3;
10553 if (pw_max > 40) pw_max = 40;
10554 break;
10555 case 10700: if (pw_max > 16) pw_max = 16;
10556 break;
10557 case 11300: if (pw_max > 40) pw_max = 40;
10558 break;
10559 case 12500: if (pw_max > 20) pw_max = 20;
10560 break;
10561 case 12800: if (pw_max > 24) pw_max = 24;
10562 break;
10563 }
10564
10565 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10566 {
10567 switch (attack_kern)
10568 {
10569 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10570 break;
10571 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10572 break;
10573 }
10574 }
10575
10576 /**
10577 * charsets : keep them together for more easy maintainnce
10578 */
10579
10580 cs_t mp_sys[6] = { { { 0 }, 0 } };
10581 cs_t mp_usr[4] = { { { 0 }, 0 } };
10582
10583 mp_setup_sys (mp_sys);
10584
10585 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10586 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10587 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10588 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10589
10590 /**
10591 * load hashes, part I: find input mode, count hashes
10592 */
10593
10594 uint hashlist_mode = 0;
10595 uint hashlist_format = HLFMT_HASHCAT;
10596
10597 uint hashes_avail = 0;
10598
10599 if (benchmark == 0)
10600 {
10601 struct stat f;
10602
10603 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10604
10605 if ((hash_mode == 2500) ||
10606 (hash_mode == 5200) ||
10607 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10608 (hash_mode == 9000))
10609 {
10610 hashlist_mode = HL_MODE_ARG;
10611
10612 char *hashfile = myargv[optind];
10613
10614 data.hashfile = hashfile;
10615
10616 logfile_top_var_string ("target", hashfile);
10617 }
10618
10619 if (hashlist_mode == HL_MODE_ARG)
10620 {
10621 if (hash_mode == 2500)
10622 {
10623 struct stat st;
10624
10625 if (stat (data.hashfile, &st) == -1)
10626 {
10627 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10628
10629 return (-1);
10630 }
10631
10632 hashes_avail = st.st_size / sizeof (hccap_t);
10633 }
10634 else
10635 {
10636 hashes_avail = 1;
10637 }
10638 }
10639 else if (hashlist_mode == HL_MODE_FILE)
10640 {
10641 char *hashfile = myargv[optind];
10642
10643 data.hashfile = hashfile;
10644
10645 logfile_top_var_string ("target", hashfile);
10646
10647 FILE *fp = NULL;
10648
10649 if ((fp = fopen (hashfile, "rb")) == NULL)
10650 {
10651 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10652
10653 return (-1);
10654 }
10655
10656 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10657
10658 hashes_avail = count_lines (fp);
10659
10660 rewind (fp);
10661
10662 if (hashes_avail == 0)
10663 {
10664 log_error ("ERROR: hashfile is empty or corrupt");
10665
10666 fclose (fp);
10667
10668 return (-1);
10669 }
10670
10671 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10672
10673 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10674 {
10675 log_error ("ERROR: remove not supported in native hashfile-format mode");
10676
10677 fclose (fp);
10678
10679 return (-1);
10680 }
10681
10682 fclose (fp);
10683 }
10684 }
10685 else
10686 {
10687 hashlist_mode = HL_MODE_ARG;
10688
10689 hashes_avail = 1;
10690 }
10691
10692 if (hash_mode == 3000) hashes_avail *= 2;
10693
10694 data.hashlist_mode = hashlist_mode;
10695 data.hashlist_format = hashlist_format;
10696
10697 logfile_top_uint (hashlist_mode);
10698 logfile_top_uint (hashlist_format);
10699
10700 /**
10701 * load hashes, part II: allocate required memory, set pointers
10702 */
10703
10704 hash_t *hashes_buf = NULL;
10705 void *digests_buf = NULL;
10706 salt_t *salts_buf = NULL;
10707 void *esalts_buf = NULL;
10708
10709 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10710
10711 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10712
10713 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10714 {
10715 u32 hash_pos;
10716
10717 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10718 {
10719 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10720
10721 hashes_buf[hash_pos].hash_info = hash_info;
10722
10723 if (username && (remove || show || left))
10724 {
10725 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10726 }
10727
10728 if (benchmark)
10729 {
10730 hash_info->orighash = (char *) mymalloc (256);
10731 }
10732 }
10733 }
10734
10735 if (isSalted)
10736 {
10737 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10738
10739 if (esalt_size)
10740 {
10741 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10742 }
10743 }
10744 else
10745 {
10746 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10747 }
10748
10749 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10750 {
10751 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10752
10753 if (isSalted)
10754 {
10755 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10756
10757 if (esalt_size)
10758 {
10759 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10760 }
10761 }
10762 else
10763 {
10764 hashes_buf[hash_pos].salt = &salts_buf[0];
10765 }
10766 }
10767
10768 /**
10769 * load hashes, part III: parse hashes or generate them if benchmark
10770 */
10771
10772 uint hashes_cnt = 0;
10773
10774 if (benchmark == 0)
10775 {
10776 if (keyspace == 1)
10777 {
10778 // useless to read hash file for keyspace, cheat a little bit w/ optind
10779 }
10780 else if (hashes_avail == 0)
10781 {
10782 }
10783 else if (hashlist_mode == HL_MODE_ARG)
10784 {
10785 char *input_buf = myargv[optind];
10786
10787 uint input_len = strlen (input_buf);
10788
10789 logfile_top_var_string ("target", input_buf);
10790
10791 char *hash_buf = NULL;
10792 int hash_len = 0;
10793
10794 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10795
10796 if (hash_len)
10797 {
10798 if (opts_type & OPTS_TYPE_HASH_COPY)
10799 {
10800 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10801
10802 hash_info_tmp->orighash = mystrdup (hash_buf);
10803 }
10804
10805 if (isSalted)
10806 {
10807 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10808 }
10809
10810 int parser_status = PARSER_OK;
10811
10812 if (hash_mode == 2500)
10813 {
10814 if (hash_len == 0)
10815 {
10816 log_error ("ERROR: hccap file not specified");
10817
10818 return (-1);
10819 }
10820
10821 hashlist_mode = HL_MODE_FILE;
10822
10823 data.hashlist_mode = hashlist_mode;
10824
10825 FILE *fp = fopen (hash_buf, "rb");
10826
10827 if (fp == NULL)
10828 {
10829 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10830
10831 return (-1);
10832 }
10833
10834 if (hashes_avail < 1)
10835 {
10836 log_error ("ERROR: hccap file is empty or corrupt");
10837
10838 fclose (fp);
10839
10840 return (-1);
10841 }
10842
10843 uint hccap_size = sizeof (hccap_t);
10844
10845 char *in = (char *) mymalloc (hccap_size);
10846
10847 while (!feof (fp))
10848 {
10849 int n = fread (in, hccap_size, 1, fp);
10850
10851 if (n != 1)
10852 {
10853 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10854
10855 break;
10856 }
10857
10858 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10859
10860 if (parser_status != PARSER_OK)
10861 {
10862 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10863
10864 continue;
10865 }
10866
10867 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10868
10869 if ((show == 1) || (left == 1))
10870 {
10871 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10872
10873 char *salt_ptr = (char *) tmp_salt->salt_buf;
10874
10875 int cur_pos = tmp_salt->salt_len;
10876 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10877
10878 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10879
10880 u8 *pke_ptr = (u8 *) wpa->pke;
10881
10882 // do the appending task
10883
10884 snprintf (salt_ptr + cur_pos,
10885 rem_len,
10886 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10887 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10888 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10889
10890
10891 // memset () the remaining part of the salt
10892
10893 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10894 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10895
10896 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10897
10898 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10899 }
10900
10901 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);
10902 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);
10903
10904 hashes_cnt++;
10905 }
10906
10907 fclose (fp);
10908
10909 myfree (in);
10910 }
10911 else if (hash_mode == 3000)
10912 {
10913 if (hash_len == 32)
10914 {
10915 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10916
10917 hash_t *lm_hash_left = NULL;
10918
10919 if (parser_status == PARSER_OK)
10920 {
10921 lm_hash_left = &hashes_buf[hashes_cnt];
10922
10923 hashes_cnt++;
10924 }
10925 else
10926 {
10927 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10928 }
10929
10930 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10931
10932 hash_t *lm_hash_right = NULL;
10933
10934 if (parser_status == PARSER_OK)
10935 {
10936 lm_hash_right = &hashes_buf[hashes_cnt];
10937
10938 hashes_cnt++;
10939 }
10940 else
10941 {
10942 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10943 }
10944
10945 // show / left
10946
10947 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10948 {
10949 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);
10950 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);
10951 }
10952 }
10953 else
10954 {
10955 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10956
10957 if (parser_status == PARSER_OK)
10958 {
10959 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10960 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10961 }
10962
10963 if (parser_status == PARSER_OK)
10964 {
10965 hashes_cnt++;
10966 }
10967 else
10968 {
10969 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10970 }
10971 }
10972 }
10973 else
10974 {
10975 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10976
10977 if (parser_status == PARSER_OK)
10978 {
10979 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10980 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10981 }
10982
10983 if (parser_status == PARSER_OK)
10984 {
10985 hashes_cnt++;
10986 }
10987 else
10988 {
10989 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10990 }
10991 }
10992 }
10993 }
10994 else if (hashlist_mode == HL_MODE_FILE)
10995 {
10996 char *hashfile = data.hashfile;
10997
10998 FILE *fp;
10999
11000 if ((fp = fopen (hashfile, "rb")) == NULL)
11001 {
11002 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11003
11004 return (-1);
11005 }
11006
11007 uint line_num = 0;
11008
11009 while (!feof (fp))
11010 {
11011 line_num++;
11012
11013 char line_buf[BUFSIZ] = { 0 };
11014
11015 int line_len = fgetl (fp, line_buf);
11016
11017 if (line_len == 0) continue;
11018
11019 char *hash_buf = NULL;
11020 int hash_len = 0;
11021
11022 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11023
11024 if (username)
11025 {
11026 char *user_buf = NULL;
11027 int user_len = 0;
11028
11029 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11030
11031 if (remove || show)
11032 {
11033 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11034
11035 *user = (user_t *) mymalloc (sizeof (user_t));
11036
11037 user_t *user_ptr = *user;
11038
11039 if (user_buf != NULL)
11040 {
11041 user_ptr->user_name = mystrdup (user_buf);
11042 }
11043 else
11044 {
11045 user_ptr->user_name = mystrdup ("");
11046 }
11047
11048 user_ptr->user_len = user_len;
11049 }
11050 }
11051
11052 if (opts_type & OPTS_TYPE_HASH_COPY)
11053 {
11054 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11055
11056 hash_info_tmp->orighash = mystrdup (hash_buf);
11057 }
11058
11059 if (isSalted)
11060 {
11061 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11062 }
11063
11064 if (hash_mode == 3000)
11065 {
11066 if (hash_len == 32)
11067 {
11068 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11069
11070 if (parser_status < PARSER_GLOBAL_ZERO)
11071 {
11072 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11073
11074 continue;
11075 }
11076
11077 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11078
11079 hashes_cnt++;
11080
11081 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11082
11083 if (parser_status < PARSER_GLOBAL_ZERO)
11084 {
11085 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11086
11087 continue;
11088 }
11089
11090 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11091
11092 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);
11093
11094 hashes_cnt++;
11095
11096 // show / left
11097
11098 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);
11099 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);
11100 }
11101 else
11102 {
11103 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11104
11105 if (parser_status < PARSER_GLOBAL_ZERO)
11106 {
11107 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11108
11109 continue;
11110 }
11111
11112 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);
11113
11114 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11115 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11116
11117 hashes_cnt++;
11118 }
11119 }
11120 else
11121 {
11122 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11123
11124 if (parser_status < PARSER_GLOBAL_ZERO)
11125 {
11126 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11127
11128 continue;
11129 }
11130
11131 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);
11132
11133 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11135
11136 hashes_cnt++;
11137 }
11138 }
11139
11140 fclose (fp);
11141
11142 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11143
11144 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11145 }
11146 }
11147 else
11148 {
11149 if (isSalted)
11150 {
11151 hashes_buf[0].salt->salt_len = 8;
11152
11153 // special salt handling
11154
11155 switch (hash_mode)
11156 {
11157 case 1500: hashes_buf[0].salt->salt_len = 2;
11158 break;
11159 case 1731: hashes_buf[0].salt->salt_len = 4;
11160 break;
11161 case 2410: hashes_buf[0].salt->salt_len = 4;
11162 break;
11163 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11164 break;
11165 case 3100: hashes_buf[0].salt->salt_len = 1;
11166 break;
11167 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11168 break;
11169 case 5800: hashes_buf[0].salt->salt_len = 16;
11170 break;
11171 case 6800: hashes_buf[0].salt->salt_len = 32;
11172 break;
11173 case 8400: hashes_buf[0].salt->salt_len = 40;
11174 break;
11175 case 8800: hashes_buf[0].salt->salt_len = 16;
11176 break;
11177 case 8900: hashes_buf[0].salt->salt_len = 16;
11178 hashes_buf[0].salt->scrypt_N = 1024;
11179 hashes_buf[0].salt->scrypt_r = 1;
11180 hashes_buf[0].salt->scrypt_p = 1;
11181 break;
11182 case 9100: hashes_buf[0].salt->salt_len = 16;
11183 break;
11184 case 9300: hashes_buf[0].salt->salt_len = 14;
11185 hashes_buf[0].salt->scrypt_N = 16384;
11186 hashes_buf[0].salt->scrypt_r = 1;
11187 hashes_buf[0].salt->scrypt_p = 1;
11188 break;
11189 case 9400: hashes_buf[0].salt->salt_len = 16;
11190 break;
11191 case 9500: hashes_buf[0].salt->salt_len = 16;
11192 break;
11193 case 9600: hashes_buf[0].salt->salt_len = 16;
11194 break;
11195 case 9700: hashes_buf[0].salt->salt_len = 16;
11196 break;
11197 case 9710: hashes_buf[0].salt->salt_len = 16;
11198 break;
11199 case 9720: hashes_buf[0].salt->salt_len = 16;
11200 break;
11201 case 9800: hashes_buf[0].salt->salt_len = 16;
11202 break;
11203 case 9810: hashes_buf[0].salt->salt_len = 16;
11204 break;
11205 case 9820: hashes_buf[0].salt->salt_len = 16;
11206 break;
11207 case 10300: hashes_buf[0].salt->salt_len = 12;
11208 break;
11209 case 11500: hashes_buf[0].salt->salt_len = 4;
11210 break;
11211 case 11600: hashes_buf[0].salt->salt_len = 4;
11212 break;
11213 case 12400: hashes_buf[0].salt->salt_len = 4;
11214 break;
11215 case 12500: hashes_buf[0].salt->salt_len = 8;
11216 break;
11217 case 12600: hashes_buf[0].salt->salt_len = 64;
11218 break;
11219 }
11220
11221 // special esalt handling
11222
11223 switch (hash_mode)
11224 {
11225 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11226 break;
11227 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11228 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11229 break;
11230 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11231 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11232 break;
11233 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11234 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11235 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11236 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11237 break;
11238 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11239 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11240 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11241 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11242 break;
11243 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11244 break;
11245 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11246 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11247 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11248 break;
11249 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11250 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11251 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11252 break;
11253 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11254 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11255 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11256 break;
11257 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11258 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11259 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11260 break;
11261 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11262 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11263 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11264 break;
11265 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11266 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11267 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11268 break;
11269 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11270 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11271 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11272 break;
11273 }
11274 }
11275
11276 // set hashfile
11277
11278 switch (hash_mode)
11279 {
11280 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11281 break;
11282 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11283 break;
11284 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11285 break;
11286 case 6211:
11287 case 6212:
11288 case 6213:
11289 case 6221:
11290 case 6222:
11291 case 6223:
11292 case 6231:
11293 case 6232:
11294 case 6233:
11295 case 6241:
11296 case 6242:
11297 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11298 break;
11299 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11300 break;
11301 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11302 break;
11303 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11304 break;
11305 }
11306
11307 // set default iterations
11308
11309 switch (hash_mode)
11310 {
11311 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11312 break;
11313 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11314 break;
11315 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11316 break;
11317 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11318 break;
11319 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11320 break;
11321 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11322 break;
11323 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11324 break;
11325 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11326 break;
11327 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11328 break;
11329 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11330 break;
11331 case 6211:
11332 case 6212:
11333 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11334 break;
11335 case 6221:
11336 case 6222:
11337 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11338 break;
11339 case 6231:
11340 case 6232:
11341 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11342 break;
11343 case 6241:
11344 case 6242:
11345 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11346 break;
11347 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11348 break;
11349 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11350 break;
11351 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11352 break;
11353 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11354 break;
11355 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11356 break;
11357 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11358 break;
11359 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11360 break;
11361 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11362 break;
11363 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11364 break;
11365 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11366 break;
11367 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11368 break;
11369 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11370 break;
11371 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11372 break;
11373 case 8900: hashes_buf[0].salt->salt_iter = 1;
11374 break;
11375 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11376 break;
11377 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11378 break;
11379 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11380 break;
11381 case 9300: hashes_buf[0].salt->salt_iter = 1;
11382 break;
11383 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11384 break;
11385 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11386 break;
11387 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11388 break;
11389 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11390 break;
11391 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11392 break;
11393 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11394 break;
11395 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11396 break;
11397 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11398 break;
11399 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11400 break;
11401 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11402 break;
11403 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11404 break;
11405 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11406 break;
11407 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11408 break;
11409 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11410 break;
11411 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11412 break;
11413 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11414 break;
11415 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11416 break;
11417 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11418 break;
11419 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11420 break;
11421 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11422 break;
11423 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11424 break;
11425 }
11426
11427 hashes_cnt = 1;
11428 }
11429
11430 if (show == 1 || left == 1)
11431 {
11432 for (uint i = 0; i < pot_cnt; i++)
11433 {
11434 pot_t *pot_ptr = &pot[i];
11435
11436 hash_t *hashes_buf = &pot_ptr->hash;
11437
11438 local_free (hashes_buf->digest);
11439
11440 if (isSalted)
11441 {
11442 local_free (hashes_buf->salt);
11443 }
11444 }
11445
11446 local_free (pot);
11447
11448 if (data.quiet == 0) log_info_nn ("");
11449
11450 return (0);
11451 }
11452
11453 if (keyspace == 0)
11454 {
11455 if (hashes_cnt == 0)
11456 {
11457 log_error ("ERROR: No hashes loaded");
11458
11459 return (-1);
11460 }
11461 }
11462
11463 /**
11464 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11465 */
11466
11467 if (data.outfile != NULL)
11468 {
11469 if (data.hashfile != NULL)
11470 {
11471 #ifdef _POSIX
11472 struct stat tmpstat_outfile;
11473 struct stat tmpstat_hashfile;
11474 #endif
11475
11476 #ifdef _WIN
11477 struct stat64 tmpstat_outfile;
11478 struct stat64 tmpstat_hashfile;
11479 #endif
11480
11481 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11482
11483 if (tmp_outfile_fp)
11484 {
11485 #ifdef _POSIX
11486 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11487 #endif
11488
11489 #ifdef _WIN
11490 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11491 #endif
11492
11493 fclose (tmp_outfile_fp);
11494 }
11495
11496 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11497
11498 if (tmp_hashfile_fp)
11499 {
11500 #ifdef _POSIX
11501 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11502 #endif
11503
11504 #ifdef _WIN
11505 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11506 #endif
11507
11508 fclose (tmp_hashfile_fp);
11509 }
11510
11511 if (tmp_outfile_fp && tmp_outfile_fp)
11512 {
11513 tmpstat_outfile.st_mode = 0;
11514 tmpstat_outfile.st_nlink = 0;
11515 tmpstat_outfile.st_uid = 0;
11516 tmpstat_outfile.st_gid = 0;
11517 tmpstat_outfile.st_rdev = 0;
11518 tmpstat_outfile.st_atime = 0;
11519
11520 tmpstat_hashfile.st_mode = 0;
11521 tmpstat_hashfile.st_nlink = 0;
11522 tmpstat_hashfile.st_uid = 0;
11523 tmpstat_hashfile.st_gid = 0;
11524 tmpstat_hashfile.st_rdev = 0;
11525 tmpstat_hashfile.st_atime = 0;
11526
11527 #ifdef _POSIX
11528 tmpstat_outfile.st_blksize = 0;
11529 tmpstat_outfile.st_blocks = 0;
11530
11531 tmpstat_hashfile.st_blksize = 0;
11532 tmpstat_hashfile.st_blocks = 0;
11533 #endif
11534
11535 #ifdef _POSIX
11536 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11537 {
11538 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11539
11540 return (-1);
11541 }
11542 #endif
11543
11544 #ifdef _WIN
11545 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11546 {
11547 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11548
11549 return (-1);
11550 }
11551 #endif
11552 }
11553 }
11554 }
11555
11556 /**
11557 * Remove duplicates
11558 */
11559
11560 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11561
11562 if (isSalted)
11563 {
11564 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11565 }
11566 else
11567 {
11568 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11569 }
11570
11571 uint hashes_cnt_orig = hashes_cnt;
11572
11573 hashes_cnt = 1;
11574
11575 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11576 {
11577 if (isSalted)
11578 {
11579 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11580 {
11581 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11582 }
11583 }
11584 else
11585 {
11586 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11587 }
11588
11589 if (hashes_pos > hashes_cnt)
11590 {
11591 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11592 }
11593
11594 hashes_cnt++;
11595 }
11596
11597 /**
11598 * Potfile removes
11599 */
11600
11601 uint potfile_remove_cracks = 0;
11602
11603 if (potfile_disable == 0)
11604 {
11605 hash_t hash_buf;
11606
11607 hash_buf.digest = mymalloc (dgst_size);
11608 hash_buf.salt = NULL;
11609 hash_buf.esalt = NULL;
11610 hash_buf.hash_info = NULL;
11611 hash_buf.cracked = 0;
11612
11613 if (isSalted)
11614 {
11615 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11616 }
11617
11618 if (esalt_size)
11619 {
11620 hash_buf.esalt = mymalloc (esalt_size);
11621 }
11622
11623 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11624
11625 // no solution for these special hash types (for instane because they use hashfile in output etc)
11626 if ((hash_mode != 5200) &&
11627 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11628 (hash_mode != 9000))
11629 {
11630 FILE *fp = fopen (potfile, "rb");
11631
11632 if (fp != NULL)
11633 {
11634 while (!feof (fp))
11635 {
11636 char line_buf[BUFSIZ] = { 0 };
11637
11638 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11639
11640 if (ptr == NULL) break;
11641
11642 int line_len = strlen (line_buf);
11643
11644 if (line_len == 0) continue;
11645
11646 int iter = MAX_CUT_TRIES;
11647
11648 for (int i = line_len - 1; i && iter; i--, line_len--)
11649 {
11650 if (line_buf[i] != ':') continue;
11651
11652 if (isSalted)
11653 {
11654 memset (hash_buf.salt, 0, sizeof (salt_t));
11655 }
11656
11657 hash_t *found = NULL;
11658
11659 if (hash_mode == 6800)
11660 {
11661 if (i < 64) // 64 = 16 * uint in salt_buf[]
11662 {
11663 // manipulate salt_buf
11664 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11665
11666 hash_buf.salt->salt_len = i;
11667
11668 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11669 }
11670 }
11671 else if (hash_mode == 2500)
11672 {
11673 if (i < 64) // 64 = 16 * uint in salt_buf[]
11674 {
11675 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11676 // manipulate salt_buf
11677
11678 // to be safe work with a copy (because of line_len loop, i etc)
11679
11680 char line_buf_cpy[BUFSIZ] = { 0 };
11681
11682 memcpy (line_buf_cpy, line_buf, i);
11683
11684 char *mac2_pos = strrchr (line_buf_cpy, ':');
11685
11686 if (mac2_pos == NULL) continue;
11687
11688 mac2_pos[0] = 0;
11689 mac2_pos++;
11690
11691 if (strlen (mac2_pos) != 12) continue;
11692
11693 char *mac1_pos = strrchr (line_buf_cpy, ':');
11694
11695 if (mac1_pos == NULL) continue;
11696
11697 mac1_pos[0] = 0;
11698 mac1_pos++;
11699
11700 if (strlen (mac1_pos) != 12) continue;
11701
11702 uint essid_length = mac1_pos - line_buf_cpy - 1;
11703
11704 // here we need the ESSID
11705 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11706
11707 hash_buf.salt->salt_len = essid_length;
11708
11709 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11710
11711 if (found)
11712 {
11713 wpa_t *wpa = (wpa_t *) found->esalt;
11714
11715 uint pke[25] = { 0 };
11716
11717 char *pke_ptr = (char *) pke;
11718
11719 for (uint i = 0; i < 25; i++)
11720 {
11721 pke[i] = byte_swap_32 (wpa->pke[i]);
11722 }
11723
11724 u8 mac1[6] = { 0 };
11725 u8 mac2[6] = { 0 };
11726
11727 memcpy (mac1, pke_ptr + 23, 6);
11728 memcpy (mac2, pke_ptr + 29, 6);
11729
11730 // compare hex string(s) vs binary MAC address(es)
11731
11732 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11733 {
11734 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11735 {
11736 found = NULL;
11737 break;
11738 }
11739 }
11740
11741 // early skip ;)
11742 if (!found) continue;
11743
11744 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11745 {
11746 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11747 {
11748 found = NULL;
11749 break;
11750 }
11751 }
11752 }
11753 }
11754 }
11755 else
11756 {
11757 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11758
11759 if (parser_status == PARSER_OK)
11760 {
11761 if (isSalted)
11762 {
11763 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11764 }
11765 else
11766 {
11767 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11768 }
11769 }
11770 }
11771
11772 if (found == NULL) continue;
11773
11774 if (!found->cracked) potfile_remove_cracks++;
11775
11776 found->cracked = 1;
11777
11778 if (found) break;
11779
11780 iter--;
11781 }
11782 }
11783
11784 fclose (fp);
11785 }
11786 }
11787
11788 if (esalt_size)
11789 {
11790 local_free (hash_buf.esalt);
11791 }
11792
11793 if (isSalted)
11794 {
11795 local_free (hash_buf.salt);
11796 }
11797
11798 local_free (hash_buf.digest);
11799 }
11800
11801 /**
11802 * Now generate all the buffers required for later
11803 */
11804
11805 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11806
11807 salt_t *salts_buf_new = NULL;
11808 void *esalts_buf_new = NULL;
11809
11810 if (isSalted)
11811 {
11812 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11813
11814 if (esalt_size)
11815 {
11816 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11817 }
11818 }
11819 else
11820 {
11821 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11822 }
11823
11824 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11825
11826 uint digests_cnt = hashes_cnt;
11827 uint digests_done = 0;
11828
11829 uint size_digests = digests_cnt * dgst_size;
11830 uint size_shown = digests_cnt * sizeof (uint);
11831
11832 uint *digests_shown = (uint *) mymalloc (size_shown);
11833 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11834
11835 uint salts_cnt = 0;
11836 uint salts_done = 0;
11837
11838 hashinfo_t **hash_info = NULL;
11839
11840 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11841 {
11842 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11843
11844 if (username && (remove || show))
11845 {
11846 uint user_pos;
11847
11848 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11849 {
11850 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11851
11852 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11853 }
11854 }
11855 }
11856
11857 uint *salts_shown = (uint *) mymalloc (size_shown);
11858
11859 salt_t *salt_buf;
11860
11861 {
11862 // copied from inner loop
11863
11864 salt_buf = &salts_buf_new[salts_cnt];
11865
11866 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11867
11868 if (esalt_size)
11869 {
11870 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11871 }
11872
11873 salt_buf->digests_cnt = 0;
11874 salt_buf->digests_done = 0;
11875 salt_buf->digests_offset = 0;
11876
11877 salts_cnt++;
11878 }
11879
11880 if (hashes_buf[0].cracked == 1)
11881 {
11882 digests_shown[0] = 1;
11883
11884 digests_done++;
11885
11886 salt_buf->digests_done++;
11887 }
11888
11889 salt_buf->digests_cnt++;
11890
11891 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11892
11893 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11894 {
11895 hash_info[0] = hashes_buf[0].hash_info;
11896 }
11897
11898 // copy from inner loop
11899
11900 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11901 {
11902 if (isSalted)
11903 {
11904 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11905 {
11906 salt_buf = &salts_buf_new[salts_cnt];
11907
11908 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11909
11910 if (esalt_size)
11911 {
11912 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11913 }
11914
11915 salt_buf->digests_cnt = 0;
11916 salt_buf->digests_done = 0;
11917 salt_buf->digests_offset = hashes_pos;
11918
11919 salts_cnt++;
11920 }
11921 }
11922
11923 if (hashes_buf[hashes_pos].cracked == 1)
11924 {
11925 digests_shown[hashes_pos] = 1;
11926
11927 digests_done++;
11928
11929 salt_buf->digests_done++;
11930 }
11931
11932 salt_buf->digests_cnt++;
11933
11934 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11935
11936 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11937 {
11938 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11939 }
11940 }
11941
11942 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11943 {
11944 salt_t *salt_buf = &salts_buf_new[salt_pos];
11945
11946 if (salt_buf->digests_done == salt_buf->digests_cnt)
11947 {
11948 salts_shown[salt_pos] = 1;
11949
11950 salts_done++;
11951 }
11952
11953 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11954 }
11955
11956 local_free (digests_buf);
11957 local_free (salts_buf);
11958 local_free (esalts_buf);
11959
11960 digests_buf = digests_buf_new;
11961 salts_buf = salts_buf_new;
11962 esalts_buf = esalts_buf_new;
11963
11964 local_free (hashes_buf);
11965
11966 /**
11967 * special modification not set from parser
11968 */
11969
11970 switch (hash_mode)
11971 {
11972 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11973 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11974 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11975 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11976 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11977 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11978 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11979 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11980 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11981 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11982 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11983 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11984 }
11985
11986 if (truecrypt_keyfiles)
11987 {
11988 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11989
11990 char *keyfiles = strdup (truecrypt_keyfiles);
11991
11992 char *keyfile = strtok (keyfiles, ",");
11993
11994 do
11995 {
11996 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
11997
11998 } while ((keyfile = strtok (NULL, ",")) != NULL);
11999
12000 free (keyfiles);
12001 }
12002
12003 data.digests_cnt = digests_cnt;
12004 data.digests_done = digests_done;
12005 data.digests_buf = digests_buf;
12006 data.digests_shown = digests_shown;
12007 data.digests_shown_tmp = digests_shown_tmp;
12008
12009 data.salts_cnt = salts_cnt;
12010 data.salts_done = salts_done;
12011 data.salts_buf = salts_buf;
12012 data.salts_shown = salts_shown;
12013
12014 data.esalts_buf = esalts_buf;
12015 data.hash_info = hash_info;
12016
12017 /**
12018 * Automatic Optimizers
12019 */
12020
12021 if (salts_cnt == 1)
12022 opti_type |= OPTI_TYPE_SINGLE_SALT;
12023
12024 if (digests_cnt == 1)
12025 opti_type |= OPTI_TYPE_SINGLE_HASH;
12026
12027 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12028 opti_type |= OPTI_TYPE_NOT_ITERATED;
12029
12030 if (attack_mode == ATTACK_MODE_BF)
12031 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12032
12033 data.opti_type = opti_type;
12034
12035 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12036 {
12037 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12038 {
12039 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12040 {
12041 if (opts_type & OPTS_TYPE_ST_ADD80)
12042 {
12043 opts_type &= ~OPTS_TYPE_ST_ADD80;
12044 opts_type |= OPTS_TYPE_PT_ADD80;
12045 }
12046
12047 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12048 {
12049 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12050 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12051 }
12052
12053 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12054 {
12055 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12056 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12057 }
12058 }
12059 }
12060 }
12061
12062 /**
12063 * Some algorithm, like descrypt, can benefit from JIT compilation
12064 */
12065
12066 int force_jit_compilation = -1;
12067
12068 if (hash_mode == 8900)
12069 {
12070 force_jit_compilation = 8900;
12071 }
12072 else if (hash_mode == 9300)
12073 {
12074 force_jit_compilation = 8900;
12075 }
12076 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12077 {
12078 force_jit_compilation = 1500;
12079 }
12080
12081 /**
12082 * generate bitmap tables
12083 */
12084
12085 const uint bitmap_shift1 = 5;
12086 const uint bitmap_shift2 = 13;
12087
12088 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12089
12090 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12091 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12092 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12093 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12094 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12095 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12096 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12097 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12098
12099 uint bitmap_bits;
12100 uint bitmap_nums;
12101 uint bitmap_mask;
12102 uint bitmap_size;
12103
12104 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12105 {
12106 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12107
12108 bitmap_nums = 1 << bitmap_bits;
12109
12110 bitmap_mask = bitmap_nums - 1;
12111
12112 bitmap_size = bitmap_nums * sizeof (uint);
12113
12114 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12115
12116 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;
12117 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;
12118
12119 break;
12120 }
12121
12122 bitmap_nums = 1 << bitmap_bits;
12123
12124 bitmap_mask = bitmap_nums - 1;
12125
12126 bitmap_size = bitmap_nums * sizeof (uint);
12127
12128 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);
12129 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);
12130
12131 /**
12132 * prepare quick rule
12133 */
12134
12135 data.rule_buf_l = rule_buf_l;
12136 data.rule_buf_r = rule_buf_r;
12137
12138 int rule_len_l = (int) strlen (rule_buf_l);
12139 int rule_len_r = (int) strlen (rule_buf_r);
12140
12141 data.rule_len_l = rule_len_l;
12142 data.rule_len_r = rule_len_r;
12143
12144 /**
12145 * load rules
12146 */
12147
12148 uint *all_kernel_rules_cnt = NULL;
12149
12150 kernel_rule_t **all_kernel_rules_buf = NULL;
12151
12152 if (rp_files_cnt)
12153 {
12154 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12155
12156 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12157 }
12158
12159 char rule_buf[BUFSIZ] = { 0 };
12160
12161 int rule_len = 0;
12162
12163 for (uint i = 0; i < rp_files_cnt; i++)
12164 {
12165 uint kernel_rules_avail = 0;
12166
12167 uint kernel_rules_cnt = 0;
12168
12169 kernel_rule_t *kernel_rules_buf = NULL;
12170
12171 char *rp_file = rp_files[i];
12172
12173 char in[BLOCK_SIZE] = { 0 };
12174 char out[BLOCK_SIZE] = { 0 };
12175
12176 FILE *fp = NULL;
12177
12178 uint rule_line = 0;
12179
12180 if ((fp = fopen (rp_file, "rb")) == NULL)
12181 {
12182 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12183
12184 return (-1);
12185 }
12186
12187 while (!feof (fp))
12188 {
12189 memset (rule_buf, 0, BUFSIZ);
12190
12191 rule_len = fgetl (fp, rule_buf);
12192
12193 rule_line++;
12194
12195 if (rule_len == 0) continue;
12196
12197 if (rule_buf[0] == '#') continue;
12198
12199 if (kernel_rules_avail == kernel_rules_cnt)
12200 {
12201 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12202
12203 kernel_rules_avail += INCR_RULES;
12204 }
12205
12206 memset (in, 0, BLOCK_SIZE);
12207 memset (out, 0, BLOCK_SIZE);
12208
12209 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12210
12211 if (result == -1)
12212 {
12213 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12214
12215 continue;
12216 }
12217
12218 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12219 {
12220 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12221
12222 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12223
12224 continue;
12225 }
12226
12227 /* its so slow
12228 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12229 {
12230 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12231
12232 continue;
12233 }
12234 */
12235
12236 kernel_rules_cnt++;
12237 }
12238
12239 fclose (fp);
12240
12241 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12242
12243 all_kernel_rules_buf[i] = kernel_rules_buf;
12244 }
12245
12246 /**
12247 * merge rules or automatic rule generator
12248 */
12249
12250 uint kernel_rules_cnt = 0;
12251
12252 kernel_rule_t *kernel_rules_buf = NULL;
12253
12254 if (attack_mode == ATTACK_MODE_STRAIGHT)
12255 {
12256 if (rp_files_cnt)
12257 {
12258 kernel_rules_cnt = 1;
12259
12260 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12261
12262 repeats[0] = kernel_rules_cnt;
12263
12264 for (uint i = 0; i < rp_files_cnt; i++)
12265 {
12266 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12267
12268 repeats[i + 1] = kernel_rules_cnt;
12269 }
12270
12271 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12272
12273 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12274
12275 for (uint i = 0; i < kernel_rules_cnt; i++)
12276 {
12277 uint out_pos = 0;
12278
12279 kernel_rule_t *out = &kernel_rules_buf[i];
12280
12281 for (uint j = 0; j < rp_files_cnt; j++)
12282 {
12283 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12284 uint in_pos;
12285
12286 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12287
12288 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12289 {
12290 if (out_pos == RULES_MAX - 1)
12291 {
12292 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12293
12294 break;
12295 }
12296
12297 out->cmds[out_pos] = in->cmds[in_pos];
12298 }
12299 }
12300 }
12301
12302 local_free (repeats);
12303 }
12304 else if (rp_gen)
12305 {
12306 uint kernel_rules_avail = 0;
12307
12308 while (kernel_rules_cnt < rp_gen)
12309 {
12310 if (kernel_rules_avail == kernel_rules_cnt)
12311 {
12312 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12313
12314 kernel_rules_avail += INCR_RULES;
12315 }
12316
12317 memset (rule_buf, 0, BLOCK_SIZE);
12318
12319 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12320
12321 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12322
12323 kernel_rules_cnt++;
12324 }
12325 }
12326 }
12327
12328 /**
12329 * generate NOP rules
12330 */
12331
12332 if (kernel_rules_cnt == 0)
12333 {
12334 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12335
12336 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12337
12338 kernel_rules_cnt++;
12339 }
12340
12341 data.kernel_rules_cnt = kernel_rules_cnt;
12342 data.kernel_rules_buf = kernel_rules_buf;
12343
12344 /**
12345 * OpenCL platforms: detect
12346 */
12347
12348 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12349 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12350
12351 cl_uint platforms_cnt = 0;
12352 cl_uint platform_devices_cnt = 0;
12353
12354 if (keyspace == 0)
12355 {
12356 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12357
12358 if (platforms_cnt == 0)
12359 {
12360 log_error ("ERROR: No OpenCL compatible platform found");
12361
12362 return (-1);
12363 }
12364 }
12365
12366 /**
12367 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12368 */
12369
12370 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12371 {
12372 cl_platform_id platform = platforms[platform_id];
12373
12374 char platform_vendor[INFOSZ] = { 0 };
12375
12376 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12377
12378 #ifdef HAVE_HWMON
12379 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12380 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12381 {
12382 // make sure that we do not directly control the fan for NVidia
12383
12384 gpu_temp_retain = 0;
12385
12386 data.gpu_temp_retain = gpu_temp_retain;
12387 }
12388 #endif // HAVE_NVML || HAVE_NVAPI
12389 #endif
12390 }
12391
12392 /**
12393 * OpenCL devices: simply push all devices from all platforms into the same device array
12394 */
12395
12396 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12397
12398 data.devices_param = devices_param;
12399
12400 uint devices_cnt = 0;
12401
12402 uint devices_active = 0;
12403
12404 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12405 {
12406 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12407
12408 cl_platform_id platform = platforms[platform_id];
12409
12410 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12411
12412 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12413 {
12414 size_t param_value_size = 0;
12415
12416 const uint device_id = devices_cnt;
12417
12418 hc_device_param_t *device_param = &data.devices_param[device_id];
12419
12420 device_param->device = platform_devices[platform_devices_id];
12421
12422 device_param->device_id = device_id;
12423
12424 device_param->platform_devices_id = platform_devices_id;
12425
12426 // device_type
12427
12428 cl_device_type device_type;
12429
12430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12431
12432 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12433
12434 device_param->device_type = device_type;
12435
12436 // vendor_id
12437
12438 cl_uint vendor_id = 0;
12439
12440 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12441
12442 device_param->vendor_id = vendor_id;
12443
12444 // device_name
12445
12446 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12447
12448 char *device_name = (char *) mymalloc (param_value_size);
12449
12450 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12451
12452 device_param->device_name = device_name;
12453
12454 // device_version
12455
12456 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12457
12458 char *device_version = (char *) mymalloc (param_value_size);
12459
12460 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12461
12462 device_param->device_version = device_version;
12463
12464 // device_opencl_version
12465
12466 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12467
12468 char *device_opencl_version = (char *) mymalloc (param_value_size);
12469
12470 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12471
12472 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12473
12474 myfree (device_opencl_version);
12475
12476 if (strstr (device_version, "pocl"))
12477 {
12478 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12479 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12480
12481 cl_uint vendor_id = VENDOR_ID_GENERIC;
12482
12483 device_param->vendor_id = vendor_id;
12484 }
12485
12486 // max_compute_units
12487
12488 cl_uint vector_width;
12489
12490 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12491 {
12492 #ifndef OSX
12493 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12494 #else
12495 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
12496 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12497 else
12498 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12499 #endif
12500
12501 int is_ti = 0;
12502
12503 const int device_name_len = strlen (device_name);
12504
12505 if (device_name[device_name_len - 2] == 't') is_ti++;
12506 if (device_name[device_name_len - 2] == 'T') is_ti++;
12507 if (device_name[device_name_len - 1] == 'i') is_ti++;
12508 if (device_name[device_name_len - 1] == 'I') is_ti++;
12509
12510 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12511 {
12512 // Yeah that's a super bad hack, but there's no other attribute we could use
12513
12514 if (vector_width < 2) vector_width *= 2;
12515 }
12516
12517 if (opti_type & OPTI_TYPE_USES_BITS_64)
12518 {
12519 if (vector_width > 1) vector_width /= 2;
12520 }
12521 }
12522 else
12523 {
12524 vector_width = opencl_vector_width;
12525 }
12526
12527 if (vector_width > 8) vector_width = 8;
12528
12529 device_param->vector_width = vector_width;
12530
12531 // max_compute_units
12532
12533 cl_uint device_processors;
12534
12535 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12536
12537 device_param->device_processors = device_processors;
12538
12539 // max_mem_alloc_size
12540
12541 cl_ulong device_maxmem_alloc;
12542
12543 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12544
12545 device_param->device_maxmem_alloc = device_maxmem_alloc;
12546
12547 // max_mem_alloc_size
12548
12549 cl_ulong device_global_mem;
12550
12551 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12552
12553 device_param->device_global_mem = device_global_mem;
12554
12555 // max_clock_frequency
12556
12557 cl_uint device_maxclock_frequency;
12558
12559 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12560
12561 device_param->device_maxclock_frequency = device_maxclock_frequency;
12562
12563 // device_timer_resolution
12564
12565 cl_ulong device_timer_resolution;
12566
12567 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof (device_timer_resolution), &device_timer_resolution, NULL);
12568
12569 device_param->device_timer_resolution = device_timer_resolution;
12570
12571 // skipped
12572
12573 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12574 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12575
12576 device_param->skipped = (skipped1 || skipped2);
12577
12578 // driver_version
12579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12580
12581 char *driver_version = (char *) mymalloc (param_value_size);
12582
12583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12584
12585 device_param->driver_version = driver_version;
12586
12587 // device_name_chksum
12588
12589 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12590
12591 #if __x86_64__
12592 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);
12593 #else
12594 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);
12595 #endif
12596
12597 uint device_name_digest[4] = { 0 };
12598
12599 md5_64 ((uint *) device_name_chksum, device_name_digest);
12600
12601 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12602
12603 device_param->device_name_chksum = device_name_chksum;
12604
12605 // device_processor_cores
12606
12607 if (device_type & CL_DEVICE_TYPE_CPU)
12608 {
12609 cl_uint device_processor_cores = 1;
12610
12611 device_param->device_processor_cores = device_processor_cores;
12612 }
12613
12614 if (device_type & CL_DEVICE_TYPE_GPU)
12615 {
12616 if (vendor_id == VENDOR_ID_AMD)
12617 {
12618 cl_uint device_processor_cores = 0;
12619
12620 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12621
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12623
12624 device_param->device_processor_cores = device_processor_cores;
12625 }
12626 else if (vendor_id == VENDOR_ID_NV)
12627 {
12628 cl_uint kernel_exec_timeout = 0;
12629
12630 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12631
12632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12633
12634 device_param->kernel_exec_timeout = kernel_exec_timeout;
12635
12636 cl_uint device_processor_cores = 0;
12637
12638 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12639
12640 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12641
12642 device_param->device_processor_cores = device_processor_cores;
12643
12644 cl_uint sm_minor = 0;
12645 cl_uint sm_major = 0;
12646
12647 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12648 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12649
12650 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12652
12653 device_param->sm_minor = sm_minor;
12654 device_param->sm_major = sm_major;
12655 }
12656 else
12657 {
12658 cl_uint device_processor_cores = 1;
12659
12660 device_param->device_processor_cores = device_processor_cores;
12661 }
12662 }
12663
12664 // display results
12665
12666 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12667 {
12668 if (device_param->skipped == 0)
12669 {
12670 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12671 device_id + 1,
12672 device_name,
12673 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12674 (unsigned int) (device_global_mem / 1024 / 1024),
12675 (unsigned int) (device_maxclock_frequency),
12676 (unsigned int) device_processors);
12677 }
12678 else
12679 {
12680 log_info ("Device #%u: %s, skipped",
12681 device_id + 1,
12682 device_name);
12683 }
12684 }
12685
12686 // common driver check
12687
12688 if (device_param->skipped == 0)
12689 {
12690 if (strstr (device_version, "pocl"))
12691 {
12692 if (force == 0)
12693 {
12694 log_info ("");
12695 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12696 log_info ("You are STRONGLY encouraged not to use it");
12697 log_info ("You can use --force to override this but do not post error reports if you do so");
12698 log_info ("");
12699
12700 return (-1);
12701 }
12702 }
12703
12704 if (device_type & CL_DEVICE_TYPE_GPU)
12705 {
12706 if (vendor_id == VENDOR_ID_NV)
12707 {
12708 if (device_param->kernel_exec_timeout != 0)
12709 {
12710 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);
12711 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12712 }
12713 }
12714 else if (vendor_id == VENDOR_ID_AMD)
12715 {
12716 int catalyst_check = (force == 1) ? 0 : 1;
12717
12718 int catalyst_warn = 0;
12719
12720 int catalyst_broken = 0;
12721
12722 if (catalyst_check == 1)
12723 {
12724 catalyst_warn = 1;
12725
12726 // v14.9 and higher
12727 if (atoi (device_param->driver_version) >= 1573)
12728 {
12729 catalyst_warn = 0;
12730 }
12731
12732 catalyst_check = 0;
12733 }
12734
12735 if (catalyst_broken == 1)
12736 {
12737 log_info ("");
12738 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12739 log_info ("It will pass over cracked hashes and does not report them as cracked");
12740 log_info ("You are STRONGLY encouraged not to use it");
12741 log_info ("You can use --force to override this but do not post error reports if you do so");
12742 log_info ("");
12743
12744 return (-1);
12745 }
12746
12747 if (catalyst_warn == 1)
12748 {
12749 log_info ("");
12750 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12751 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12752 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12753 #ifdef _WIN
12754 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12755 #endif
12756 log_info ("You can use --force to override this but do not post error reports if you do so");
12757 log_info ("");
12758
12759 return (-1);
12760 }
12761 }
12762 }
12763
12764 /**
12765 * kernel accel and loops auto adjustment
12766 */
12767
12768 uint _kernel_accel = kernel_accel;
12769 uint _kernel_loops = kernel_loops;
12770
12771 #ifndef OSX
12772 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode);
12773 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode);
12774 #else
12775 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12776 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12777 #endif
12778
12779 if (workload_profile == 1)
12780 {
12781 _kernel_loops /= 8;
12782 _kernel_accel /= 4;
12783
12784 if (_kernel_loops == 0) _kernel_loops = 8;
12785 if (_kernel_accel == 0) _kernel_accel = 2;
12786 }
12787 else if (workload_profile == 3)
12788 {
12789 _kernel_loops *= 8;
12790 _kernel_accel *= 4;
12791
12792 if (_kernel_loops > 1024) _kernel_loops = 1024;
12793 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
12794 }
12795
12796 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
12797
12798 if (benchmark == 1 && benchmark_mode == 1)
12799 {
12800 _kernel_loops *= 8;
12801 _kernel_accel *= 4;
12802
12803 #ifdef OSX
12804 bool isCpu = device_param->device_type & CL_DEVICE_TYPE_CPU;
12805
12806 if (!isCpu)
12807 {
12808 if (hash_mode == 7100 || hash_mode == 8200 || hash_mode == 9600 || \
12809 hash_mode == 11300 || hash_mode == 11600 || hash_mode == 12200)
12810 {
12811 _kernel_accel = 1;
12812 }
12813 else if (hash_mode == 7200 || hash_mode == 9300 || hash_mode == 13000)
12814 {
12815 _kernel_accel = 2;
12816 }
12817 else if (hash_mode == 3200)
12818 {
12819 _kernel_loops = ROUNDS_BCRYPT / 2;
12820 }
12821 else if (hash_mode == 6231)
12822 {
12823 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12824 _kernel_accel = 1;
12825 }
12826 else if (hash_mode == 6241)
12827 {
12828 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12829 _kernel_accel = 1;
12830 }
12831 }
12832 else
12833 {
12834 if (hash_mode == 3200)
12835 {
12836 _kernel_loops = ROUNDS_BCRYPT;
12837 }
12838 else if (hash_mode == 6231)
12839 {
12840 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12841 _kernel_accel = 8;
12842 }
12843 else if (hash_mode == 6241)
12844 {
12845 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12846 _kernel_accel = 128;
12847 }
12848 }
12849 #endif
12850
12851 switch (hash_mode)
12852 {
12853 case 400: _kernel_loops = ROUNDS_PHPASS;
12854 _kernel_accel = 32;
12855 break;
12856 case 500: _kernel_loops = ROUNDS_MD5CRYPT;
12857 _kernel_accel = 32;
12858 break;
12859 case 501: _kernel_loops = ROUNDS_MD5CRYPT;
12860 _kernel_accel = 32;
12861 break;
12862 case 1600: _kernel_loops = ROUNDS_MD5CRYPT;
12863 _kernel_accel = 32;
12864 break;
12865 case 1800: _kernel_loops = ROUNDS_SHA512CRYPT;
12866 #ifndef OSX
12867 _kernel_accel = 16;
12868 #else
12869 if (isCpu) _kernel_accel = 16;
12870 #endif
12871 break;
12872 case 2100: _kernel_loops = ROUNDS_DCC2;
12873 _kernel_accel = 16;
12874 break;
12875 case 2500: _kernel_loops = ROUNDS_WPA2;
12876 #ifndef OSX
12877 _kernel_accel = 32;
12878 #else
12879 if (isCpu) _kernel_accel = 32;
12880 #endif
12881 break;
12882 case 3200: _kernel_accel = 8;
12883 #ifndef OSX
12884 _kernel_loops = ROUNDS_BCRYPT;
12885 #endif
12886 break;
12887 case 5200: _kernel_loops = ROUNDS_PSAFE3;
12888 _kernel_accel = 16;
12889 break;
12890 case 5800: _kernel_loops = ROUNDS_ANDROIDPIN;
12891 _kernel_accel = 16;
12892 break;
12893 case 6211: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12894 #ifndef OSX
12895 _kernel_accel = 64;
12896 #else
12897 if (isCpu) _kernel_accel = 64;
12898 #endif
12899 break;
12900 case 6212: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12901 _kernel_accel = 32;
12902 break;
12903 case 6213: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12904 _kernel_accel = 32;
12905 break;
12906 case 6221: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12907 _kernel_accel = 8;
12908 break;
12909 case 6222: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12910 _kernel_accel = 8;
12911 break;
12912 case 6223: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12913 _kernel_accel = 8;
12914 break;
12915 #ifndef OSX
12916 case 6231: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12917 _kernel_accel = 8;
12918 break;
12919 #endif
12920 case 6232: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12921 _kernel_accel = 8;
12922 break;
12923 case 6233: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12924 _kernel_accel = 8;
12925 break;
12926 #ifndef OSX
12927 case 6241: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12928 _kernel_accel = 128;
12929 break;
12930 #endif
12931 case 6242: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12932 _kernel_accel = 64;
12933 break;
12934 case 6243: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12935 _kernel_accel = 64;
12936 break;
12937 case 6300: _kernel_loops = ROUNDS_MD5CRYPT;
12938 _kernel_accel = 32;
12939 break;
12940 case 6700: _kernel_loops = ROUNDS_SHA1AIX;
12941 _kernel_accel = 128;
12942 break;
12943 case 6400: _kernel_loops = ROUNDS_SHA256AIX;
12944 _kernel_accel = 128;
12945 break;
12946 case 6500: _kernel_loops = ROUNDS_SHA512AIX;
12947 _kernel_accel = 32;
12948 break;
12949 case 6600: _kernel_loops = ROUNDS_AGILEKEY;
12950 _kernel_accel = 64;
12951 break;
12952 case 6800: _kernel_loops = ROUNDS_LASTPASS;
12953 #ifndef OSX
12954 _kernel_accel = 64;
12955 #else
12956 if (isCpu) _kernel_accel = 64;
12957 #endif
12958 break;
12959 case 7100: _kernel_loops = ROUNDS_SHA512OSX;
12960 #ifndef OSX
12961 _kernel_accel = 8;
12962 #endif
12963 break;
12964 case 7200: _kernel_loops = ROUNDS_GRUB;
12965 #ifndef OSX
12966 _kernel_accel = 16;
12967 #endif
12968 break;
12969 case 7400: _kernel_loops = ROUNDS_SHA256CRYPT;
12970 _kernel_accel = 8;
12971 break;
12972 case 7900: _kernel_loops = ROUNDS_DRUPAL7;
12973 #ifndef OSX
12974 _kernel_accel = 8;
12975 #else
12976 if (isCpu) _kernel_accel = 8;
12977 #endif
12978 break;
12979 case 8200: _kernel_loops = ROUNDS_CLOUDKEY;
12980 #ifndef OSX
12981 _kernel_accel = 8;
12982 #endif
12983 break;
12984 case 8800: _kernel_loops = ROUNDS_ANDROIDFDE;
12985 _kernel_accel = 32;
12986 break;
12987 case 8900: _kernel_loops = 1;
12988 _kernel_accel = 64;
12989 break;
12990 case 9000: _kernel_loops = ROUNDS_PSAFE2;
12991 _kernel_accel = 16;
12992 break;
12993 case 9100: _kernel_loops = ROUNDS_LOTUS8;
12994 #ifndef OSX
12995 _kernel_accel = 64;
12996 #else
12997 if (isCpu) _kernel_accel = 64;
12998 #endif
12999 break;
13000 case 9200: _kernel_loops = ROUNDS_CISCO8;
13001 #ifndef OSX
13002 _kernel_accel = 8;
13003 #else
13004 if (isCpu) _kernel_accel = 8;
13005 #endif
13006 break;
13007 case 9300: _kernel_loops = 1;
13008 #ifndef OSX
13009 _kernel_accel = 4;
13010 #endif
13011 break;
13012 case 9400: _kernel_loops = ROUNDS_OFFICE2007;
13013 #ifndef OSX
13014 _kernel_accel = 32;
13015 #else
13016 if (isCpu) _kernel_accel = 32;
13017 #endif
13018 break;
13019 case 9500: _kernel_loops = ROUNDS_OFFICE2010;
13020 #ifndef OSX
13021 _kernel_accel = 32;
13022 #else
13023 if (isCpu) _kernel_accel = 32;
13024 #endif
13025 break;
13026 case 9600: _kernel_loops = ROUNDS_OFFICE2013;
13027 #ifndef OSX
13028 _kernel_accel = 8;
13029 #endif
13030 break;
13031 case 10000: _kernel_loops = ROUNDS_DJANGOPBKDF2;
13032 #ifndef OSX
13033 _kernel_accel = 8;
13034 #else
13035 if (isCpu) _kernel_accel = 8;
13036 #endif
13037 break;
13038 case 10300: _kernel_loops = ROUNDS_SAPH_SHA1;
13039 _kernel_accel = 16;
13040 break;
13041 case 10500: _kernel_loops = ROUNDS_PDF14;
13042 _kernel_accel = 256;
13043 break;
13044 case 10700: _kernel_loops = ROUNDS_PDF17L8;
13045 _kernel_accel = 8;
13046 break;
13047 case 10900: _kernel_loops = ROUNDS_PBKDF2_SHA256;
13048 _kernel_accel = 8;
13049 break;
13050 case 11300: _kernel_loops = ROUNDS_BITCOIN_WALLET;
13051 #ifndef OSX
13052 _kernel_accel = 8;
13053 #endif
13054 break;
13055 case 11600: _kernel_loops = ROUNDS_SEVEN_ZIP;
13056 #ifndef OSX
13057 _kernel_accel = 8;
13058 #endif
13059 break;
13060 case 11900: _kernel_loops = ROUNDS_PBKDF2_MD5;
13061 _kernel_accel = 8;
13062 break;
13063 case 12000: _kernel_loops = ROUNDS_PBKDF2_SHA1;
13064 _kernel_accel = 8;
13065 break;
13066 case 12100: _kernel_loops = ROUNDS_PBKDF2_SHA512;
13067 _kernel_accel = 8;
13068 break;
13069 case 12200: _kernel_loops = ROUNDS_ECRYPTFS;
13070 #ifndef OSX
13071 _kernel_accel = 8;
13072 #endif
13073 break;
13074 case 12300: _kernel_loops = ROUNDS_ORACLET;
13075 _kernel_accel = 8;
13076 break;
13077 case 12500: _kernel_loops = ROUNDS_RAR3;
13078 #ifndef OSX
13079 _kernel_accel = 32;
13080 #else
13081 if (isCpu) _kernel_accel = 32;
13082 #endif
13083 break;
13084 case 12700: _kernel_loops = ROUNDS_MYWALLET;
13085 _kernel_accel = 512;
13086 break;
13087 case 12800: _kernel_loops = ROUNDS_MS_DRSR;
13088 _kernel_accel = 512;
13089 break;
13090 case 12900: _kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
13091 _kernel_accel = 8;
13092 break;
13093 case 13000: _kernel_loops = ROUNDS_RAR5;
13094 #ifndef OSX
13095 _kernel_accel = 8;
13096 #endif
13097 break;
13098 }
13099
13100 // some algorithm collide too fast, make that impossible
13101
13102 switch (hash_mode)
13103 {
13104 case 11500: ((uint *) digests_buf)[1] = 1;
13105 break;
13106 }
13107
13108 if (_kernel_loops > 1024) _kernel_loops = 1024;
13109 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
13110 }
13111
13112 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13113 {
13114 _kernel_loops = 1024;
13115 }
13116
13117 if (hash_mode == 12500)
13118 {
13119 _kernel_loops = ROUNDS_RAR3 / 16;
13120 }
13121
13122 device_param->kernel_accel = _kernel_accel;
13123 device_param->kernel_loops = _kernel_loops;
13124
13125 devices_active++;
13126 }
13127
13128 // next please
13129
13130 devices_cnt++;
13131 }
13132 }
13133
13134 if (keyspace == 0 && devices_active == 0)
13135 {
13136 log_error ("ERROR: No devices found/left");
13137
13138 return (-1);
13139 }
13140
13141 data.devices_cnt = devices_cnt;
13142
13143 data.devices_active = devices_active;
13144
13145 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13146 {
13147 log_info ("");
13148 }
13149
13150 /**
13151 * HM devices: init
13152 */
13153
13154 #ifdef HAVE_HWMON
13155 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13156 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13157 #endif
13158
13159 #ifdef HAVE_ADL
13160 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13161 #endif
13162
13163 if (gpu_temp_disable == 0)
13164 {
13165 #if defined(WIN) && defined(HAVE_NVAPI)
13166 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13167
13168 if (nvapi_init (nvapi) == 0)
13169 data.hm_nv = nvapi;
13170
13171 if (data.hm_nv)
13172 {
13173 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13174 {
13175 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13176
13177 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13178
13179 int tmp_out = 0;
13180
13181 for (int i = 0; i < tmp_in; i++)
13182 {
13183 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13184 }
13185
13186 for (int i = 0; i < tmp_out; i++)
13187 {
13188 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13189
13190 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13191
13192 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;
13193 }
13194 }
13195 }
13196 #endif // WIN && HAVE_NVAPI
13197
13198 #if defined(LINUX) && defined(HAVE_NVML)
13199 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13200
13201 if (nvml_init (nvml) == 0)
13202 data.hm_nv = nvml;
13203
13204 if (data.hm_nv)
13205 {
13206 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13207 {
13208 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13209
13210 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13211
13212 int tmp_out = 0;
13213
13214 for (int i = 0; i < tmp_in; i++)
13215 {
13216 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13217 }
13218
13219 for (int i = 0; i < tmp_out; i++)
13220 {
13221 unsigned int speed;
13222
13223 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;
13224 }
13225 }
13226 }
13227 #endif // LINUX && HAVE_NVML
13228
13229 data.hm_amd = NULL;
13230
13231 #ifdef HAVE_ADL
13232 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13233
13234 if (adl_init (adl) == 0)
13235 data.hm_amd = adl;
13236
13237 if (data.hm_amd)
13238 {
13239 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13240 {
13241 // total number of adapters
13242
13243 int hm_adapters_num;
13244
13245 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13246
13247 // adapter info
13248
13249 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13250
13251 if (lpAdapterInfo == NULL) return (-1);
13252
13253 // get a list (of ids of) valid/usable adapters
13254
13255 int num_adl_adapters = 0;
13256
13257 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13258
13259 if (num_adl_adapters > 0)
13260 {
13261 hc_thread_mutex_lock (mux_adl);
13262
13263 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13264
13265 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13266
13267 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13268 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13269
13270 hc_thread_mutex_unlock (mux_adl);
13271 }
13272
13273 myfree (valid_adl_device_list);
13274 myfree (lpAdapterInfo);
13275 }
13276 }
13277 #endif // HAVE_ADL
13278
13279 if (data.hm_amd == NULL && data.hm_nv == NULL)
13280 {
13281 gpu_temp_disable = 1;
13282 }
13283 }
13284
13285 /**
13286 * OpenCL devices: allocate buffer for device specific information
13287 */
13288
13289 #ifdef HAVE_HWMON
13290 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13291
13292 #ifdef HAVE_ADL
13293 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13294
13295 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13296 #endif // ADL
13297 #endif
13298
13299 /**
13300 * enable custom signal handler(s)
13301 */
13302
13303 if (benchmark == 0)
13304 {
13305 hc_signal (sigHandler_default);
13306 }
13307 else
13308 {
13309 hc_signal (sigHandler_benchmark);
13310 }
13311
13312 /**
13313 * User-defined GPU temp handling
13314 */
13315
13316 #ifdef HAVE_HWMON
13317 if (gpu_temp_disable == 1)
13318 {
13319 gpu_temp_abort = 0;
13320 gpu_temp_retain = 0;
13321 }
13322
13323 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13324 {
13325 if (gpu_temp_abort < gpu_temp_retain)
13326 {
13327 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13328
13329 return (-1);
13330 }
13331 }
13332
13333 data.gpu_temp_disable = gpu_temp_disable;
13334 data.gpu_temp_abort = gpu_temp_abort;
13335 data.gpu_temp_retain = gpu_temp_retain;
13336 #endif
13337
13338 /**
13339 * inform the user
13340 */
13341
13342 if (data.quiet == 0)
13343 {
13344 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13345
13346 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);
13347
13348 if (attack_mode == ATTACK_MODE_STRAIGHT)
13349 {
13350 log_info ("Rules: %u", kernel_rules_cnt);
13351 }
13352
13353 if (opti_type)
13354 {
13355 log_info ("Applicable Optimizers:");
13356
13357 for (uint i = 0; i < 32; i++)
13358 {
13359 const uint opti_bit = 1u << i;
13360
13361 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13362 }
13363 }
13364
13365 /**
13366 * Watchdog and Temperature balance
13367 */
13368
13369 #ifdef HAVE_HWMON
13370 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13371 {
13372 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13373 }
13374
13375 if (gpu_temp_abort == 0)
13376 {
13377 log_info ("Watchdog: Temperature abort trigger disabled");
13378 }
13379 else
13380 {
13381 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13382 }
13383
13384 if (gpu_temp_retain == 0)
13385 {
13386 log_info ("Watchdog: Temperature retain trigger disabled");
13387 }
13388 else
13389 {
13390 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13391 }
13392 #endif
13393 }
13394
13395 if (data.quiet == 0) log_info ("");
13396
13397 /**
13398 * HM devices: copy
13399 */
13400
13401 if (gpu_temp_disable == 0)
13402 {
13403 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13404 {
13405 hc_device_param_t *device_param = &data.devices_param[device_id];
13406
13407 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13408
13409 if (device_param->skipped) continue;
13410
13411 const uint platform_devices_id = device_param->platform_devices_id;
13412
13413 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13414 if (device_param->vendor_id == VENDOR_ID_NV)
13415 {
13416 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13417 }
13418 #endif
13419
13420 #ifdef HAVE_ADL
13421 if (device_param->vendor_id == VENDOR_ID_AMD)
13422 {
13423 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13424 }
13425 #endif
13426 }
13427 }
13428
13429 /*
13430 * Temporary fix:
13431 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13432 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13433 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13434 * Driver / ADL bug?
13435 */
13436
13437 #ifdef HAVE_ADL
13438 if (powertune_enable == 1)
13439 {
13440 hc_thread_mutex_lock (mux_adl);
13441
13442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13443 {
13444 hc_device_param_t *device_param = &data.devices_param[device_id];
13445
13446 if (device_param->skipped) continue;
13447
13448 if (data.hm_device[device_id].od_version == 6)
13449 {
13450 // set powertune value only
13451
13452 int powertune_supported = 0;
13453
13454 int ADL_rc = 0;
13455
13456 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13457 {
13458 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13459
13460 return (-1);
13461 }
13462
13463 if (powertune_supported != 0)
13464 {
13465 // powertune set
13466 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13467
13468 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13469 {
13470 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13471
13472 return (-1);
13473 }
13474
13475 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13476 {
13477 log_error ("ERROR: Failed to set new ADL PowerControl values");
13478
13479 return (-1);
13480 }
13481 }
13482 }
13483 }
13484
13485 hc_thread_mutex_unlock (mux_adl);
13486 }
13487 #endif // HAVE_ADK
13488 #endif // HAVE_HWMON
13489
13490 #ifdef OSX
13491 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13492 {
13493 if (force == 0)
13494 {
13495 log_info ("");
13496 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13497 log_info ("You can use --force to override this but do not post error reports if you do so");
13498 log_info ("");
13499
13500 continue;
13501 }
13502 }
13503 #endif
13504
13505 #ifdef DEBUG
13506 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13507 #endif
13508
13509 uint kernel_blocks_all = 0;
13510
13511 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13512 {
13513 /**
13514 * host buffer
13515 */
13516
13517 hc_device_param_t *device_param = &data.devices_param[device_id];
13518
13519 if (device_param->skipped) continue;
13520
13521 /**
13522 * device properties
13523 */
13524
13525 char *device_name_chksum = device_param->device_name_chksum;
13526
13527 uint device_processors = device_param->device_processors;
13528
13529 uint device_processor_cores = device_param->device_processor_cores;
13530
13531 uint kernel_accel = device_param->kernel_accel;
13532
13533 cl_device_type device_type = device_param->device_type;
13534
13535 /**
13536 * create context for each device
13537 */
13538
13539 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13540
13541 /**
13542 * create command-queue
13543 */
13544
13545 // not supported with NV
13546 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13547
13548 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13549
13550 /**
13551 * create input buffers on device
13552 */
13553
13554 uint kernel_threads = KERNEL_THREADS;
13555
13556 // bcrypt
13557 if (hash_mode == 3200) kernel_threads = 8;
13558 if (hash_mode == 9000) kernel_threads = 8;
13559
13560 // we need to get rid of this
13561 if (device_type & CL_DEVICE_TYPE_CPU)
13562 {
13563 if (benchmark_mode == 0)
13564 {
13565 if (device_param->kernel_accel > 16)
13566 {
13567 device_param->kernel_accel = 16;
13568 }
13569 }
13570 else
13571 {
13572 if (device_param->kernel_accel > 64)
13573 {
13574 device_param->kernel_accel = 64;
13575 }
13576 }
13577 }
13578
13579 uint kernel_power = 1;
13580 uint kernel_blocks = 1;
13581
13582 uint size_pws = 4;
13583 uint size_tmps = 4;
13584 uint size_hooks = 4;
13585
13586 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13587
13588 while (kernel_accel)
13589 {
13590 kernel_power = device_processors * kernel_threads * kernel_accel;
13591 kernel_blocks = kernel_power;
13592
13593 // size_pws
13594
13595 size_pws = kernel_blocks * sizeof (pw_t);
13596
13597 // size_tmps
13598
13599 switch (hash_mode)
13600 {
13601 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13602 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13603 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13604 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13605 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13606 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13607 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13608 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13609 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13610 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13611 case 6211:
13612 case 6212:
13613 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13614 case 6221:
13615 case 6222:
13616 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13617 case 6231:
13618 case 6232:
13619 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13620 case 6241:
13621 case 6242:
13622 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13623 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13624 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13625 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13626 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13627 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13628 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13629 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13630 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13631 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13632 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13633 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13634 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13635 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13636 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13637 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13638 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13639 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13640 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13641 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13642 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13643 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13644 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13645 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13646 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13647 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13648 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13649 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13650 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13651 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13652 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13653 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13654 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13655 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13656 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13657 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13658 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13659 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13660 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13661 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13662 };
13663
13664 // size_hooks
13665
13666 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13667 {
13668 // none yet
13669 }
13670
13671 // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
13672 // if not, decrease amplifier and try again
13673
13674 if (size_pws > device_param->device_maxmem_alloc)
13675 {
13676 kernel_accel--;
13677
13678 continue;
13679 }
13680
13681 if (size_tmps > device_param->device_maxmem_alloc)
13682 {
13683 kernel_accel--;
13684
13685 continue;
13686 }
13687
13688 if (size_hooks > device_param->device_maxmem_alloc)
13689 {
13690 kernel_accel--;
13691
13692 continue;
13693 }
13694
13695 if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
13696 {
13697 kernel_accel--;
13698
13699 continue;
13700 }
13701
13702 break;
13703 }
13704
13705 if (kernel_accel == 0)
13706 {
13707 log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13708
13709 return -1;
13710 }
13711
13712 device_param->kernel_threads = kernel_threads;
13713 device_param->kernel_power_user = kernel_power;
13714 device_param->kernel_blocks_user = kernel_blocks;
13715
13716 kernel_blocks_all += kernel_blocks;
13717
13718 device_param->size_pws = size_pws;
13719 device_param->size_tmps = size_tmps;
13720 device_param->size_hooks = size_hooks;
13721
13722 // we can optimize some stuff here...
13723
13724 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13725 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13726
13727 device_param->size_root_css = size_root_css;
13728 device_param->size_markov_css = size_markov_css;
13729
13730 uint size_results = KERNEL_THREADS * sizeof (uint);
13731
13732 device_param->size_results = size_results;
13733
13734 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13735 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13736
13737 uint size_plains = digests_cnt * sizeof (plain_t);
13738 uint size_salts = salts_cnt * sizeof (salt_t);
13739 uint size_esalts = salts_cnt * esalt_size;
13740
13741 device_param->size_plains = size_plains;
13742 device_param->size_digests = size_digests;
13743 device_param->size_shown = size_shown;
13744 device_param->size_salts = size_salts;
13745
13746 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13747 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13748 uint size_tm = 32 * sizeof (bs_word_t);
13749
13750 // scrypt stuff
13751
13752 u64 size_scryptV = 1;
13753
13754 if ((hash_mode == 8900) || (hash_mode == 9300))
13755 {
13756 uint tmto_start = 0;
13757 uint tmto_stop = 10;
13758
13759 if (scrypt_tmto)
13760 {
13761 tmto_start = scrypt_tmto;
13762 }
13763 else
13764 {
13765 // in case the user did not specify the tmto manually
13766 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13767 // but set the lower end only in case the user has a device with too less memory
13768
13769 if (hash_mode == 8900)
13770 {
13771 if (device_param->vendor_id == VENDOR_ID_AMD)
13772 {
13773 tmto_start = 1;
13774 }
13775 else if (device_param->vendor_id == VENDOR_ID_NV)
13776 {
13777 tmto_start = 3;
13778 }
13779 }
13780 else if (hash_mode == 9300)
13781 {
13782 if (device_param->vendor_id == VENDOR_ID_AMD)
13783 {
13784 tmto_start = 3;
13785 }
13786 else if (device_param->vendor_id == VENDOR_ID_NV)
13787 {
13788 tmto_start = 5;
13789 }
13790 }
13791 }
13792
13793 if (quiet == 0) log_info ("");
13794
13795 uint shader_per_mp = 1;
13796
13797 if (device_param->vendor_id == VENDOR_ID_AMD)
13798 {
13799 shader_per_mp = 8;
13800 }
13801 else if (device_param->vendor_id == VENDOR_ID_NV)
13802 {
13803 shader_per_mp = 32;
13804 }
13805
13806 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13807 {
13808 // TODO: in theory the following calculation needs to be done per salt, not global
13809 // we assume all hashes have the same scrypt settings
13810
13811 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13812
13813 size_scryptV /= 1 << tmto;
13814
13815 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13816
13817 if (size_scryptV > device_param->device_maxmem_alloc)
13818 {
13819 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13820
13821 continue;
13822 }
13823
13824 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13825 {
13826 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13827 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13828 }
13829
13830 break;
13831 }
13832
13833 if (data.salts_buf[0].scrypt_phy == 0)
13834 {
13835 log_error ("ERROR: can't allocate enough device memory");
13836
13837 return -1;
13838 }
13839
13840 if (quiet == 0) log_info ("");
13841 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13842 }
13843
13844 /**
13845 * default building options
13846 */
13847
13848 char build_opts[1024] = { 0 };
13849
13850 // we don't have sm_* on vendors not NV but it doesn't matter
13851
13852 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);
13853
13854 /**
13855 * main kernel
13856 */
13857
13858 {
13859 /**
13860 * kernel source filename
13861 */
13862
13863 char source_file[256] = { 0 };
13864
13865 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13866
13867 struct stat sst;
13868
13869 if (stat (source_file, &sst) == -1)
13870 {
13871 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13872
13873 return -1;
13874 }
13875
13876 /**
13877 * kernel cached filename
13878 */
13879
13880 char cached_file[256] = { 0 };
13881
13882 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13883
13884 int cached = 1;
13885
13886 struct stat cst;
13887
13888 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13889 {
13890 cached = 0;
13891 }
13892
13893 /**
13894 * kernel compile or load
13895 */
13896
13897 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13898
13899 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13900
13901 if (force_jit_compilation == -1)
13902 {
13903 if (cached == 0)
13904 {
13905 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13906
13907 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13908
13909 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13910
13911 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13912
13913 if (rc != 0)
13914 {
13915 device_param->skipped = true;
13916 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13917 continue;
13918 }
13919
13920 size_t binary_size;
13921
13922 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13923
13924 u8 *binary = (u8 *) mymalloc (binary_size);
13925
13926 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13927
13928 writeProgramBin (cached_file, binary, binary_size);
13929
13930 local_free (binary);
13931 }
13932 else
13933 {
13934 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13935
13936 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13937
13938 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13939
13940 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13941 }
13942 }
13943 else
13944 {
13945 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13946
13947 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13948
13949 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13950
13951 char build_opts_update[1024] = { 0 };
13952
13953 if (force_jit_compilation == 1500)
13954 {
13955 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13956 }
13957 else if (force_jit_compilation == 8900)
13958 {
13959 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);
13960 }
13961
13962 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13963
13964 if (rc != 0)
13965 {
13966 device_param->skipped = true;
13967 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13968 }
13969 }
13970
13971 local_free (kernel_lengths);
13972 local_free (kernel_sources[0]);
13973 local_free (kernel_sources);
13974 }
13975
13976 /**
13977 * word generator kernel
13978 */
13979
13980 if (attack_mode != ATTACK_MODE_STRAIGHT)
13981 {
13982 /**
13983 * kernel mp source filename
13984 */
13985
13986 char source_file[256] = { 0 };
13987
13988 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13989
13990 struct stat sst;
13991
13992 if (stat (source_file, &sst) == -1)
13993 {
13994 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13995
13996 return -1;
13997 }
13998
13999 /**
14000 * kernel mp cached filename
14001 */
14002
14003 char cached_file[256] = { 0 };
14004
14005 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14006
14007 int cached = 1;
14008
14009 struct stat cst;
14010
14011 if (stat (cached_file, &cst) == -1)
14012 {
14013 cached = 0;
14014 }
14015
14016 /**
14017 * kernel compile or load
14018 */
14019
14020 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14021
14022 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14023
14024 if (cached == 0)
14025 {
14026 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14027
14028 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14029
14030 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14031
14032 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14033
14034 if (rc != 0)
14035 {
14036 device_param->skipped = true;
14037 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14038 continue;
14039 }
14040
14041 size_t binary_size;
14042
14043 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14044
14045 u8 *binary = (u8 *) mymalloc (binary_size);
14046
14047 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14048
14049 writeProgramBin (cached_file, binary, binary_size);
14050
14051 local_free (binary);
14052 }
14053 else
14054 {
14055 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14056
14057 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14058
14059 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14060
14061 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14062 }
14063
14064 local_free (kernel_lengths);
14065 local_free (kernel_sources[0]);
14066 local_free (kernel_sources);
14067 }
14068
14069 /**
14070 * amplifier kernel
14071 */
14072
14073 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14074 {
14075
14076 }
14077 else
14078 {
14079 /**
14080 * kernel amp source filename
14081 */
14082
14083 char source_file[256] = { 0 };
14084
14085 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14086
14087 struct stat sst;
14088
14089 if (stat (source_file, &sst) == -1)
14090 {
14091 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14092
14093 return -1;
14094 }
14095
14096 /**
14097 * kernel amp cached filename
14098 */
14099
14100 char cached_file[256] = { 0 };
14101
14102 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14103
14104 int cached = 1;
14105
14106 struct stat cst;
14107
14108 if (stat (cached_file, &cst) == -1)
14109 {
14110 cached = 0;
14111 }
14112
14113 /**
14114 * kernel compile or load
14115 */
14116
14117 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14118
14119 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14120
14121 if (cached == 0)
14122 {
14123 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14124
14125 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14126
14127 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14128
14129 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14130
14131 if (rc != 0)
14132 {
14133 device_param->skipped = true;
14134 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14135 continue;
14136 }
14137
14138 size_t binary_size;
14139
14140 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14141
14142 u8 *binary = (u8 *) mymalloc (binary_size);
14143
14144 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14145
14146 writeProgramBin (cached_file, binary, binary_size);
14147
14148 local_free (binary);
14149 }
14150 else
14151 {
14152 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14153
14154 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14155
14156 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14157
14158 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14159 }
14160
14161 local_free (kernel_lengths);
14162 local_free (kernel_sources[0]);
14163 local_free (kernel_sources);
14164 }
14165
14166 /**
14167 * global buffers
14168 */
14169
14170 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14171 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14172 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14173 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14174 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14175 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14176 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14177 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14178 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14179 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14180 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14181 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14182 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14183 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14184 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14185 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14186 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14187 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14188
14189 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);
14190 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);
14191 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);
14192 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);
14193 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);
14194 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);
14195 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);
14196 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);
14197 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14198 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14199 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14200
14201 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14202 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14203 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14204 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14205 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14206 run_kernel_bzero (device_param, device_param->d_result, size_results);
14207
14208 /**
14209 * special buffers
14210 */
14211
14212 if (attack_kern == ATTACK_KERN_STRAIGHT)
14213 {
14214 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14215 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14216
14217 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14218
14219 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14220 }
14221 else if (attack_kern == ATTACK_KERN_COMBI)
14222 {
14223 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14224 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14225 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14226 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14227
14228 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14229 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14230 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14231 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14232 }
14233 else if (attack_kern == ATTACK_KERN_BF)
14234 {
14235 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14236 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14237 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14238 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14239 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14240
14241 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14242 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14243 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14244 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14245 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14246 }
14247
14248 if (size_esalts)
14249 {
14250 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14251
14252 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14253 }
14254
14255 /**
14256 * main host data
14257 */
14258
14259 uint *result = (uint *) mymalloc (size_results);
14260
14261 device_param->result = result;
14262
14263 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14264
14265 device_param->pws_buf = pws_buf;
14266
14267 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14268
14269 for (int i = 0; i < 64; i++)
14270 {
14271 pw_caches[i].pw_buf.pw_len = i;
14272 pw_caches[i].cnt = 0;
14273 }
14274
14275 device_param->pw_caches = pw_caches;
14276
14277 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14278
14279 device_param->combs_buf = combs_buf;
14280
14281 void *hooks_buf = mymalloc (size_hooks);
14282
14283 device_param->hooks_buf = hooks_buf;
14284
14285 device_param->pw_transpose = pw_transpose_to_hi1;
14286 device_param->pw_add = pw_add_to_hc1;
14287
14288 /**
14289 * kernel args
14290 */
14291
14292 device_param->kernel_params_buf32[21] = bitmap_mask;
14293 device_param->kernel_params_buf32[22] = bitmap_shift1;
14294 device_param->kernel_params_buf32[23] = bitmap_shift2;
14295 device_param->kernel_params_buf32[24] = 0; // salt_pos
14296 device_param->kernel_params_buf32[25] = 0; // loop_pos
14297 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14298 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14299 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14300 device_param->kernel_params_buf32[29] = 0; // digests_offset
14301 device_param->kernel_params_buf32[30] = 0; // combs_mode
14302 device_param->kernel_params_buf32[31] = 0; // gid_max
14303
14304 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14305 ? &device_param->d_pws_buf
14306 : &device_param->d_pws_amp_buf;
14307 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14308 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14309 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14310 device_param->kernel_params[ 4] = &device_param->d_tmps;
14311 device_param->kernel_params[ 5] = &device_param->d_hooks;
14312 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14313 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14314 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14315 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14316 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14317 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14318 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14319 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14320 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14321 device_param->kernel_params[15] = &device_param->d_digests_buf;
14322 device_param->kernel_params[16] = &device_param->d_digests_shown;
14323 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14324 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14325 device_param->kernel_params[19] = &device_param->d_result;
14326 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14327 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14328 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14329 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14330 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14331 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14332 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14333 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14334 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14335 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14336 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14337 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14338
14339 device_param->kernel_params_mp_buf64[3] = 0;
14340 device_param->kernel_params_mp_buf32[4] = 0;
14341 device_param->kernel_params_mp_buf32[5] = 0;
14342 device_param->kernel_params_mp_buf32[6] = 0;
14343 device_param->kernel_params_mp_buf32[7] = 0;
14344 device_param->kernel_params_mp_buf32[8] = 0;
14345
14346 device_param->kernel_params_mp[0] = NULL;
14347 device_param->kernel_params_mp[1] = NULL;
14348 device_param->kernel_params_mp[2] = NULL;
14349 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14350 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14351 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14352 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14353 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14354 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14355
14356 device_param->kernel_params_mp_l_buf64[3] = 0;
14357 device_param->kernel_params_mp_l_buf32[4] = 0;
14358 device_param->kernel_params_mp_l_buf32[5] = 0;
14359 device_param->kernel_params_mp_l_buf32[6] = 0;
14360 device_param->kernel_params_mp_l_buf32[7] = 0;
14361 device_param->kernel_params_mp_l_buf32[8] = 0;
14362 device_param->kernel_params_mp_l_buf32[9] = 0;
14363
14364 device_param->kernel_params_mp_l[0] = NULL;
14365 device_param->kernel_params_mp_l[1] = NULL;
14366 device_param->kernel_params_mp_l[2] = NULL;
14367 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14368 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14369 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14370 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14371 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14372 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14373 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14374
14375 device_param->kernel_params_mp_r_buf64[3] = 0;
14376 device_param->kernel_params_mp_r_buf32[4] = 0;
14377 device_param->kernel_params_mp_r_buf32[5] = 0;
14378 device_param->kernel_params_mp_r_buf32[6] = 0;
14379 device_param->kernel_params_mp_r_buf32[7] = 0;
14380 device_param->kernel_params_mp_r_buf32[8] = 0;
14381
14382 device_param->kernel_params_mp_r[0] = NULL;
14383 device_param->kernel_params_mp_r[1] = NULL;
14384 device_param->kernel_params_mp_r[2] = NULL;
14385 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14386 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14387 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14388 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14389 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14390 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14391
14392 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14393 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14394
14395 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14396 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14397 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14398 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14399 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14400 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14401 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14402
14403 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14404
14405 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14406 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14407
14408 /**
14409 * kernel name
14410 */
14411
14412 char kernel_name[64] = { 0 };
14413
14414 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14415 {
14416 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14417 {
14418 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14419
14420 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14421
14422 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14423
14424 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14425
14426 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14427
14428 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14429 }
14430 else
14431 {
14432 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14433
14434 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14435
14436 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14437
14438 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14439
14440 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14441
14442 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14443 }
14444
14445 if (data.attack_mode == ATTACK_MODE_BF)
14446 {
14447 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14448 {
14449 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14450
14451 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14452
14453 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14454
14455 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14456 }
14457 }
14458 }
14459 else
14460 {
14461 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14462
14463 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14464
14465 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14466
14467 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14468
14469 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14470
14471 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14472
14473 if (opts_type & OPTS_TYPE_HOOK12)
14474 {
14475 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14476
14477 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14478 }
14479
14480 if (opts_type & OPTS_TYPE_HOOK23)
14481 {
14482 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14483
14484 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14485 }
14486 }
14487
14488 for (uint i = 0; i <= 20; i++)
14489 {
14490 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14491 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14492 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14493
14494 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14495 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14496 }
14497
14498 for (uint i = 21; i <= 31; i++)
14499 {
14500 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14501 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14502 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14503
14504 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14505 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14506 }
14507
14508 if (attack_mode == ATTACK_MODE_BF)
14509 {
14510 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14511 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14512
14513 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14514 {
14515 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14516
14517 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14518 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14519 }
14520 }
14521 else if (attack_mode == ATTACK_MODE_HYBRID1)
14522 {
14523 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14524 }
14525 else if (attack_mode == ATTACK_MODE_HYBRID2)
14526 {
14527 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14528 }
14529
14530 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14531 {
14532 // nothing to do
14533 }
14534 else
14535 {
14536 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14537 }
14538
14539 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14540 {
14541 // nothing to do
14542 }
14543 else
14544 {
14545 for (uint i = 0; i < 5; i++)
14546 {
14547 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14548 }
14549
14550 for (uint i = 5; i < 7; i++)
14551 {
14552 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14553 }
14554 }
14555
14556 /**
14557 * Store initial fanspeed if gpu_temp_retain is enabled
14558 */
14559
14560 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14561 int gpu_temp_retain_set = 0;
14562
14563 if (gpu_temp_disable == 0)
14564 {
14565 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14566 {
14567 hc_thread_mutex_lock (mux_adl);
14568
14569 if (data.hm_device[device_id].fan_supported == 1)
14570 {
14571 if (gpu_temp_retain_chgd == 0)
14572 {
14573 uint cur_temp = 0;
14574 uint default_temp = 0;
14575
14576 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);
14577
14578 if (ADL_rc == ADL_OK)
14579 {
14580 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14581
14582 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14583
14584 // special case with multi gpu setups: always use minimum retain
14585
14586 if (gpu_temp_retain_set == 0)
14587 {
14588 gpu_temp_retain = gpu_temp_retain_target;
14589 gpu_temp_retain_set = 1;
14590 }
14591 else
14592 {
14593 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14594 }
14595
14596 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14597 }
14598 }
14599
14600 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14601
14602 temp_retain_fanspeed_value[device_id] = fan_speed;
14603
14604 if (fan_speed == -1)
14605 {
14606 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14607
14608 temp_retain_fanspeed_value[device_id] = 0;
14609 }
14610 }
14611
14612 hc_thread_mutex_unlock (mux_adl);
14613 }
14614 }
14615
14616 /**
14617 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14618 */
14619
14620 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14621 {
14622 hc_thread_mutex_lock (mux_adl);
14623
14624 if (data.hm_device[device_id].od_version == 6)
14625 {
14626 int ADL_rc;
14627
14628 // check powertune capabilities first, if not available then skip device
14629
14630 int powertune_supported = 0;
14631
14632 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14633 {
14634 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14635
14636 return (-1);
14637 }
14638
14639 if (powertune_supported != 0)
14640 {
14641 // powercontrol settings
14642
14643 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14644
14645 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14646 {
14647 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14648 }
14649
14650 if (ADL_rc != ADL_OK)
14651 {
14652 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14653
14654 return (-1);
14655 }
14656
14657 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14658 {
14659 log_error ("ERROR: Failed to set new ADL PowerControl values");
14660
14661 return (-1);
14662 }
14663
14664 // clocks
14665
14666 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14667
14668 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14669
14670 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)
14671 {
14672 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14673
14674 return (-1);
14675 }
14676
14677 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14678
14679 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14680
14681 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14682 {
14683 log_error ("ERROR: Failed to get ADL device capabilities");
14684
14685 return (-1);
14686 }
14687
14688 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14689 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14690
14691 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14692 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14693
14694 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14695 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14696
14697 // warning if profile has too low max values
14698
14699 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14700 {
14701 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14702 }
14703
14704 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14705 {
14706 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14707 }
14708
14709 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14710
14711 performance_state->iNumberOfPerformanceLevels = 2;
14712
14713 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14714 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14715 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14716 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14717
14718 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)
14719 {
14720 log_info ("ERROR: Failed to set ADL performance state");
14721
14722 return (-1);
14723 }
14724
14725 local_free (performance_state);
14726 }
14727 }
14728
14729 hc_thread_mutex_unlock (mux_adl);
14730 }
14731 #endif // HAVE_HWMON && HAVE_ADL
14732 }
14733
14734 data.kernel_blocks_all = kernel_blocks_all;
14735
14736 if (data.quiet == 0) log_info ("");
14737
14738 /**
14739 * Inform user which algorithm is checked and at which workload setting
14740 */
14741
14742 if (benchmark == 1)
14743 {
14744 quiet = 0;
14745
14746 data.quiet = quiet;
14747
14748 char *hash_type = strhashtype (data.hash_mode); // not a bug
14749
14750 log_info ("Hashtype: %s", hash_type);
14751 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14752 log_info ("");
14753 }
14754
14755 /**
14756 * keep track of the progress
14757 */
14758
14759 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14760 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14761 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14762
14763 /**
14764 * open filehandles
14765 */
14766
14767 #if _WIN
14768 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14769 {
14770 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14771
14772 return (-1);
14773 }
14774
14775 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14776 {
14777 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14778
14779 return (-1);
14780 }
14781
14782 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14783 {
14784 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14785
14786 return (-1);
14787 }
14788 #endif
14789
14790 /**
14791 * dictionary pad
14792 */
14793
14794 segment_size *= (1024 * 1024);
14795
14796 data.segment_size = segment_size;
14797
14798 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14799
14800 wl_data->buf = (char *) mymalloc (segment_size);
14801 wl_data->avail = segment_size;
14802 wl_data->incr = segment_size;
14803 wl_data->cnt = 0;
14804 wl_data->pos = 0;
14805
14806 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14807
14808 data.wordlist_mode = wordlist_mode;
14809
14810 cs_t *css_buf = NULL;
14811 uint css_cnt = 0;
14812 uint dictcnt = 0;
14813 uint maskcnt = 1;
14814 char **masks = NULL;
14815 char **dictfiles = NULL;
14816
14817 uint mask_from_file = 0;
14818
14819 if (attack_mode == ATTACK_MODE_STRAIGHT)
14820 {
14821 if (wordlist_mode == WL_MODE_FILE)
14822 {
14823 int wls_left = myargc - (optind + 1);
14824
14825 for (int i = 0; i < wls_left; i++)
14826 {
14827 char *l0_filename = myargv[optind + 1 + i];
14828
14829 struct stat l0_stat;
14830
14831 if (stat (l0_filename, &l0_stat) == -1)
14832 {
14833 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14834
14835 return (-1);
14836 }
14837
14838 uint is_dir = S_ISDIR (l0_stat.st_mode);
14839
14840 if (is_dir == 0)
14841 {
14842 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14843
14844 dictcnt++;
14845
14846 dictfiles[dictcnt - 1] = l0_filename;
14847 }
14848 else
14849 {
14850 // do not allow --keyspace w/ a directory
14851
14852 if (keyspace == 1)
14853 {
14854 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14855
14856 return (-1);
14857 }
14858
14859 char **dictionary_files = NULL;
14860
14861 dictionary_files = scan_directory (l0_filename);
14862
14863 if (dictionary_files != NULL)
14864 {
14865 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14866
14867 for (int d = 0; dictionary_files[d] != NULL; d++)
14868 {
14869 char *l1_filename = dictionary_files[d];
14870
14871 struct stat l1_stat;
14872
14873 if (stat (l1_filename, &l1_stat) == -1)
14874 {
14875 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14876
14877 return (-1);
14878 }
14879
14880 if (S_ISREG (l1_stat.st_mode))
14881 {
14882 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14883
14884 dictcnt++;
14885
14886 dictfiles[dictcnt - 1] = strdup (l1_filename);
14887 }
14888 }
14889 }
14890
14891 local_free (dictionary_files);
14892 }
14893 }
14894
14895 if (dictcnt < 1)
14896 {
14897 log_error ("ERROR: No usable dictionary file found.");
14898
14899 return (-1);
14900 }
14901 }
14902 else if (wordlist_mode == WL_MODE_STDIN)
14903 {
14904 dictcnt = 1;
14905 }
14906 }
14907 else if (attack_mode == ATTACK_MODE_COMBI)
14908 {
14909 // display
14910
14911 char *dictfile1 = myargv[optind + 1 + 0];
14912 char *dictfile2 = myargv[optind + 1 + 1];
14913
14914 // find the bigger dictionary and use as base
14915
14916 FILE *fp1 = NULL;
14917 FILE *fp2 = NULL;
14918
14919 struct stat tmp_stat;
14920
14921 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14922 {
14923 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14924
14925 return (-1);
14926 }
14927
14928 if (stat (dictfile1, &tmp_stat) == -1)
14929 {
14930 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14931
14932 fclose (fp1);
14933
14934 return (-1);
14935 }
14936
14937 if (S_ISDIR (tmp_stat.st_mode))
14938 {
14939 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14940
14941 fclose (fp1);
14942
14943 return (-1);
14944 }
14945
14946 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14947 {
14948 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14949
14950 fclose (fp1);
14951
14952 return (-1);
14953 }
14954
14955 if (stat (dictfile2, &tmp_stat) == -1)
14956 {
14957 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14958
14959 fclose (fp1);
14960 fclose (fp2);
14961
14962 return (-1);
14963 }
14964
14965 if (S_ISDIR (tmp_stat.st_mode))
14966 {
14967 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14968
14969 fclose (fp1);
14970 fclose (fp2);
14971
14972 return (-1);
14973 }
14974
14975 data.combs_cnt = 1;
14976
14977 data.quiet = 1;
14978
14979 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14980
14981 data.quiet = quiet;
14982
14983 if (words1_cnt == 0)
14984 {
14985 log_error ("ERROR: %s: empty file", dictfile1);
14986
14987 fclose (fp1);
14988 fclose (fp2);
14989
14990 return (-1);
14991 }
14992
14993 data.combs_cnt = 1;
14994
14995 data.quiet = 1;
14996
14997 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14998
14999 data.quiet = quiet;
15000
15001 if (words2_cnt == 0)
15002 {
15003 log_error ("ERROR: %s: empty file", dictfile2);
15004
15005 fclose (fp1);
15006 fclose (fp2);
15007
15008 return (-1);
15009 }
15010
15011 fclose (fp1);
15012 fclose (fp2);
15013
15014 data.dictfile = dictfile1;
15015 data.dictfile2 = dictfile2;
15016
15017 if (words1_cnt >= words2_cnt)
15018 {
15019 data.combs_cnt = words2_cnt;
15020 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15021
15022 dictfiles = &data.dictfile;
15023
15024 dictcnt = 1;
15025 }
15026 else
15027 {
15028 data.combs_cnt = words1_cnt;
15029 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15030
15031 dictfiles = &data.dictfile2;
15032
15033 dictcnt = 1;
15034
15035 // we also have to switch wordlist related rules!
15036
15037 char *tmpc = data.rule_buf_l;
15038
15039 data.rule_buf_l = data.rule_buf_r;
15040 data.rule_buf_r = tmpc;
15041
15042 int tmpi = data.rule_len_l;
15043
15044 data.rule_len_l = data.rule_len_r;
15045 data.rule_len_r = tmpi;
15046 }
15047 }
15048 else if (attack_mode == ATTACK_MODE_BF)
15049 {
15050 char *mask = NULL;
15051
15052 maskcnt = 0;
15053
15054 if (benchmark == 0)
15055 {
15056 mask = myargv[optind + 1];
15057
15058 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15059
15060 if ((optind + 2) <= myargc)
15061 {
15062 struct stat file_stat;
15063
15064 if (stat (mask, &file_stat) == -1)
15065 {
15066 maskcnt = 1;
15067
15068 masks[maskcnt - 1] = mystrdup (mask);
15069 }
15070 else
15071 {
15072 int wls_left = myargc - (optind + 1);
15073
15074 uint masks_avail = INCR_MASKS;
15075
15076 for (int i = 0; i < wls_left; i++)
15077 {
15078 if (i != 0)
15079 {
15080 mask = myargv[optind + 1 + i];
15081
15082 if (stat (mask, &file_stat) == -1)
15083 {
15084 log_error ("ERROR: %s: %s", mask, strerror (errno));
15085
15086 return (-1);
15087 }
15088 }
15089
15090 uint is_file = S_ISREG (file_stat.st_mode);
15091
15092 if (is_file == 1)
15093 {
15094 FILE *mask_fp;
15095
15096 if ((mask_fp = fopen (mask, "r")) == NULL)
15097 {
15098 log_error ("ERROR: %s: %s", mask, strerror (errno));
15099
15100 return (-1);
15101 }
15102
15103 char line_buf[BUFSIZ] = { 0 };
15104
15105 while (!feof (mask_fp))
15106 {
15107 memset (line_buf, 0, BUFSIZ);
15108
15109 int line_len = fgetl (mask_fp, line_buf);
15110
15111 if (line_len == 0) continue;
15112
15113 if (line_buf[0] == '#') continue;
15114
15115 if (masks_avail == maskcnt)
15116 {
15117 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15118
15119 masks_avail += INCR_MASKS;
15120 }
15121
15122 masks[maskcnt] = mystrdup (line_buf);
15123
15124 maskcnt++;
15125 }
15126
15127 fclose (mask_fp);
15128 }
15129 else
15130 {
15131 log_error ("ERROR: %s: unsupported file-type", mask);
15132
15133 return (-1);
15134 }
15135 }
15136
15137 mask_from_file = 1;
15138 }
15139 }
15140 else
15141 {
15142 custom_charset_1 = (char *) "?l?d?u";
15143 custom_charset_2 = (char *) "?l?d";
15144 custom_charset_3 = (char *) "?l?d*!$@_";
15145
15146 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15147 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15148 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15149
15150 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15151
15152 wordlist_mode = WL_MODE_MASK;
15153
15154 data.wordlist_mode = wordlist_mode;
15155
15156 increment = 1;
15157
15158 maskcnt = 1;
15159 }
15160 }
15161 else
15162 {
15163 /**
15164 * generate full masks and charsets
15165 */
15166
15167 masks = (char **) mymalloc (sizeof (char *));
15168
15169 switch (hash_mode)
15170 {
15171 case 1731: pw_min = 5;
15172 pw_max = 5;
15173 mask = mystrdup ("?b?b?b?b?b");
15174 break;
15175 case 12500: pw_min = 5;
15176 pw_max = 5;
15177 mask = mystrdup ("?b?b?b?b?b");
15178 break;
15179 default: pw_min = 7;
15180 pw_max = 7;
15181 mask = mystrdup ("?b?b?b?b?b?b?b");
15182 break;
15183 }
15184
15185 maskcnt = 1;
15186
15187 masks[maskcnt - 1] = mystrdup (mask);
15188
15189 wordlist_mode = WL_MODE_MASK;
15190
15191 data.wordlist_mode = wordlist_mode;
15192
15193 increment = 1;
15194 }
15195
15196 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15197
15198 if (increment)
15199 {
15200 if (increment_min > pw_min) pw_min = increment_min;
15201
15202 if (increment_max < pw_max) pw_max = increment_max;
15203 }
15204 }
15205 else if (attack_mode == ATTACK_MODE_HYBRID1)
15206 {
15207 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15208
15209 // display
15210
15211 char *mask = myargv[myargc - 1];
15212
15213 maskcnt = 0;
15214
15215 masks = (char **) mymalloc (1 * sizeof (char *));
15216
15217 // mod
15218
15219 struct stat file_stat;
15220
15221 if (stat (mask, &file_stat) == -1)
15222 {
15223 maskcnt = 1;
15224
15225 masks[maskcnt - 1] = mystrdup (mask);
15226 }
15227 else
15228 {
15229 uint is_file = S_ISREG (file_stat.st_mode);
15230
15231 if (is_file == 1)
15232 {
15233 FILE *mask_fp;
15234
15235 if ((mask_fp = fopen (mask, "r")) == NULL)
15236 {
15237 log_error ("ERROR: %s: %s", mask, strerror (errno));
15238
15239 return (-1);
15240 }
15241
15242 char line_buf[BUFSIZ] = { 0 };
15243
15244 uint masks_avail = 1;
15245
15246 while (!feof (mask_fp))
15247 {
15248 memset (line_buf, 0, BUFSIZ);
15249
15250 int line_len = fgetl (mask_fp, line_buf);
15251
15252 if (line_len == 0) continue;
15253
15254 if (line_buf[0] == '#') continue;
15255
15256 if (masks_avail == maskcnt)
15257 {
15258 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15259
15260 masks_avail += INCR_MASKS;
15261 }
15262
15263 masks[maskcnt] = mystrdup (line_buf);
15264
15265 maskcnt++;
15266 }
15267
15268 fclose (mask_fp);
15269
15270 mask_from_file = 1;
15271 }
15272 else
15273 {
15274 maskcnt = 1;
15275
15276 masks[maskcnt - 1] = mystrdup (mask);
15277 }
15278 }
15279
15280 // base
15281
15282 int wls_left = myargc - (optind + 2);
15283
15284 for (int i = 0; i < wls_left; i++)
15285 {
15286 char *filename = myargv[optind + 1 + i];
15287
15288 struct stat file_stat;
15289
15290 if (stat (filename, &file_stat) == -1)
15291 {
15292 log_error ("ERROR: %s: %s", filename, strerror (errno));
15293
15294 return (-1);
15295 }
15296
15297 uint is_dir = S_ISDIR (file_stat.st_mode);
15298
15299 if (is_dir == 0)
15300 {
15301 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15302
15303 dictcnt++;
15304
15305 dictfiles[dictcnt - 1] = filename;
15306 }
15307 else
15308 {
15309 // do not allow --keyspace w/ a directory
15310
15311 if (keyspace == 1)
15312 {
15313 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15314
15315 return (-1);
15316 }
15317
15318 char **dictionary_files = NULL;
15319
15320 dictionary_files = scan_directory (filename);
15321
15322 if (dictionary_files != NULL)
15323 {
15324 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15325
15326 for (int d = 0; dictionary_files[d] != NULL; d++)
15327 {
15328 char *l1_filename = dictionary_files[d];
15329
15330 struct stat l1_stat;
15331
15332 if (stat (l1_filename, &l1_stat) == -1)
15333 {
15334 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15335
15336 return (-1);
15337 }
15338
15339 if (S_ISREG (l1_stat.st_mode))
15340 {
15341 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15342
15343 dictcnt++;
15344
15345 dictfiles[dictcnt - 1] = strdup (l1_filename);
15346 }
15347 }
15348 }
15349
15350 local_free (dictionary_files);
15351 }
15352 }
15353
15354 if (dictcnt < 1)
15355 {
15356 log_error ("ERROR: No usable dictionary file found.");
15357
15358 return (-1);
15359 }
15360
15361 if (increment)
15362 {
15363 maskcnt = 0;
15364
15365 uint mask_min = increment_min; // we can't reject smaller masks here
15366 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15367
15368 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15369 {
15370 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15371
15372 if (cur_mask == NULL) break;
15373
15374 masks[maskcnt] = cur_mask;
15375
15376 maskcnt++;
15377
15378 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15379 }
15380 }
15381 }
15382 else if (attack_mode == ATTACK_MODE_HYBRID2)
15383 {
15384 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15385
15386 // display
15387
15388 char *mask = myargv[optind + 1 + 0];
15389
15390 maskcnt = 0;
15391
15392 masks = (char **) mymalloc (1 * sizeof (char *));
15393
15394 // mod
15395
15396 struct stat file_stat;
15397
15398 if (stat (mask, &file_stat) == -1)
15399 {
15400 maskcnt = 1;
15401
15402 masks[maskcnt - 1] = mystrdup (mask);
15403 }
15404 else
15405 {
15406 uint is_file = S_ISREG (file_stat.st_mode);
15407
15408 if (is_file == 1)
15409 {
15410 FILE *mask_fp;
15411
15412 if ((mask_fp = fopen (mask, "r")) == NULL)
15413 {
15414 log_error ("ERROR: %s: %s", mask, strerror (errno));
15415
15416 return (-1);
15417 }
15418
15419 char line_buf[BUFSIZ] = { 0 };
15420
15421 uint masks_avail = 1;
15422
15423 while (!feof (mask_fp))
15424 {
15425 memset (line_buf, 0, BUFSIZ);
15426
15427 int line_len = fgetl (mask_fp, line_buf);
15428
15429 if (line_len == 0) continue;
15430
15431 if (line_buf[0] == '#') continue;
15432
15433 if (masks_avail == maskcnt)
15434 {
15435 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15436
15437 masks_avail += INCR_MASKS;
15438 }
15439
15440 masks[maskcnt] = mystrdup (line_buf);
15441
15442 maskcnt++;
15443 }
15444
15445 fclose (mask_fp);
15446
15447 mask_from_file = 1;
15448 }
15449 else
15450 {
15451 maskcnt = 1;
15452
15453 masks[maskcnt - 1] = mystrdup (mask);
15454 }
15455 }
15456
15457 // base
15458
15459 int wls_left = myargc - (optind + 2);
15460
15461 for (int i = 0; i < wls_left; i++)
15462 {
15463 char *filename = myargv[optind + 2 + i];
15464
15465 struct stat file_stat;
15466
15467 if (stat (filename, &file_stat) == -1)
15468 {
15469 log_error ("ERROR: %s: %s", filename, strerror (errno));
15470
15471 return (-1);
15472 }
15473
15474 uint is_dir = S_ISDIR (file_stat.st_mode);
15475
15476 if (is_dir == 0)
15477 {
15478 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15479
15480 dictcnt++;
15481
15482 dictfiles[dictcnt - 1] = filename;
15483 }
15484 else
15485 {
15486 // do not allow --keyspace w/ a directory
15487
15488 if (keyspace == 1)
15489 {
15490 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15491
15492 return (-1);
15493 }
15494
15495 char **dictionary_files = NULL;
15496
15497 dictionary_files = scan_directory (filename);
15498
15499 if (dictionary_files != NULL)
15500 {
15501 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15502
15503 for (int d = 0; dictionary_files[d] != NULL; d++)
15504 {
15505 char *l1_filename = dictionary_files[d];
15506
15507 struct stat l1_stat;
15508
15509 if (stat (l1_filename, &l1_stat) == -1)
15510 {
15511 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15512
15513 return (-1);
15514 }
15515
15516 if (S_ISREG (l1_stat.st_mode))
15517 {
15518 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15519
15520 dictcnt++;
15521
15522 dictfiles[dictcnt - 1] = strdup (l1_filename);
15523 }
15524 }
15525 }
15526
15527 local_free (dictionary_files);
15528 }
15529 }
15530
15531 if (dictcnt < 1)
15532 {
15533 log_error ("ERROR: No usable dictionary file found.");
15534
15535 return (-1);
15536 }
15537
15538 if (increment)
15539 {
15540 maskcnt = 0;
15541
15542 uint mask_min = increment_min; // we can't reject smaller masks here
15543 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15544
15545 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15546 {
15547 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15548
15549 if (cur_mask == NULL) break;
15550
15551 masks[maskcnt] = cur_mask;
15552
15553 maskcnt++;
15554
15555 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15556 }
15557 }
15558 }
15559
15560 data.pw_min = pw_min;
15561 data.pw_max = pw_max;
15562
15563 /**
15564 * weak hash check
15565 */
15566
15567 if (weak_hash_threshold >= salts_cnt)
15568 {
15569 hc_device_param_t *device_param = NULL;
15570
15571 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15572 {
15573 device_param = &data.devices_param[device_id];
15574
15575 if (device_param->skipped) continue;
15576
15577 break;
15578 }
15579
15580 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15581
15582 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15583 {
15584 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15585 }
15586 }
15587
15588 // Display hack, guarantee that there is at least one \r before real start
15589
15590 if (data.quiet == 0) log_info_nn ("");
15591
15592 /**
15593 * status and monitor threads
15594 */
15595
15596 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15597
15598 hc_thread_t i_thread = 0;
15599
15600 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15601 {
15602 hc_thread_create (i_thread, thread_keypress, &benchmark);
15603 }
15604
15605 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15606
15607 uint ni_threads_cnt = 0;
15608
15609 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15610
15611 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15612
15613 ni_threads_cnt++;
15614
15615 /**
15616 * Outfile remove
15617 */
15618
15619 if (keyspace == 0)
15620 {
15621 if (outfile_check_timer != 0)
15622 {
15623 if (data.outfile_check_directory != NULL)
15624 {
15625 if ((hash_mode != 5200) &&
15626 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15627 (hash_mode != 9000))
15628 {
15629 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15630
15631 ni_threads_cnt++;
15632 }
15633 else
15634 {
15635 outfile_check_timer = 0;
15636 }
15637 }
15638 else
15639 {
15640 outfile_check_timer = 0;
15641 }
15642 }
15643 }
15644
15645 /**
15646 * Inform the user if we got some hashes remove because of the pot file remove feature
15647 */
15648
15649 if (data.quiet == 0)
15650 {
15651 if (potfile_remove_cracks > 0)
15652 {
15653 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15654 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15655 }
15656 }
15657
15658 data.outfile_check_timer = outfile_check_timer;
15659
15660 /**
15661 * main loop
15662 */
15663
15664 char **induction_dictionaries = NULL;
15665
15666 int induction_dictionaries_cnt = 0;
15667
15668 hcstat_table_t *root_table_buf = NULL;
15669 hcstat_table_t *markov_table_buf = NULL;
15670
15671 uint initial_restore_done = 0;
15672
15673 data.maskcnt = maskcnt;
15674
15675 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15676 {
15677 if (data.devices_status == STATUS_CRACKED) break;
15678
15679 data.devices_status = STATUS_INIT;
15680
15681 if (maskpos > rd->maskpos)
15682 {
15683 rd->dictpos = 0;
15684 }
15685
15686 rd->maskpos = maskpos;
15687 data.maskpos = maskpos;
15688
15689 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15690 {
15691 char *mask = masks[maskpos];
15692
15693 if (mask_from_file == 1)
15694 {
15695 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15696
15697 char *str_ptr;
15698 uint str_pos;
15699
15700 uint mask_offset = 0;
15701
15702 uint separator_cnt;
15703
15704 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15705 {
15706 str_ptr = strstr (mask + mask_offset, ",");
15707
15708 if (str_ptr == NULL) break;
15709
15710 str_pos = str_ptr - mask;
15711
15712 // escaped separator, i.e. "\,"
15713
15714 if (str_pos > 0)
15715 {
15716 if (mask[str_pos - 1] == '\\')
15717 {
15718 separator_cnt --;
15719
15720 mask_offset = str_pos + 1;
15721
15722 continue;
15723 }
15724 }
15725
15726 // reset the offset
15727
15728 mask_offset = 0;
15729
15730 mask[str_pos] = '\0';
15731
15732 switch (separator_cnt)
15733 {
15734 case 0:
15735 mp_reset_usr (mp_usr, 0);
15736
15737 custom_charset_1 = mask;
15738 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15739 break;
15740
15741 case 1:
15742 mp_reset_usr (mp_usr, 1);
15743
15744 custom_charset_2 = mask;
15745 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15746 break;
15747
15748 case 2:
15749 mp_reset_usr (mp_usr, 2);
15750
15751 custom_charset_3 = mask;
15752 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15753 break;
15754
15755 case 3:
15756 mp_reset_usr (mp_usr, 3);
15757
15758 custom_charset_4 = mask;
15759 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15760 break;
15761 }
15762
15763 mask = mask + str_pos + 1;
15764 }
15765 }
15766
15767 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15768 {
15769 if (maskpos > 0)
15770 {
15771 local_free (css_buf);
15772 local_free (data.root_css_buf);
15773 local_free (data.markov_css_buf);
15774
15775 local_free (masks[maskpos - 1]);
15776 }
15777
15778 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15779
15780 data.mask = mask;
15781 data.css_cnt = css_cnt;
15782 data.css_buf = css_buf;
15783
15784 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15785
15786 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15787
15788 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15789 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15790
15791 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15792
15793 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15794
15795 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15796 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15797
15798 data.root_css_buf = root_css_buf;
15799 data.markov_css_buf = markov_css_buf;
15800
15801 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15802
15803 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15804
15805 local_free (root_table_buf);
15806 local_free (markov_table_buf);
15807
15808 // args
15809
15810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15811 {
15812 hc_device_param_t *device_param = &data.devices_param[device_id];
15813
15814 if (device_param->skipped) continue;
15815
15816 device_param->kernel_params_mp[0] = &device_param->d_combs;
15817 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15818 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15819
15820 device_param->kernel_params_mp_buf64[3] = 0;
15821 device_param->kernel_params_mp_buf32[4] = css_cnt;
15822 device_param->kernel_params_mp_buf32[5] = 0;
15823 device_param->kernel_params_mp_buf32[6] = 0;
15824 device_param->kernel_params_mp_buf32[7] = 0;
15825
15826 if (attack_mode == ATTACK_MODE_HYBRID1)
15827 {
15828 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15829 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15830 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15831 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15832 }
15833 else if (attack_mode == ATTACK_MODE_HYBRID2)
15834 {
15835 device_param->kernel_params_mp_buf32[5] = 0;
15836 device_param->kernel_params_mp_buf32[6] = 0;
15837 device_param->kernel_params_mp_buf32[7] = 0;
15838 }
15839
15840 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]);
15841 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]);
15842 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]);
15843
15844 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);
15845 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);
15846 }
15847 }
15848 else if (attack_mode == ATTACK_MODE_BF)
15849 {
15850 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15851
15852 if (increment)
15853 {
15854 for (uint i = 0; i < dictcnt; i++)
15855 {
15856 local_free (dictfiles[i]);
15857 }
15858
15859 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15860 {
15861 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15862
15863 if (l1_filename == NULL) break;
15864
15865 dictcnt++;
15866
15867 dictfiles[dictcnt - 1] = l1_filename;
15868 }
15869 }
15870 else
15871 {
15872 dictcnt++;
15873
15874 dictfiles[dictcnt - 1] = mask;
15875 }
15876
15877 if (dictcnt == 0)
15878 {
15879 log_error ("ERROR: Mask is too small");
15880
15881 return (-1);
15882 }
15883 }
15884 }
15885
15886 free (induction_dictionaries);
15887
15888 // induction_dictionaries_cnt = 0; // implied
15889
15890 if (attack_mode != ATTACK_MODE_BF)
15891 {
15892 if (keyspace == 0)
15893 {
15894 induction_dictionaries = scan_directory (induction_directory);
15895
15896 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15897 }
15898 }
15899
15900 if (induction_dictionaries_cnt)
15901 {
15902 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15903 }
15904
15905 /**
15906 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15907 */
15908 if (keyspace == 1)
15909 {
15910 if ((maskcnt > 1) || (dictcnt > 1))
15911 {
15912 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15913
15914 return (-1);
15915 }
15916 }
15917
15918 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15919 {
15920 char *subid = logfile_generate_subid ();
15921
15922 data.subid = subid;
15923
15924 logfile_sub_msg ("START");
15925
15926 data.devices_status = STATUS_INIT;
15927
15928 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15929 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15930 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15931
15932 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15933
15934 data.cpt_pos = 0;
15935
15936 data.cpt_start = time (NULL);
15937
15938 data.cpt_total = 0;
15939
15940 if (data.restore == 0)
15941 {
15942 rd->words_cur = skip;
15943
15944 skip = 0;
15945
15946 data.skip = 0;
15947 }
15948
15949 data.ms_paused = 0;
15950
15951 data.words_cur = rd->words_cur;
15952
15953 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15954 {
15955 hc_device_param_t *device_param = &data.devices_param[device_id];
15956
15957 if (device_param->skipped) continue;
15958
15959 device_param->speed_pos = 0;
15960
15961 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15962 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15963 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15964
15965 device_param->kernel_power = device_param->kernel_power_user;
15966 device_param->kernel_blocks = device_param->kernel_blocks_user;
15967
15968 device_param->outerloop_pos = 0;
15969 device_param->outerloop_left = 0;
15970 device_param->innerloop_pos = 0;
15971 device_param->innerloop_left = 0;
15972
15973 // some more resets:
15974
15975 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15976
15977 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15978
15979 device_param->pw_cnt = 0;
15980 device_param->pws_cnt = 0;
15981
15982 device_param->words_off = 0;
15983 device_param->words_done = 0;
15984 }
15985
15986 data.kernel_blocks_div = 0;
15987
15988 // figure out some workload
15989
15990 if (attack_mode == ATTACK_MODE_STRAIGHT)
15991 {
15992 if (data.wordlist_mode == WL_MODE_FILE)
15993 {
15994 char *dictfile = NULL;
15995
15996 if (induction_dictionaries_cnt)
15997 {
15998 dictfile = induction_dictionaries[0];
15999 }
16000 else
16001 {
16002 dictfile = dictfiles[dictpos];
16003 }
16004
16005 data.dictfile = dictfile;
16006
16007 logfile_sub_string (dictfile);
16008
16009 for (uint i = 0; i < rp_files_cnt; i++)
16010 {
16011 logfile_sub_var_string ("rulefile", rp_files[i]);
16012 }
16013
16014 FILE *fd2 = fopen (dictfile, "rb");
16015
16016 if (fd2 == NULL)
16017 {
16018 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16019
16020 return (-1);
16021 }
16022
16023 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16024
16025 fclose (fd2);
16026
16027 if (data.words_cnt == 0)
16028 {
16029 if (data.devices_status == STATUS_CRACKED) break;
16030 if (data.devices_status == STATUS_ABORTED) break;
16031
16032 dictpos++;
16033
16034 continue;
16035 }
16036 }
16037 }
16038 else if (attack_mode == ATTACK_MODE_COMBI)
16039 {
16040 char *dictfile = data.dictfile;
16041 char *dictfile2 = data.dictfile2;
16042
16043 logfile_sub_string (dictfile);
16044 logfile_sub_string (dictfile2);
16045
16046 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16047 {
16048 FILE *fd2 = fopen (dictfile, "rb");
16049
16050 if (fd2 == NULL)
16051 {
16052 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16053
16054 return (-1);
16055 }
16056
16057 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16058
16059 fclose (fd2);
16060 }
16061 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16062 {
16063 FILE *fd2 = fopen (dictfile2, "rb");
16064
16065 if (fd2 == NULL)
16066 {
16067 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16068
16069 return (-1);
16070 }
16071
16072 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16073
16074 fclose (fd2);
16075 }
16076
16077 if (data.words_cnt == 0)
16078 {
16079 if (data.devices_status == STATUS_CRACKED) break;
16080 if (data.devices_status == STATUS_ABORTED) break;
16081
16082 dictpos++;
16083
16084 continue;
16085 }
16086 }
16087 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16088 {
16089 char *dictfile = NULL;
16090
16091 if (induction_dictionaries_cnt)
16092 {
16093 dictfile = induction_dictionaries[0];
16094 }
16095 else
16096 {
16097 dictfile = dictfiles[dictpos];
16098 }
16099
16100 data.dictfile = dictfile;
16101
16102 char *mask = data.mask;
16103
16104 logfile_sub_string (dictfile);
16105 logfile_sub_string (mask);
16106
16107 FILE *fd2 = fopen (dictfile, "rb");
16108
16109 if (fd2 == NULL)
16110 {
16111 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16112
16113 return (-1);
16114 }
16115
16116 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16117
16118 fclose (fd2);
16119
16120 if (data.words_cnt == 0)
16121 {
16122 if (data.devices_status == STATUS_CRACKED) break;
16123 if (data.devices_status == STATUS_ABORTED) break;
16124
16125 dictpos++;
16126
16127 continue;
16128 }
16129 }
16130 else if (attack_mode == ATTACK_MODE_BF)
16131 {
16132 local_free (css_buf);
16133 local_free (data.root_css_buf);
16134 local_free (data.markov_css_buf);
16135
16136 char *mask = dictfiles[dictpos];
16137
16138 logfile_sub_string (mask);
16139
16140 // base
16141
16142 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16143
16144 if (opts_type & OPTS_TYPE_PT_UNICODE)
16145 {
16146 uint css_cnt_unicode = css_cnt * 2;
16147
16148 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16149
16150 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16151 {
16152 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16153
16154 css_buf_unicode[j + 1].cs_buf[0] = 0;
16155 css_buf_unicode[j + 1].cs_len = 1;
16156 }
16157
16158 free (css_buf);
16159
16160 css_buf = css_buf_unicode;
16161 css_cnt = css_cnt_unicode;
16162 }
16163
16164 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16165
16166 uint mask_min = pw_min;
16167 uint mask_max = pw_max;
16168
16169 if (opts_type & OPTS_TYPE_PT_UNICODE)
16170 {
16171 mask_min *= 2;
16172 mask_max *= 2;
16173 }
16174
16175 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16176 {
16177 if (css_cnt < mask_min)
16178 {
16179 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16180 }
16181
16182 if (css_cnt > mask_max)
16183 {
16184 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16185 }
16186
16187 // skip to next mask
16188
16189 dictpos++;
16190
16191 rd->dictpos = dictpos;
16192
16193 logfile_sub_msg ("STOP");
16194
16195 continue;
16196 }
16197
16198 uint save_css_cnt = css_cnt;
16199
16200 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16201 {
16202 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16203 {
16204 uint salt_len = (uint) data.salts_buf[0].salt_len;
16205 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16206
16207 uint css_cnt_salt = css_cnt + salt_len;
16208
16209 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16210
16211 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16212
16213 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16214 {
16215 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16216 css_buf_salt[j].cs_len = 1;
16217 }
16218
16219 free (css_buf);
16220
16221 css_buf = css_buf_salt;
16222 css_cnt = css_cnt_salt;
16223 }
16224 }
16225
16226 data.mask = mask;
16227 data.css_cnt = css_cnt;
16228 data.css_buf = css_buf;
16229
16230 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16231
16232 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16233
16234 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16235
16236 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16237 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16238
16239 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16240
16241 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16242
16243 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16244 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16245
16246 data.root_css_buf = root_css_buf;
16247 data.markov_css_buf = markov_css_buf;
16248
16249 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16250
16251 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16252
16253 local_free (root_table_buf);
16254 local_free (markov_table_buf);
16255
16256 // copy + args
16257
16258 uint css_cnt_l = css_cnt;
16259 uint css_cnt_r;
16260
16261 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16262 {
16263 if (save_css_cnt < 6)
16264 {
16265 css_cnt_r = 1;
16266 }
16267 else if (save_css_cnt == 6)
16268 {
16269 css_cnt_r = 2;
16270 }
16271 else
16272 {
16273 if (opts_type & OPTS_TYPE_PT_UNICODE)
16274 {
16275 if (save_css_cnt == 8 || save_css_cnt == 10)
16276 {
16277 css_cnt_r = 2;
16278 }
16279 else
16280 {
16281 css_cnt_r = 4;
16282 }
16283 }
16284 else
16285 {
16286 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16287 {
16288 css_cnt_r = 3;
16289 }
16290 else
16291 {
16292 css_cnt_r = 4;
16293 }
16294 }
16295 }
16296 }
16297 else
16298 {
16299 css_cnt_r = 1;
16300
16301 /* unfinished code?
16302 int sum = css_buf[css_cnt_r - 1].cs_len;
16303
16304 for (uint i = 1; i < 4 && i < css_cnt; i++)
16305 {
16306 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16307
16308 css_cnt_r++;
16309
16310 sum *= css_buf[css_cnt_r - 1].cs_len;
16311 }
16312 */
16313 }
16314
16315 css_cnt_l -= css_cnt_r;
16316
16317 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16318
16319 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16320 {
16321 hc_device_param_t *device_param = &data.devices_param[device_id];
16322
16323 if (device_param->skipped) continue;
16324
16325 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16326 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16327 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16328
16329 device_param->kernel_params_mp_l_buf64[3] = 0;
16330 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16331 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16332 device_param->kernel_params_mp_l_buf32[6] = 0;
16333 device_param->kernel_params_mp_l_buf32[7] = 0;
16334 device_param->kernel_params_mp_l_buf32[8] = 0;
16335
16336 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16337 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16338 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16339 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16340
16341 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16342 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16343 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16344
16345 device_param->kernel_params_mp_r_buf64[3] = 0;
16346 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16347 device_param->kernel_params_mp_r_buf32[5] = 0;
16348 device_param->kernel_params_mp_r_buf32[6] = 0;
16349 device_param->kernel_params_mp_r_buf32[7] = 0;
16350
16351 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]);
16352 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]);
16353 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]);
16354
16355 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]);
16356 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]);
16357 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]);
16358
16359 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);
16360 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);
16361 }
16362 }
16363
16364 u64 words_base = data.words_cnt;
16365
16366 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16367 {
16368 if (data.kernel_rules_cnt)
16369 {
16370 words_base /= data.kernel_rules_cnt;
16371 }
16372 }
16373 else if (data.attack_kern == ATTACK_KERN_COMBI)
16374 {
16375 if (data.combs_cnt)
16376 {
16377 words_base /= data.combs_cnt;
16378 }
16379 }
16380 else if (data.attack_kern == ATTACK_KERN_BF)
16381 {
16382 if (data.bfs_cnt)
16383 {
16384 words_base /= data.bfs_cnt;
16385 }
16386 }
16387
16388 data.words_base = words_base;
16389
16390 if (keyspace == 1)
16391 {
16392 log_info ("%llu", (unsigned long long int) words_base);
16393
16394 return (0);
16395 }
16396
16397 if (data.words_cur > data.words_base)
16398 {
16399 log_error ("ERROR: restore value greater keyspace");
16400
16401 return (-1);
16402 }
16403
16404 if (data.words_cur)
16405 {
16406 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16407 {
16408 for (uint i = 0; i < data.salts_cnt; i++)
16409 {
16410 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16411 }
16412 }
16413 else if (data.attack_kern == ATTACK_KERN_COMBI)
16414 {
16415 for (uint i = 0; i < data.salts_cnt; i++)
16416 {
16417 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16418 }
16419 }
16420 else if (data.attack_kern == ATTACK_KERN_BF)
16421 {
16422 for (uint i = 0; i < data.salts_cnt; i++)
16423 {
16424 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16425 }
16426 }
16427 }
16428
16429 /*
16430 * Inform user about possible slow speeds
16431 */
16432
16433 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16434 {
16435 if (data.words_base < kernel_blocks_all)
16436 {
16437 if (quiet == 0)
16438 {
16439 log_info ("");
16440 log_info ("ATTENTION!");
16441 log_info (" The wordlist or mask you are using is too small.");
16442 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16443 log_info (" The cracking speed will drop.");
16444 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16445 log_info ("");
16446 }
16447 }
16448 }
16449
16450 /*
16451 * Update loopback file
16452 */
16453
16454 if (loopback == 1)
16455 {
16456 time_t now;
16457
16458 time (&now);
16459
16460 uint random_num = get_random_num (0, 9999);
16461
16462 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16463
16464 data.loopback_file = loopback_file;
16465 }
16466
16467 /*
16468 * Update dictionary statistic
16469 */
16470
16471 if (keyspace == 0)
16472 {
16473 dictstat_fp = fopen (dictstat, "wb");
16474
16475 if (dictstat_fp)
16476 {
16477 lock_file (dictstat_fp);
16478
16479 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16480
16481 fclose (dictstat_fp);
16482 }
16483 }
16484
16485 data.devices_status = STATUS_RUNNING;
16486
16487 if (initial_restore_done == 0)
16488 {
16489 if (data.restore_disable == 0) cycle_restore ();
16490
16491 initial_restore_done = 1;
16492 }
16493
16494 hc_timer_set (&data.timer_running);
16495
16496 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16497 {
16498 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16499 {
16500 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16501 if (quiet == 0) fflush (stdout);
16502 }
16503 }
16504 else if (wordlist_mode == WL_MODE_STDIN)
16505 {
16506 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16507 if (data.quiet == 0) log_info ("");
16508 }
16509
16510 time_t runtime_start;
16511
16512 time (&runtime_start);
16513
16514 data.runtime_start = runtime_start;
16515
16516 /**
16517 * create cracker threads
16518 */
16519
16520 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16521
16522 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16523 {
16524 hc_device_param_t *device_param = &devices_param[device_id];
16525
16526 if (wordlist_mode == WL_MODE_STDIN)
16527 {
16528 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16529 }
16530 else
16531 {
16532 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16533 }
16534 }
16535
16536 // wait for crack threads to exit
16537
16538 hc_thread_wait (data.devices_cnt, c_threads);
16539
16540 local_free (c_threads);
16541
16542 data.restore = 0;
16543
16544 // finalize task
16545
16546 logfile_sub_var_uint ("status-after-work", data.devices_status);
16547
16548 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16549
16550 if (data.devices_status == STATUS_CRACKED) break;
16551 if (data.devices_status == STATUS_ABORTED) break;
16552
16553 if (data.devices_status == STATUS_BYPASS)
16554 {
16555 data.devices_status = STATUS_RUNNING;
16556 }
16557
16558 if (induction_dictionaries_cnt)
16559 {
16560 unlink (induction_dictionaries[0]);
16561 }
16562
16563 free (induction_dictionaries);
16564
16565 if (attack_mode != ATTACK_MODE_BF)
16566 {
16567 induction_dictionaries = scan_directory (induction_directory);
16568
16569 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16570 }
16571
16572 if (benchmark == 0)
16573 {
16574 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16575 {
16576 if (quiet == 0) clear_prompt ();
16577
16578 if (quiet == 0) log_info ("");
16579
16580 if (status == 1)
16581 {
16582 status_display ();
16583 }
16584 else
16585 {
16586 if (quiet == 0) status_display ();
16587 }
16588
16589 if (quiet == 0) log_info ("");
16590 }
16591 }
16592
16593 if (attack_mode == ATTACK_MODE_BF)
16594 {
16595 dictpos++;
16596
16597 rd->dictpos = dictpos;
16598 }
16599 else
16600 {
16601 if (induction_dictionaries_cnt)
16602 {
16603 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16604 }
16605 else
16606 {
16607 dictpos++;
16608
16609 rd->dictpos = dictpos;
16610 }
16611 }
16612
16613 time_t runtime_stop;
16614
16615 time (&runtime_stop);
16616
16617 data.runtime_stop = runtime_stop;
16618
16619 logfile_sub_uint (runtime_start);
16620 logfile_sub_uint (runtime_stop);
16621
16622 logfile_sub_msg ("STOP");
16623
16624 global_free (subid);
16625 }
16626
16627 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16628
16629 if (data.devices_status == STATUS_CRACKED) break;
16630 if (data.devices_status == STATUS_ABORTED) break;
16631 if (data.devices_status == STATUS_QUIT) break;
16632
16633 if (data.devices_status == STATUS_BYPASS)
16634 {
16635 data.devices_status = STATUS_RUNNING;
16636 }
16637 }
16638
16639 // 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
16640
16641 if (attack_mode == ATTACK_MODE_STRAIGHT)
16642 {
16643 if (data.wordlist_mode == WL_MODE_FILE)
16644 {
16645 if (data.dictfile == NULL)
16646 {
16647 if (dictfiles != NULL)
16648 {
16649 data.dictfile = dictfiles[0];
16650
16651 hc_timer_set (&data.timer_running);
16652 }
16653 }
16654 }
16655 }
16656 // NOTE: combi is okay because it is already set beforehand
16657 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16658 {
16659 if (data.dictfile == NULL)
16660 {
16661 if (dictfiles != NULL)
16662 {
16663 hc_timer_set (&data.timer_running);
16664
16665 data.dictfile = dictfiles[0];
16666 }
16667 }
16668 }
16669 else if (attack_mode == ATTACK_MODE_BF)
16670 {
16671 if (data.mask == NULL)
16672 {
16673 hc_timer_set (&data.timer_running);
16674
16675 data.mask = masks[0];
16676 }
16677 }
16678
16679 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16680 {
16681 data.devices_status = STATUS_EXHAUSTED;
16682 }
16683
16684 // if cracked / aborted remove last induction dictionary
16685
16686 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16687 {
16688 struct stat induct_stat;
16689
16690 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16691 {
16692 unlink (induction_dictionaries[file_pos]);
16693 }
16694 }
16695
16696 // wait for non-interactive threads
16697
16698 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16699 {
16700 hc_thread_wait (1, &ni_threads[thread_idx]);
16701 }
16702
16703 local_free (ni_threads);
16704
16705 // wait for interactive threads
16706
16707 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16708 {
16709 hc_thread_wait (1, &i_thread);
16710 }
16711
16712 // we dont need restore file anymore
16713 if (data.restore_disable == 0)
16714 {
16715 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16716 {
16717 unlink (eff_restore_file);
16718 unlink (new_restore_file);
16719 }
16720 else
16721 {
16722 cycle_restore ();
16723 }
16724 }
16725
16726 // finally save left hashes
16727
16728 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16729 {
16730 save_hash ();
16731 }
16732
16733 /**
16734 * Clean up
16735 */
16736
16737 if (benchmark == 1)
16738 {
16739 status_benchmark ();
16740
16741 log_info ("");
16742 }
16743 else
16744 {
16745 if (quiet == 0) clear_prompt ();
16746
16747 if (quiet == 0) log_info ("");
16748
16749 if (status == 1)
16750 {
16751 status_display ();
16752 }
16753 else
16754 {
16755 if (quiet == 0) status_display ();
16756 }
16757
16758 if (quiet == 0) log_info ("");
16759 }
16760
16761 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16762 {
16763 hc_device_param_t *device_param = &data.devices_param[device_id];
16764
16765 if (device_param->skipped) continue;
16766
16767 local_free (device_param->result);
16768
16769 local_free (device_param->pw_caches);
16770
16771 local_free (device_param->combs_buf);
16772
16773 local_free (device_param->hooks_buf);
16774
16775 local_free (device_param->device_name);
16776
16777 local_free (device_param->device_name_chksum);
16778
16779 local_free (device_param->device_version);
16780
16781 local_free (device_param->driver_version);
16782
16783 if (device_param->pws_buf) myfree (device_param->pws_buf);
16784 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16785 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16786 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16787 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16788 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16789 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16790 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16791 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16792 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16793 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16794 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16795 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16796 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16797 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16798 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16799 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16800 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16801 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16802 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16803 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16804 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16805 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16806 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16807 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16808 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16809 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16810 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16811 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16812
16813 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16814 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16815 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16816 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16817 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16818 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16819 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16820 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16821 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16822 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16823 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16824
16825 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16826 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16827 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16828
16829 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16830 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16831 }
16832
16833 // reset default fan speed
16834
16835 #ifdef HAVE_HWMON
16836 if (gpu_temp_disable == 0)
16837 {
16838 #ifdef HAVE_ADL
16839 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16840 {
16841 hc_thread_mutex_lock (mux_adl);
16842
16843 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16844 {
16845 hc_device_param_t *device_param = &data.devices_param[device_id];
16846
16847 if (device_param->skipped) continue;
16848
16849 if (data.hm_device[device_id].fan_supported == 1)
16850 {
16851 int fanspeed = temp_retain_fanspeed_value[device_id];
16852
16853 if (fanspeed == -1) continue;
16854
16855 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16856
16857 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16858 }
16859 }
16860
16861 hc_thread_mutex_unlock (mux_adl);
16862 }
16863 #endif // HAVE_ADL
16864 }
16865
16866 #ifdef HAVE_ADL
16867 // reset power tuning
16868
16869 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16870 {
16871 hc_thread_mutex_lock (mux_adl);
16872
16873 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16874 {
16875 hc_device_param_t *device_param = &data.devices_param[device_id];
16876
16877 if (device_param->skipped) continue;
16878
16879 if (data.hm_device[device_id].od_version == 6)
16880 {
16881 // check powertune capabilities first, if not available then skip device
16882
16883 int powertune_supported = 0;
16884
16885 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16886 {
16887 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16888
16889 return (-1);
16890 }
16891
16892 if (powertune_supported != 0)
16893 {
16894 // powercontrol settings
16895
16896 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)
16897 {
16898 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16899
16900 return (-1);
16901 }
16902
16903 // clocks
16904
16905 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16906
16907 performance_state->iNumberOfPerformanceLevels = 2;
16908
16909 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16910 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16911 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16912 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16913
16914 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)
16915 {
16916 log_info ("ERROR: Failed to restore ADL performance state");
16917
16918 return (-1);
16919 }
16920
16921 local_free (performance_state);
16922 }
16923 }
16924 }
16925
16926 hc_thread_mutex_unlock (mux_adl);
16927 }
16928 #endif // HAVE_ADL
16929
16930 if (gpu_temp_disable == 0)
16931 {
16932 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16933 if (data.hm_nv)
16934 {
16935 #if defined(LINUX) && defined(HAVE_NVML)
16936
16937 hm_NVML_nvmlShutdown (data.hm_nv);
16938
16939 nvml_close (data.hm_nv);
16940
16941 #elif defined(WIN) && (HAVE_NVAPI)
16942
16943 hm_NvAPI_Unload (data.hm_nv);
16944
16945 nvapi_close (data.hm_nv);
16946
16947 #endif
16948
16949 data.hm_nv = NULL;
16950 }
16951 #endif
16952
16953 #ifdef HAVE_ADL
16954 if (data.hm_amd)
16955 {
16956 hm_ADL_Main_Control_Destroy (data.hm_amd);
16957
16958 adl_close (data.hm_amd);
16959 data.hm_amd = NULL;
16960 }
16961 #endif
16962 }
16963 #endif // HAVE_HWMON
16964
16965 // free memory
16966
16967 local_free (masks);
16968
16969 local_free (dictstat_base);
16970
16971 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16972 {
16973 pot_t *pot_ptr = &pot[pot_pos];
16974
16975 hash_t *hash = &pot_ptr->hash;
16976
16977 local_free (hash->digest);
16978
16979 if (isSalted)
16980 {
16981 local_free (hash->salt);
16982 }
16983 }
16984
16985 local_free (pot);
16986
16987 local_free (all_kernel_rules_cnt);
16988 local_free (all_kernel_rules_buf);
16989
16990 local_free (wl_data->buf);
16991 local_free (wl_data);
16992
16993 local_free (bitmap_s1_a);
16994 local_free (bitmap_s1_b);
16995 local_free (bitmap_s1_c);
16996 local_free (bitmap_s1_d);
16997 local_free (bitmap_s2_a);
16998 local_free (bitmap_s2_b);
16999 local_free (bitmap_s2_c);
17000 local_free (bitmap_s2_d);
17001
17002 #ifdef HAVE_HWMON
17003 local_free (temp_retain_fanspeed_value);
17004 #ifdef HAVE_ADL
17005 local_free (od_clock_mem_status);
17006 local_free (od_power_control_status);
17007 #endif // ADL
17008 #endif
17009
17010 global_free (devices_param);
17011
17012 global_free (kernel_rules_buf);
17013
17014 global_free (root_css_buf);
17015 global_free (markov_css_buf);
17016
17017 global_free (digests_buf);
17018 global_free (digests_shown);
17019 global_free (digests_shown_tmp);
17020
17021 global_free (salts_buf);
17022 global_free (salts_shown);
17023
17024 global_free (esalts_buf);
17025
17026 global_free (words_progress_done);
17027 global_free (words_progress_rejected);
17028 global_free (words_progress_restored);
17029
17030 if (pot_fp) fclose (pot_fp);
17031
17032 if (data.devices_status == STATUS_QUIT) break;
17033 }
17034
17035 // destroy others mutex
17036
17037 hc_thread_mutex_delete (mux_dispatcher);
17038 hc_thread_mutex_delete (mux_counter);
17039 hc_thread_mutex_delete (mux_display);
17040 hc_thread_mutex_delete (mux_adl);
17041
17042 // free memory
17043
17044 local_free (eff_restore_file);
17045 local_free (new_restore_file);
17046
17047 local_free (rd);
17048
17049 // loopback
17050
17051 local_free (loopback_file);
17052
17053 if (loopback == 1) unlink (loopback_file);
17054
17055 // induction directory
17056
17057 if (induction_dir == NULL)
17058 {
17059 if (attack_mode != ATTACK_MODE_BF)
17060 {
17061 if (rmdir (induction_directory) == -1)
17062 {
17063 if (errno == ENOENT)
17064 {
17065 // good, we can ignore
17066 }
17067 else if (errno == ENOTEMPTY)
17068 {
17069 // good, we can ignore
17070 }
17071 else
17072 {
17073 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17074
17075 return (-1);
17076 }
17077 }
17078
17079 local_free (induction_directory);
17080 }
17081 }
17082
17083 // outfile-check directory
17084
17085 if (outfile_check_dir == NULL)
17086 {
17087 if (rmdir (outfile_check_directory) == -1)
17088 {
17089 if (errno == ENOENT)
17090 {
17091 // good, we can ignore
17092 }
17093 else if (errno == ENOTEMPTY)
17094 {
17095 // good, we can ignore
17096 }
17097 else
17098 {
17099 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17100
17101 return (-1);
17102 }
17103 }
17104
17105 local_free (outfile_check_directory);
17106 }
17107
17108 time_t proc_stop;
17109
17110 time (&proc_stop);
17111
17112 logfile_top_uint (proc_start);
17113 logfile_top_uint (proc_stop);
17114
17115 logfile_top_msg ("STOP");
17116
17117 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17118 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17119
17120 if (data.ocl) ocl_close (data.ocl);
17121
17122 if (data.devices_status == STATUS_ABORTED) return 2;
17123 if (data.devices_status == STATUS_QUIT) return 2;
17124 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17125 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17126 if (data.devices_status == STATUS_CRACKED) return 0;
17127
17128 return -1;
17129 }
Hashcat additions to support pwdhash