projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #183 from gm4tr1x/updateTestScript
[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 #ifndef OSX
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 #else
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
397 #endif
398 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
399 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
400 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
401 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
402 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
403 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
404 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 #ifdef HAVE_HWMON
407 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
408 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
409 #ifdef HAVE_ADL
410 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
411 #endif
412 #endif
413 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
414 "",
415 "* Distributed:",
416 "",
417 " -s, --skip=NUM Skip number of words",
418 " -l, --limit=NUM Limit number of words",
419 " --keyspace Show keyspace base:mod values and quit",
420 "",
421 "* Rules:",
422 "",
423 " -j, --rule-left=RULE Single rule applied to each word from left dict",
424 " -k, --rule-right=RULE Single rule applied to each word from right dict",
425 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
426 " -g, --generate-rules=NUM Generate NUM random rules",
427 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
428 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
429 " --generate-rules-seed=NUM Force RNG seed to NUM",
430 "",
431 "* Custom charsets:",
432 "",
433 " -1, --custom-charset1=CS User-defined charsets",
434 " -2, --custom-charset2=CS Example:",
435 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
436 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
437 "",
438 "* Increment:",
439 "",
440 " -i, --increment Enable increment mode",
441 " --increment-min=NUM Start incrementing at NUM",
442 " --increment-max=NUM Stop incrementing at NUM",
443 "",
444 "==========",
445 "References",
446 "==========",
447 "",
448 "* Workload Profile:",
449 "",
450 " 1 = Reduced performance profile (low latency desktop)",
451 " 2 = Default performance profile",
452 " 3 = Tuned performance profile (high latency desktop)",
453 "",
454 "* Benchmark Settings:",
455 "",
456 " 0 = Manual Tuning",
457 " 1 = Performance Tuning, default",
458 "",
459 "* OpenCL device-types:",
460 "",
461 " 1 = CPU devices",
462 " 2 = GPU devices",
463 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
464 "",
465 "* Outfile Formats:",
466 "",
467 " 1 = hash[:salt]",
468 " 2 = plain",
469 " 3 = hash[:salt]:plain",
470 " 4 = hex_plain",
471 " 5 = hash[:salt]:hex_plain",
472 " 6 = plain:hex_plain",
473 " 7 = hash[:salt]:plain:hex_plain",
474 " 8 = crackpos",
475 " 9 = hash[:salt]:crackpos",
476 " 10 = plain:crackpos",
477 " 11 = hash[:salt]:plain:crackpos",
478 " 12 = hex_plain:crackpos",
479 " 13 = hash[:salt]:hex_plain:crackpos",
480 " 14 = plain:hex_plain:crackpos",
481 " 15 = hash[:salt]:plain:hex_plain:crackpos",
482 "",
483 "* Debug mode output formats (for hybrid mode only, by using rules):",
484 "",
485 " 1 = save finding rule",
486 " 2 = save original word",
487 " 3 = save original word and finding rule",
488 " 4 = save original word, finding rule and modified plain",
489 "",
490 "* Built-in charsets:",
491 "",
492 " ?l = abcdefghijklmnopqrstuvwxyz",
493 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
494 " ?d = 0123456789",
495 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
496 " ?a = ?l?u?d?s",
497 " ?b = 0x00 - 0xff",
498 "",
499 "* Attack modes:",
500 "",
501 " 0 = Straight",
502 " 1 = Combination",
503 " 3 = Brute-force",
504 " 6 = Hybrid dict + mask",
505 " 7 = Hybrid mask + dict",
506 "",
507 "* Hash types:",
508 "",
509 "[[ Roll-your-own: Raw Hashes ]]",
510 "",
511 " 900 = MD4",
512 " 0 = MD5",
513 " 5100 = Half MD5",
514 " 100 = SHA1",
515 " 10800 = SHA-384",
516 " 1400 = SHA-256",
517 " 1700 = SHA-512",
518 " 5000 = SHA-3(Keccak)",
519 " 10100 = SipHash",
520 " 6000 = RipeMD160",
521 " 6100 = Whirlpool",
522 " 6900 = GOST R 34.11-94",
523 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
524 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
525 "",
526 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
527 "",
528 " 10 = md5($pass.$salt)",
529 " 20 = md5($salt.$pass)",
530 " 30 = md5(unicode($pass).$salt)",
531 " 40 = md5($salt.unicode($pass))",
532 " 3800 = md5($salt.$pass.$salt)",
533 " 3710 = md5($salt.md5($pass))",
534 " 2600 = md5(md5($pass)",
535 " 4300 = md5(strtoupper(md5($pass)))",
536 " 4400 = md5(sha1($pass))",
537 " 110 = sha1($pass.$salt)",
538 " 120 = sha1($salt.$pass)",
539 " 130 = sha1(unicode($pass).$salt)",
540 " 140 = sha1($salt.unicode($pass))",
541 " 4500 = sha1(sha1($pass)",
542 " 4700 = sha1(md5($pass))",
543 " 4900 = sha1($salt.$pass.$salt)",
544 " 1410 = sha256($pass.$salt)",
545 " 1420 = sha256($salt.$pass)",
546 " 1430 = sha256(unicode($pass).$salt)",
547 " 1440 = sha256($salt.unicode($pass))",
548 " 1710 = sha512($pass.$salt)",
549 " 1720 = sha512($salt.$pass)",
550 " 1730 = sha512(unicode($pass).$salt)",
551 " 1740 = sha512($salt.unicode($pass))",
552 "",
553 "[[ Roll-your-own: Authenticated Hashes ]]",
554 "",
555 " 50 = HMAC-MD5 (key = $pass)",
556 " 60 = HMAC-MD5 (key = $salt)",
557 " 150 = HMAC-SHA1 (key = $pass)",
558 " 160 = HMAC-SHA1 (key = $salt)",
559 " 1450 = HMAC-SHA256 (key = $pass)",
560 " 1460 = HMAC-SHA256 (key = $salt)",
561 " 1750 = HMAC-SHA512 (key = $pass)",
562 " 1760 = HMAC-SHA512 (key = $salt)",
563 "",
564 "[[ Generic KDF ]]",
565 "",
566 " 400 = phpass",
567 " 8900 = scrypt",
568 " 11900 = PBKDF2-HMAC-MD5",
569 " 12000 = PBKDF2-HMAC-SHA1",
570 " 10900 = PBKDF2-HMAC-SHA256",
571 " 12100 = PBKDF2-HMAC-SHA512",
572 "",
573 "[[ Network protocols, Challenge-Response ]]",
574 "",
575 " 23 = Skype",
576 " 2500 = WPA/WPA2",
577 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
578 " 5300 = IKE-PSK MD5",
579 " 5400 = IKE-PSK SHA1",
580 " 5500 = NetNTLMv1",
581 " 5500 = NetNTLMv1 + ESS",
582 " 5600 = NetNTLMv2",
583 " 7300 = IPMI2 RAKP HMAC-SHA1",
584 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
585 " 8300 = DNSSEC (NSEC3)",
586 " 10200 = Cram MD5",
587 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
588 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
589 " 11400 = SIP digest authentication (MD5)",
590 "",
591 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
592 "",
593 " 121 = SMF (Simple Machines Forum)",
594 " 400 = phpBB3",
595 " 2611 = vBulletin < v3.8.5",
596 " 2711 = vBulletin > v3.8.5",
597 " 2811 = MyBB",
598 " 2811 = IPB (Invison Power Board)",
599 " 8400 = WBB3 (Woltlab Burning Board)",
600 " 11 = Joomla < 2.5.18",
601 " 400 = Joomla > 2.5.18",
602 " 400 = Wordpress",
603 " 2612 = PHPS",
604 " 7900 = Drupal7",
605 " 21 = osCommerce",
606 " 21 = xt:Commerce",
607 " 11000 = PrestaShop",
608 " 124 = Django (SHA-1)",
609 " 10000 = Django (PBKDF2-SHA256)",
610 " 3711 = Mediawiki B type",
611 " 7600 = Redmine",
612 "",
613 "[[ Database Server ]]",
614 "",
615 " 12 = PostgreSQL",
616 " 131 = MSSQL(2000)",
617 " 132 = MSSQL(2005)",
618 " 1731 = MSSQL(2012)",
619 " 1731 = MSSQL(2014)",
620 " 200 = MySQL323",
621 " 300 = MySQL4.1/MySQL5",
622 " 3100 = Oracle H: Type (Oracle 7+)",
623 " 112 = Oracle S: Type (Oracle 11+)",
624 " 12300 = Oracle T: Type (Oracle 12+)",
625 " 8000 = Sybase ASE",
626 "",
627 "[[ HTTP, SMTP, LDAP Server ]]",
628 "",
629 " 141 = EPiServer 6.x < v4",
630 " 1441 = EPiServer 6.x > v4",
631 " 1600 = Apache $apr1$",
632 " 12600 = ColdFusion 10+",
633 " 1421 = hMailServer",
634 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
635 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
636 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
637 "",
638 "[[ Checksums ]]",
639 "",
640 " 11500 = CRC32",
641 "",
642 "[[ Operating-Systems ]]",
643 "",
644 " 3000 = LM",
645 " 1000 = NTLM",
646 " 1100 = Domain Cached Credentials (DCC), MS Cache",
647 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
648 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
649 " 1500 = descrypt, DES(Unix), Traditional DES",
650 " 12400 = BSDiCrypt, Extended DES",
651 " 500 = md5crypt $1$, MD5(Unix)",
652 " 3200 = bcrypt $2*$, Blowfish(Unix)",
653 " 7400 = sha256crypt $5$, SHA256(Unix)",
654 " 1800 = sha512crypt $6$, SHA512(Unix)",
655 " 122 = OSX v10.4",
656 " 122 = OSX v10.5",
657 " 122 = OSX v10.6",
658 " 1722 = OSX v10.7",
659 " 7100 = OSX v10.8",
660 " 7100 = OSX v10.9",
661 " 7100 = OSX v10.10",
662 " 6300 = AIX {smd5}",
663 " 6700 = AIX {ssha1}",
664 " 6400 = AIX {ssha256}",
665 " 6500 = AIX {ssha512}",
666 " 2400 = Cisco-PIX",
667 " 2410 = Cisco-ASA",
668 " 500 = Cisco-IOS $1$",
669 " 5700 = Cisco-IOS $4$",
670 " 9200 = Cisco-IOS $8$",
671 " 9300 = Cisco-IOS $9$",
672 " 22 = Juniper Netscreen/SSG (ScreenOS)",
673 " 501 = Juniper IVE",
674 " 5800 = Android PIN",
675 " 8100 = Citrix Netscaler",
676 " 8500 = RACF",
677 " 7200 = GRUB 2",
678 " 9900 = Radmin2",
679 "",
680 "[[ Enterprise Application Software (EAS) ]]",
681 "",
682 " 7700 = SAP CODVN B (BCODE)",
683 " 7800 = SAP CODVN F/G (PASSCODE)",
684 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
685 " 8600 = Lotus Notes/Domino 5",
686 " 8700 = Lotus Notes/Domino 6",
687 " 9100 = Lotus Notes/Domino 8",
688 " 133 = PeopleSoft",
689 "",
690 "[[ Archives ]]",
691 "",
692 " 11600 = 7-Zip",
693 " 12500 = RAR3-hp",
694 " 13000 = RAR5",
695 "",
696 "[[ Full-Disk encryptions (FDE) ]]",
697 "",
698 " 62XY = TrueCrypt 5.0+",
699 " X = 1 = PBKDF2-HMAC-RipeMD160",
700 " X = 2 = PBKDF2-HMAC-SHA512",
701 " X = 3 = PBKDF2-HMAC-Whirlpool",
702 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
703 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
704 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
705 " Y = 3 = XTS 1536 bit (Ciphers: All)",
706 " 8800 = Android FDE < v4.3",
707 " 12900 = Android FDE (Samsung DEK)",
708 " 12200 = eCryptfs",
709 "",
710 "[[ Documents ]]",
711 "",
712 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
713 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
714 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
715 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
716 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
717 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
718 " 9400 = MS Office 2007",
719 " 9500 = MS Office 2010",
720 " 9600 = MS Office 2013",
721 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
722 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
723 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
724 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
725 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
726 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
727 "",
728 "[[ Password Managers ]]",
729 "",
730 " 9000 = Password Safe v2",
731 " 5200 = Password Safe v3",
732 " 6800 = Lastpass",
733 " 6600 = 1Password, agilekeychain",
734 " 8200 = 1Password, cloudkeychain",
735 " 11300 = Bitcoin/Litecoin wallet.dat",
736 " 12700 = Blockchain, My Wallet",
737 "",
738 NULL
739 };
740
741 /**
742 * oclHashcat specific functions
743 */
744
745 void status_display_automat ()
746 {
747 FILE *out = stdout;
748
749 fprintf (out, "STATUS\t%u\t", data.devices_status);
750
751 /**
752 * speed new
753 */
754
755 fprintf (out, "SPEED\t");
756
757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
758 {
759 hc_device_param_t *device_param = &data.devices_param[device_id];
760
761 if (device_param->skipped) continue;
762
763 u64 speed_cnt = 0;
764 float speed_ms = 0;
765
766 for (int i = 0; i < SPEED_CACHE; i++)
767 {
768 float rec_ms;
769
770 hc_timer_get (device_param->speed_rec[i], rec_ms);
771
772 if (rec_ms > SPEED_MAXAGE) continue;
773
774 speed_cnt += device_param->speed_cnt[i];
775 speed_ms += device_param->speed_ms[i];
776 }
777
778 speed_cnt /= SPEED_CACHE;
779 speed_ms /= SPEED_CACHE;
780
781 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
782 }
783
784 /**
785 * words_cur
786 */
787
788 u64 words_cur = get_lowest_words_done ();
789
790 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
791
792 /**
793 * counter
794 */
795
796 uint salts_left = data.salts_cnt - data.salts_done;
797
798 if (salts_left == 0) salts_left = 1;
799
800 u64 progress_total = data.words_cnt * salts_left;
801
802 u64 all_done = 0;
803 u64 all_rejected = 0;
804 u64 all_restored = 0;
805
806 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
807 {
808 if (salts_left > 1)
809 {
810 // otherwise the final cracked status shows 0/XXX progress
811
812 if (data.salts_shown[salt_pos] == 1) continue;
813 }
814
815 all_done += data.words_progress_done[salt_pos];
816 all_rejected += data.words_progress_rejected[salt_pos];
817 all_restored += data.words_progress_restored[salt_pos];
818 }
819
820 u64 progress_cur = all_restored + all_done + all_rejected;
821 u64 progress_end = progress_total;
822
823 u64 progress_skip = 0;
824
825 if (data.skip)
826 {
827 progress_skip = MIN (data.skip, data.words_base) * salts_left;
828
829 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
830 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
831 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
832 }
833
834 if (data.limit)
835 {
836 progress_end = MIN (data.limit, data.words_base) * salts_left;
837
838 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
839 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
840 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
841 }
842
843 u64 progress_cur_relative_skip = progress_cur - progress_skip;
844 u64 progress_end_relative_skip = progress_end - progress_skip;
845
846 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
847
848 /**
849 * cracks
850 */
851
852 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
853 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
854
855 /**
856 * temperature
857 */
858
859 #ifdef HAVE_HWMON
860 if (data.gpu_temp_disable == 0)
861 {
862 fprintf (out, "TEMP\t");
863
864 hc_thread_mutex_lock (mux_adl);
865
866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
867 {
868 hc_device_param_t *device_param = &data.devices_param[device_id];
869
870 if (device_param->skipped) continue;
871
872 int temp = hm_get_temperature_with_device_id (device_id);
873
874 fprintf (out, "%d\t", temp);
875 }
876
877 hc_thread_mutex_unlock (mux_adl);
878 }
879 #endif // HAVE_HWMON
880
881 #ifdef _WIN
882 fputc ('\r', out);
883 fputc ('\n', out);
884 #endif
885
886 #ifdef _POSIX
887 fputc ('\n', out);
888 #endif
889
890 fflush (out);
891 }
892
893 void status_display ()
894 {
895 if (data.devices_status == STATUS_INIT) return;
896 if (data.devices_status == STATUS_STARTING) return;
897 if (data.devices_status == STATUS_BYPASS) return;
898
899 if (data.status_automat == 1)
900 {
901 status_display_automat ();
902
903 return;
904 }
905
906 char tmp_buf[1000] = { 0 };
907
908 uint tmp_len = 0;
909
910 log_info ("Session.Name...: %s", data.session);
911
912 char *status_type = strstatus (data.devices_status);
913
914 uint hash_mode = data.hash_mode;
915
916 char *hash_type = strhashtype (hash_mode); // not a bug
917
918 log_info ("Status.........: %s", status_type);
919
920 /**
921 * show rules
922 */
923
924 if (data.rp_files_cnt)
925 {
926 uint i;
927
928 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
929 {
930 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
931 }
932
933 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
934
935 log_info ("Rules.Type.....: %s", tmp_buf);
936
937 tmp_len = 0;
938 }
939
940 if (data.rp_gen)
941 {
942 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
943
944 if (data.rp_gen_seed)
945 {
946 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
947 }
948 }
949
950 /**
951 * show input
952 */
953
954 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
955 {
956 if (data.wordlist_mode == WL_MODE_FILE)
957 {
958 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
959 }
960 else if (data.wordlist_mode == WL_MODE_STDIN)
961 {
962 log_info ("Input.Mode.....: Pipe");
963 }
964 }
965 else if (data.attack_mode == ATTACK_MODE_COMBI)
966 {
967 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
968 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
969 }
970 else if (data.attack_mode == ATTACK_MODE_BF)
971 {
972 char *mask = data.mask;
973
974 if (mask != NULL)
975 {
976 uint mask_len = data.css_cnt;
977
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
979
980 if (mask_len > 0)
981 {
982 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
983 {
984 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
985 {
986 mask_len -= data.salts_buf[0].salt_len;
987 }
988 }
989
990 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
991
992 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
993 }
994
995 if (data.maskcnt > 1)
996 {
997 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1000 }
1001
1002 log_info ("Input.Mode.....: %s", tmp_buf);
1003 }
1004
1005 tmp_len = 0;
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1008 {
1009 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1010 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1013 {
1014 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1015 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1016 }
1017
1018 if (data.digests_cnt == 1)
1019 {
1020 if (data.hash_mode == 2500)
1021 {
1022 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1023
1024 uint pke[25] = { 0 };
1025
1026 char *pke_ptr = (char *) pke;
1027
1028 for (uint i = 0; i < 25; i++)
1029 {
1030 pke[i] = byte_swap_32 (wpa->pke[i]);
1031 }
1032
1033 char mac1[6] = { 0 };
1034 char mac2[6] = { 0 };
1035
1036 memcpy (mac1, pke_ptr + 23, 6);
1037 memcpy (mac2, pke_ptr + 29, 6);
1038
1039 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1040 (char *) data.salts_buf[0].salt_buf,
1041 mac1[0] & 0xff,
1042 mac1[1] & 0xff,
1043 mac1[2] & 0xff,
1044 mac1[3] & 0xff,
1045 mac1[4] & 0xff,
1046 mac1[5] & 0xff,
1047 mac2[0] & 0xff,
1048 mac2[1] & 0xff,
1049 mac2[2] & 0xff,
1050 mac2[3] & 0xff,
1051 mac2[4] & 0xff,
1052 mac2[5] & 0xff);
1053 }
1054 else if (data.hash_mode == 5200)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if (data.hash_mode == 9000)
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else
1067 {
1068 char out_buf[4096] = { 0 };
1069
1070 ascii_digest (out_buf, 0, 0);
1071
1072 // limit length
1073 if (strlen (out_buf) > 40)
1074 {
1075 out_buf[41] = '.';
1076 out_buf[42] = '.';
1077 out_buf[43] = '.';
1078 out_buf[44] = 0;
1079 }
1080
1081 log_info ("Hash.Target....: %s", out_buf);
1082 }
1083 }
1084 else
1085 {
1086 if (data.hash_mode == 3000)
1087 {
1088 char out_buf1[4096] = { 0 };
1089 char out_buf2[4096] = { 0 };
1090
1091 ascii_digest (out_buf1, 0, 0);
1092 ascii_digest (out_buf2, 0, 1);
1093
1094 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1095 }
1096 else
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 }
1101
1102 log_info ("Hash.Type......: %s", hash_type);
1103
1104 /**
1105 * speed new
1106 */
1107
1108 u64 speed_cnt[DEVICES_MAX] = { 0 };
1109 float speed_ms[DEVICES_MAX] = { 0 };
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hc_device_param_t *device_param = &data.devices_param[device_id];
1114
1115 if (device_param->skipped) continue;
1116
1117 // we need to clear values (set to 0) because in case the device does
1118 // not get new candidates it idles around but speed display would
1119 // show it as working.
1120 // if we instantly set it to 0 after reading it happens that the
1121 // speed can be shown as zero if the users refreshes too fast.
1122 // therefore, we add a timestamp when a stat was recorded and if its
1123 // too old we will not use it
1124
1125 speed_cnt[device_id] = 0;
1126 speed_ms[device_id] = 0;
1127
1128 for (int i = 0; i < SPEED_CACHE; i++)
1129 {
1130 float rec_ms;
1131
1132 hc_timer_get (device_param->speed_rec[i], rec_ms);
1133
1134 if (rec_ms > SPEED_MAXAGE) continue;
1135
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 float hashes_all_ms = 0;
1145
1146 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * timers
1166 */
1167
1168 float ms_running = 0;
1169
1170 hc_timer_get (data.timer_running, ms_running);
1171
1172 float ms_paused = data.ms_paused;
1173
1174 if (data.devices_status == STATUS_PAUSED)
1175 {
1176 float ms_paused_tmp = 0;
1177
1178 hc_timer_get (data.timer_paused, ms_paused_tmp);
1179
1180 ms_paused += ms_paused_tmp;
1181 }
1182
1183 #ifdef WIN
1184
1185 __time64_t sec_run = ms_running / 1000;
1186
1187 #else
1188
1189 time_t sec_run = ms_running / 1000;
1190
1191 #endif
1192
1193 if (sec_run)
1194 {
1195 char display_run[32] = { 0 };
1196
1197 struct tm tm_run;
1198
1199 struct tm *tmp = NULL;
1200
1201 #ifdef WIN
1202
1203 tmp = _gmtime64 (&sec_run);
1204
1205 #else
1206
1207 tmp = gmtime (&sec_run);
1208
1209 #endif
1210
1211 if (tmp != NULL)
1212 {
1213 memset (&tm_run, 0, sizeof (tm_run));
1214
1215 memcpy (&tm_run, tmp, sizeof (tm_run));
1216
1217 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1218
1219 char *start = ctime (&data.proc_start);
1220
1221 size_t start_len = strlen (start);
1222
1223 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1224 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1225
1226 log_info ("Time.Started...: %s (%s)", start, display_run);
1227 }
1228 }
1229 else
1230 {
1231 log_info ("Time.Started...: 0 secs");
1232 }
1233
1234 /**
1235 * counters
1236 */
1237
1238 uint salts_left = data.salts_cnt - data.salts_done;
1239
1240 if (salts_left == 0) salts_left = 1;
1241
1242 u64 progress_total = data.words_cnt * salts_left;
1243
1244 u64 all_done = 0;
1245 u64 all_rejected = 0;
1246 u64 all_restored = 0;
1247
1248 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1249 {
1250 if (salts_left > 1)
1251 {
1252 // otherwise the final cracked status shows 0/XXX progress
1253
1254 if (data.salts_shown[salt_pos] == 1) continue;
1255 }
1256
1257 all_done += data.words_progress_done[salt_pos];
1258 all_rejected += data.words_progress_rejected[salt_pos];
1259 all_restored += data.words_progress_restored[salt_pos];
1260 }
1261
1262 u64 progress_cur = all_restored + all_done + all_rejected;
1263 u64 progress_end = progress_total;
1264
1265 u64 progress_skip = 0;
1266
1267 if (data.skip)
1268 {
1269 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1270
1271 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1272 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1273 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1274 }
1275
1276 if (data.limit)
1277 {
1278 progress_end = MIN (data.limit, data.words_base) * salts_left;
1279
1280 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1281 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1282 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1283 }
1284
1285 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1286 u64 progress_end_relative_skip = progress_end - progress_skip;
1287
1288 float speed_ms_real = ms_running - ms_paused;
1289 u64 speed_plains_real = all_done;
1290
1291 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1292 {
1293 if (data.devices_status != STATUS_CRACKED)
1294 {
1295 u64 words_per_ms = 0;
1296
1297 if (speed_plains_real && speed_ms_real)
1298 {
1299 words_per_ms = speed_plains_real / speed_ms_real;
1300 }
1301
1302 #ifdef WIN
1303 __time64_t sec_etc = 0;
1304 #else
1305 time_t sec_etc = 0;
1306 #endif
1307
1308 if (words_per_ms)
1309 {
1310 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1311
1312 u64 ms_left = progress_left_relative_skip / words_per_ms;
1313
1314 sec_etc = ms_left / 1000;
1315 }
1316
1317 if (sec_etc == 0)
1318 {
1319 log_info ("Time.Estimated.: 0 secs");
1320 }
1321 else if ((u64) sec_etc > ETC_MAX)
1322 {
1323 log_info ("Time.Estimated.: > 10 Years");
1324 }
1325 else
1326 {
1327 char display_etc[32] = { 0 };
1328
1329 struct tm tm_etc;
1330
1331 struct tm *tmp = NULL;
1332
1333 #ifdef WIN
1334
1335 tmp = _gmtime64 (&sec_etc);
1336
1337 #else
1338
1339 tmp = gmtime (&sec_etc);
1340
1341 #endif
1342
1343 if (tmp != NULL)
1344 {
1345 memset (&tm_etc, 0, sizeof (tm_etc));
1346
1347 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1348
1349 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1350
1351 time_t now;
1352
1353 time (&now);
1354
1355 now += sec_etc;
1356
1357 char *etc = ctime (&now);
1358
1359 size_t etc_len = strlen (etc);
1360
1361 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1362 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1363
1364 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1365 }
1366 }
1367 }
1368 }
1369
1370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1371 {
1372 hc_device_param_t *device_param = &data.devices_param[device_id];
1373
1374 if (device_param->skipped) continue;
1375
1376 char display_dev_cur[16] = { 0 };
1377
1378 strncpy (display_dev_cur, "0.00", 4);
1379
1380 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1381
1382 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1383 }
1384
1385 char display_all_cur[16] = { 0 };
1386
1387 strncpy (display_all_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1390
1391 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1392
1393 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1394 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1395
1396 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);
1397
1398 // crack-per-time
1399
1400 if (data.digests_cnt > 100)
1401 {
1402 time_t now = time (NULL);
1403
1404 int cpt_cur_min = 0;
1405 int cpt_cur_hour = 0;
1406 int cpt_cur_day = 0;
1407
1408 for (int i = 0; i < CPT_BUF; i++)
1409 {
1410 const uint cracked = data.cpt_buf[i].cracked;
1411 const time_t timestamp = data.cpt_buf[i].timestamp;
1412
1413 if ((timestamp + 60) > now)
1414 {
1415 cpt_cur_min += cracked;
1416 }
1417
1418 if ((timestamp + 3600) > now)
1419 {
1420 cpt_cur_hour += cracked;
1421 }
1422
1423 if ((timestamp + 86400) > now)
1424 {
1425 cpt_cur_day += cracked;
1426 }
1427 }
1428
1429 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1430 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1431 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1432
1433 if ((data.cpt_start + 86400) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_cur_hour,
1438 cpt_cur_day,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else if ((data.cpt_start + 3600) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 60) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else
1461 {
1462 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 }
1468
1469 // Restore point
1470
1471 u64 restore_point = get_lowest_words_done ();
1472
1473 u64 restore_total = data.words_base;
1474
1475 float percent_restore = 0;
1476
1477 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1478
1479 if (progress_end_relative_skip)
1480 {
1481 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1482 {
1483 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1484 float percent_rejected = 0.0;
1485
1486 if (progress_cur)
1487 {
1488 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1489 }
1490
1491 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);
1492 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1493
1494 if (data.restore_disable == 0)
1495 {
1496 if (percent_finished != 1)
1497 {
1498 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1499 }
1500 }
1501 }
1502 }
1503 else
1504 {
1505 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1506 {
1507 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509
1510 if (data.restore_disable == 0)
1511 {
1512 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513 }
1514 }
1515 else
1516 {
1517 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1518 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1519
1520 // --restore not allowed if stdin is used -- really? why?
1521
1522 //if (data.restore_disable == 0)
1523 //{
1524 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1525 //}
1526 }
1527 }
1528
1529 #ifdef HAVE_HWMON
1530 if (data.gpu_temp_disable == 0)
1531 {
1532 hc_thread_mutex_lock (mux_adl);
1533
1534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1535 {
1536 hc_device_param_t *device_param = &data.devices_param[device_id];
1537
1538 if (device_param->skipped) continue;
1539
1540 #define HM_STR_BUF_SIZE 255
1541
1542 if (data.hm_device[device_id].fan_supported == 1)
1543 {
1544 char utilization[HM_STR_BUF_SIZE] = { 0 };
1545 char temperature[HM_STR_BUF_SIZE] = { 0 };
1546 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1547
1548 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1549 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1550
1551 if (device_param->vendor_id == VENDOR_ID_AMD)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555 else if (device_param->vendor_id == VENDOR_ID_NV)
1556 {
1557 #ifdef LINUX
1558 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1559 #else
1560 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1561 #endif
1562 }
1563
1564 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1565 }
1566 else
1567 {
1568 char utilization[HM_STR_BUF_SIZE] = { 0 };
1569 char temperature[HM_STR_BUF_SIZE] = { 0 };
1570
1571 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1572 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1573
1574 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1575 }
1576 }
1577
1578 hc_thread_mutex_unlock (mux_adl);
1579 }
1580 #endif // HAVE_HWMON
1581 }
1582
1583 static void status_benchmark ()
1584 {
1585 if (data.devices_status == STATUS_INIT) return;
1586 if (data.devices_status == STATUS_STARTING) return;
1587
1588 if (data.words_cnt == 0) return;
1589
1590 u64 speed_cnt[DEVICES_MAX] = { 0 };
1591 float speed_ms[DEVICES_MAX] = { 0 };
1592
1593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1594 {
1595 hc_device_param_t *device_param = &data.devices_param[device_id];
1596
1597 if (device_param->skipped) continue;
1598
1599 speed_cnt[device_id] = 0;
1600 speed_ms[device_id] = 0;
1601
1602 for (int i = 0; i < SPEED_CACHE; i++)
1603 {
1604 speed_cnt[device_id] += device_param->speed_cnt[i];
1605 speed_ms[device_id] += device_param->speed_ms[i];
1606 }
1607
1608 speed_cnt[device_id] /= SPEED_CACHE;
1609 speed_ms[device_id] /= SPEED_CACHE;
1610 }
1611
1612 float hashes_all_ms = 0;
1613
1614 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 hashes_dev_ms[device_id] = 0;
1623
1624 if (speed_ms[device_id])
1625 {
1626 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1627
1628 hashes_all_ms += hashes_dev_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 char display_dev_cur[16] = { 0 };
1639
1640 strncpy (display_dev_cur, "0.00", 4);
1641
1642 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1643
1644 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1645 }
1646
1647 char display_all_cur[16] = { 0 };
1648
1649 strncpy (display_all_cur, "0.00", 4);
1650
1651 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1652
1653 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1654 }
1655
1656 /**
1657 * oclHashcat -only- functions
1658 */
1659
1660 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1661 {
1662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1663 {
1664 if (attack_kern == ATTACK_KERN_STRAIGHT)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1666 else if (attack_kern == ATTACK_KERN_COMBI)
1667 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1668 else if (attack_kern == ATTACK_KERN_BF)
1669 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1670 }
1671 else
1672 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1673 }
1674
1675 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)
1676 {
1677 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1678 {
1679 if (attack_kern == ATTACK_KERN_STRAIGHT)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 else if (attack_kern == ATTACK_KERN_COMBI)
1682 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1683 else if (attack_kern == ATTACK_KERN_BF)
1684 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1685 }
1686 else
1687 {
1688 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1689 }
1690 }
1691
1692 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1693 {
1694 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1695 {
1696 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1697 }
1698 else
1699 {
1700 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1701 }
1702 }
1703
1704 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)
1705 {
1706 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1707 {
1708 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1709 }
1710 else
1711 {
1712 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1713 }
1714 }
1715
1716 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1717 {
1718 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1719 }
1720
1721 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1722 {
1723 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1724 }
1725
1726 static uint convert_from_hex (char *line_buf, const uint line_len)
1727 {
1728 if (line_len & 1) return (line_len); // not in hex
1729
1730 if (data.hex_wordlist == 1)
1731 {
1732 uint i;
1733 uint j;
1734
1735 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1736 {
1737 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1738 }
1739
1740 memset (line_buf + i, 0, line_len - i);
1741
1742 return (i);
1743 }
1744 else if (line_len >= 6) // $HEX[] = 6
1745 {
1746 if (line_buf[0] != '$') return (line_len);
1747 if (line_buf[1] != 'H') return (line_len);
1748 if (line_buf[2] != 'E') return (line_len);
1749 if (line_buf[3] != 'X') return (line_len);
1750 if (line_buf[4] != '[') return (line_len);
1751 if (line_buf[line_len - 1] != ']') return (line_len);
1752
1753 uint i;
1754 uint j;
1755
1756 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1757 {
1758 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1759 }
1760
1761 memset (line_buf + i, 0, line_len - i);
1762
1763 return (i);
1764 }
1765
1766 return (line_len);
1767 }
1768
1769 static uint count_lines (FILE *fd)
1770 {
1771 uint cnt = 0;
1772
1773 char *buf = (char *) mymalloc (BUFSIZ + 1);
1774
1775 size_t nread_tmp = 0;
1776
1777 char *ptr = buf;
1778
1779 while (!feof (fd))
1780 {
1781 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1782 nread_tmp = nread;
1783
1784 if (nread < 1) continue;
1785
1786 ptr = buf;
1787
1788 do
1789 {
1790 if (*ptr++ == '\n') cnt++;
1791
1792 } while (nread--);
1793 }
1794
1795 // special case (if last line did not contain a newline char ... at the very end of the file)
1796
1797 if (nread_tmp > 3)
1798 {
1799 ptr -= 2;
1800
1801 if (*ptr != '\n')
1802 {
1803 ptr--;
1804
1805 if (*ptr != '\n') // needed ? different on windows systems?
1806 {
1807 cnt++;
1808 }
1809 }
1810 }
1811
1812 myfree (buf);
1813
1814 return cnt;
1815 }
1816
1817 static void clear_prompt ()
1818 {
1819 fputc ('\r', stdout);
1820
1821 for (size_t i = 0; i < strlen (PROMPT); i++)
1822 {
1823 fputc (' ', stdout);
1824 }
1825
1826 fputc ('\r', stdout);
1827
1828 fflush (stdout);
1829 }
1830
1831 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1832 {
1833 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);
1834 }
1835
1836 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1837 {
1838 char *outfile = data.outfile;
1839 uint quiet = data.quiet;
1840 FILE *pot_fp = data.pot_fp;
1841 uint loopback = data.loopback;
1842 uint debug_mode = data.debug_mode;
1843 char *debug_file = data.debug_file;
1844
1845 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1846 int debug_rule_len = 0; // -1 error
1847 uint debug_plain_len = 0;
1848
1849 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1850
1851 // hash
1852
1853 char out_buf[4096] = { 0 };
1854
1855 ascii_digest (out_buf, salt_pos, digest_pos);
1856
1857 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1858
1859 // plain
1860
1861 plain_t plain;
1862
1863 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);
1864
1865 uint gidvid = plain.gidvid;
1866 uint il_pos = plain.il_pos;
1867
1868 u64 crackpos = device_param->words_off;
1869
1870 uint plain_buf[16] = { 0 };
1871
1872 u8 *plain_ptr = (u8 *) plain_buf;
1873 unsigned int plain_len = 0;
1874
1875 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1876 {
1877 u64 gidd = gidvid;
1878 u64 gidm = 0;
1879
1880 pw_t pw;
1881
1882 gidd_to_pw_t (device_param, gidd, &pw);
1883
1884 for (int i = 0, j = gidm; i < 16; i++, j++)
1885 {
1886 plain_buf[i] = pw.h.hi1[0][j];
1887 }
1888
1889 plain_len = pw.pw_len;
1890
1891 const uint off = device_param->innerloop_pos + il_pos;
1892
1893 if (debug_mode > 0)
1894 {
1895 debug_rule_len = 0;
1896
1897 // save rule
1898 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1899 {
1900 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1901
1902 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1903 }
1904
1905 // save plain
1906 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1907 {
1908 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1909
1910 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1911
1912 debug_plain_len = plain_len;
1913 }
1914 }
1915
1916 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1917
1918 crackpos += gidvid;
1919 crackpos *= data.kernel_rules_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921
1922 if (plain_len > data.pw_max) plain_len = data.pw_max;
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_COMBI)
1925 {
1926 u64 gidd = gidvid;
1927 u64 gidm = 0;
1928
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidd, &pw);
1932
1933 for (int i = 0, j = gidm; i < 16; i++, j++)
1934 {
1935 plain_buf[i] = pw.h.hi1[0][j];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1941 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1942
1943 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1944 {
1945 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1946 }
1947 else
1948 {
1949 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1950
1951 memcpy (plain_ptr, comb_buf, comb_len);
1952 }
1953
1954 plain_len += comb_len;
1955
1956 crackpos += gidvid;
1957 crackpos *= data.combs_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (data.pw_max != PW_DICTMAX1)
1961 {
1962 if (plain_len > data.pw_max) plain_len = data.pw_max;
1963 }
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_BF)
1966 {
1967 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1968 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1969
1970 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1971 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1972
1973 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1974 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1975
1976 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1977 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1978
1979 plain_len = data.css_cnt;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.bfs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984 }
1985 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1986 {
1987 u64 gidd = gidvid;
1988 u64 gidm = 0;
1989
1990 pw_t pw;
1991
1992 gidd_to_pw_t (device_param, gidd, &pw);
1993
1994 for (int i = 0, j = gidm; i < 16; i++, j++)
1995 {
1996 plain_buf[i] = pw.h.hi1[0][j];
1997 }
1998
1999 plain_len = pw.pw_len;
2000
2001 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2002
2003 uint start = 0;
2004 uint stop = device_param->kernel_params_mp_buf32[4];
2005
2006 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2007
2008 plain_len += start + stop;
2009
2010 crackpos += gidvid;
2011 crackpos *= data.combs_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013
2014 if (data.pw_max != PW_DICTMAX1)
2015 {
2016 if (plain_len > data.pw_max) plain_len = data.pw_max;
2017 }
2018 }
2019 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2020 {
2021 u64 gidd = gidvid;
2022 u64 gidm = 0;
2023
2024 pw_t pw;
2025
2026 gidd_to_pw_t (device_param, gidd, &pw);
2027
2028 for (int i = 0, j = gidm; i < 16; i++, j++)
2029 {
2030 plain_buf[i] = pw.h.hi1[0][j];
2031 }
2032
2033 plain_len = pw.pw_len;
2034
2035 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2036
2037 uint start = 0;
2038 uint stop = device_param->kernel_params_mp_buf32[4];
2039
2040 memmove (plain_ptr + stop, plain_ptr, plain_len);
2041
2042 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2043
2044 plain_len += start + stop;
2045
2046 crackpos += gidvid;
2047 crackpos *= data.combs_cnt;
2048 crackpos += device_param->innerloop_pos + il_pos;
2049
2050 if (data.pw_max != PW_DICTMAX1)
2051 {
2052 if (plain_len > data.pw_max) plain_len = data.pw_max;
2053 }
2054 }
2055
2056 if (data.attack_mode == ATTACK_MODE_BF)
2057 {
2058 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2059 {
2060 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2061 {
2062 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2063 {
2064 plain_len = plain_len - data.salts_buf[0].salt_len;
2065 }
2066 }
2067
2068 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2069 {
2070 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2071 {
2072 plain_ptr[j] = plain_ptr[i];
2073 }
2074
2075 plain_len = plain_len / 2;
2076 }
2077 }
2078 }
2079
2080 // if enabled, update also the potfile
2081
2082 if (pot_fp)
2083 {
2084 lock_file (pot_fp);
2085
2086 fprintf (pot_fp, "%s:", out_buf);
2087
2088 format_plain (pot_fp, plain_ptr, plain_len, 1);
2089
2090 fputc ('\n', pot_fp);
2091
2092 fflush (pot_fp);
2093
2094 unlock_file (pot_fp);
2095 }
2096
2097 // outfile
2098
2099 FILE *out_fp = NULL;
2100
2101 if (outfile != NULL)
2102 {
2103 if ((out_fp = fopen (outfile, "ab")) == NULL)
2104 {
2105 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2106
2107 out_fp = stdout;
2108 }
2109 lock_file (out_fp);
2110 }
2111 else
2112 {
2113 out_fp = stdout;
2114
2115 if (quiet == 0) clear_prompt ();
2116 }
2117
2118 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2119
2120 if (outfile != NULL)
2121 {
2122 if (out_fp != stdout)
2123 {
2124 fclose (out_fp);
2125 }
2126 }
2127 else
2128 {
2129 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2130 {
2131 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2132 {
2133 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2134 if (quiet == 0) fflush (stdout);
2135 }
2136 }
2137 }
2138
2139 // loopback
2140
2141 if (loopback)
2142 {
2143 char *loopback_file = data.loopback_file;
2144
2145 FILE *fb_fp = NULL;
2146
2147 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2148 {
2149 lock_file (fb_fp);
2150
2151 format_plain (fb_fp, plain_ptr, plain_len, 1);
2152
2153 fputc ('\n', fb_fp);
2154
2155 fclose (fb_fp);
2156 }
2157 }
2158
2159 // (rule) debug mode
2160
2161 // the next check implies that:
2162 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2163 // - debug_mode > 0
2164
2165 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2166 {
2167 if (debug_rule_len < 0) debug_rule_len = 0;
2168
2169 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2170
2171 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2172
2173 if ((quiet == 0) && (debug_file == NULL))
2174 {
2175 fprintf (stdout, "%s", PROMPT);
2176 fflush (stdout);
2177 }
2178 }
2179 }
2180
2181 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2182 {
2183 salt_t *salt_buf = &data.salts_buf[salt_pos];
2184
2185 int found = 0;
2186
2187 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);
2188
2189 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2190
2191 if (found == 1)
2192 {
2193 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2194
2195 log_info_nn ("");
2196
2197 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);
2198
2199 uint cpt_cracked = 0;
2200
2201 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2202 {
2203 uint idx = salt_buf->digests_offset + digest_pos;
2204
2205 if (data.digests_shown_tmp[idx] == 0) continue;
2206
2207 if (data.digests_shown[idx] == 1) continue;
2208
2209 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2210 {
2211 data.digests_shown[idx] = 1;
2212
2213 data.digests_done++;
2214
2215 cpt_cracked++;
2216
2217 salt_buf->digests_done++;
2218
2219 if (salt_buf->digests_done == salt_buf->digests_cnt)
2220 {
2221 data.salts_shown[salt_pos] = 1;
2222
2223 data.salts_done++;
2224 }
2225 }
2226
2227 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2228
2229 check_hash (device_param, salt_pos, digest_pos);
2230 }
2231
2232 if (cpt_cracked > 0)
2233 {
2234 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2235 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2236
2237 data.cpt_pos++;
2238
2239 data.cpt_total += cpt_cracked;
2240
2241 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2242 }
2243
2244 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2245 {
2246 // we need to reset cracked state on the device
2247 // otherwise host thinks again and again the hash was cracked
2248 // and returns invalid password each time
2249
2250 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2251
2252 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);
2253 }
2254
2255 memset (device_param->result, 0, device_param->size_results);
2256
2257 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);
2258 }
2259 }
2260
2261 static void save_hash ()
2262 {
2263 char *hashfile = data.hashfile;
2264
2265 char new_hashfile[256] = { 0 };
2266 char old_hashfile[256] = { 0 };
2267
2268 snprintf (new_hashfile, 255, "%s.new", hashfile);
2269 snprintf (old_hashfile, 255, "%s.old", hashfile);
2270
2271 unlink (new_hashfile);
2272
2273 char separator = data.separator;
2274
2275 FILE *fp = fopen (new_hashfile, "wb");
2276
2277 if (fp == NULL)
2278 {
2279 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2280
2281 exit (-1);
2282 }
2283
2284 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2285 {
2286 if (data.salts_shown[salt_pos] == 1) continue;
2287
2288 salt_t *salt_buf = &data.salts_buf[salt_pos];
2289
2290 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2291 {
2292 uint idx = salt_buf->digests_offset + digest_pos;
2293
2294 if (data.digests_shown[idx] == 1) continue;
2295
2296 if (data.hash_mode != 2500)
2297 {
2298 char out_buf[4096] = { 0 };
2299
2300 if (data.username == 1)
2301 {
2302 user_t *user = data.hash_info[idx]->user;
2303
2304 uint i;
2305
2306 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2307
2308 fputc (separator, fp);
2309 }
2310
2311 ascii_digest (out_buf, salt_pos, digest_pos);
2312
2313 fputs (out_buf, fp);
2314
2315 log_out (fp, "");
2316 }
2317 else
2318 {
2319 hccap_t hccap;
2320
2321 to_hccap_t (&hccap, salt_pos, digest_pos);
2322
2323 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2324 }
2325 }
2326 }
2327
2328 fflush (fp);
2329
2330 fclose (fp);
2331
2332 unlink (old_hashfile);
2333
2334 if (rename (hashfile, old_hashfile) != 0)
2335 {
2336 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2337
2338 exit (-1);
2339 }
2340
2341 unlink (hashfile);
2342
2343 if (rename (new_hashfile, hashfile) != 0)
2344 {
2345 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2346
2347 exit (-1);
2348 }
2349
2350 unlink (old_hashfile);
2351 }
2352
2353 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2354 {
2355 // function called only in case kernel_blocks_all > words_left)
2356
2357 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2358
2359 kernel_blocks_div += kernel_blocks_div / 100;
2360
2361 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2362
2363 while (kernel_blocks_new < total_left)
2364 {
2365 kernel_blocks_div += kernel_blocks_div / 100;
2366
2367 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2368 }
2369
2370 if (data.quiet == 0)
2371 {
2372 clear_prompt ();
2373
2374 log_info ("");
2375
2376 log_info ("INFO: approaching final keyspace, workload adjusted");
2377
2378 log_info ("");
2379
2380 fprintf (stdout, "%s", PROMPT);
2381
2382 fflush (stdout);
2383 }
2384
2385 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2386
2387 return kernel_blocks_div;
2388 }
2389
2390 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2391 {
2392 uint num_elements = num;
2393
2394 device_param->kernel_params_buf32[30] = data.combs_mode;
2395 device_param->kernel_params_buf32[31] = num;
2396
2397 uint kernel_threads = device_param->kernel_threads;
2398
2399 while (num_elements % kernel_threads) num_elements++;
2400
2401 cl_kernel kernel = NULL;
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_1: kernel = device_param->kernel1; break;
2406 case KERN_RUN_12: kernel = device_param->kernel12; break;
2407 case KERN_RUN_2: kernel = device_param->kernel2; break;
2408 case KERN_RUN_23: kernel = device_param->kernel23; break;
2409 case KERN_RUN_3: kernel = device_param->kernel3; break;
2410 }
2411
2412 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2413 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2414 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2415 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2416 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2417 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2418 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2419 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2420 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2421 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2422 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2423
2424 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2425 {
2426 const size_t global_work_size[3] = { num_elements, 32, 1 };
2427 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2428
2429 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2430 }
2431 else
2432 {
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 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);
2437
2438 if (rc != CL_SUCCESS)
2439 {
2440 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2443 }
2444 }
2445
2446 hc_clFlush (data.ocl, device_param->command_queue);
2447
2448 hc_clFinish (data.ocl, device_param->command_queue);
2449 }
2450
2451 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2452 {
2453 uint num_elements = num;
2454
2455 switch (kern_run)
2456 {
2457 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2458 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2459 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2460 }
2461
2462 // causes problems with special threads like in bcrypt
2463 // const uint kernel_threads = device_param->kernel_threads;
2464
2465 const uint kernel_threads = KERNEL_THREADS;
2466
2467 while (num_elements % kernel_threads) num_elements++;
2468
2469 cl_kernel kernel = NULL;
2470
2471 switch (kern_run)
2472 {
2473 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2474 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2475 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2476 }
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2481 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2482 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2483 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2484 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2485 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2486 break;
2487 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2493 break;
2494 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2495 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2496 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2497 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2498 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2499 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2500 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2501 break;
2502 }
2503
2504 const size_t global_work_size[3] = { num_elements, 1, 1 };
2505 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2506
2507 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);
2508
2509 if (rc != CL_SUCCESS)
2510 {
2511 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2512
2513 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2514 }
2515
2516 hc_clFlush (data.ocl, device_param->command_queue);
2517
2518 hc_clFinish (data.ocl, device_param->command_queue);
2519 }
2520
2521 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2522 {
2523 uint num_elements = num;
2524
2525 uint kernel_threads = device_param->kernel_threads;
2526
2527 while (num_elements % kernel_threads) num_elements++;
2528
2529 cl_kernel kernel = device_param->kernel_tb;
2530
2531 const size_t global_work_size[3] = { num_elements, 1, 1 };
2532 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2533
2534 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2535
2536 hc_clFlush (data.ocl, device_param->command_queue);
2537
2538 hc_clFinish (data.ocl, device_param->command_queue);
2539 }
2540
2541 static void run_kernel_tm (hc_device_param_t *device_param)
2542 {
2543 const uint num_elements = 1024; // fixed
2544
2545 const uint kernel_threads = 32;
2546
2547 cl_kernel kernel = device_param->kernel_tm;
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2553
2554 hc_clFlush (data.ocl, device_param->command_queue);
2555
2556 hc_clFinish (data.ocl, device_param->command_queue);
2557 }
2558
2559 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2560 {
2561 uint num_elements = num;
2562
2563 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2564 device_param->kernel_params_amp_buf32[6] = num_elements;
2565
2566 // causes problems with special threads like in bcrypt
2567 // const uint kernel_threads = device_param->kernel_threads;
2568
2569 const uint kernel_threads = KERNEL_THREADS;
2570
2571 while (num_elements % kernel_threads) num_elements++;
2572
2573 cl_kernel kernel = device_param->kernel_amp;
2574
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2589 {
2590 if (device_param->vendor_id == VENDOR_ID_AMD)
2591 {
2592 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2593
2594 const cl_uchar zero = 0;
2595
2596 hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2597 }
2598 else
2599 {
2600 // NOTE: clEnqueueFillBuffer () always fails with -59
2601 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2602 // How's that possible, OpenCL 1.2 support is advertised??
2603 // We need to workaround...
2604
2605 #define FILLSZ 0x100000
2606
2607 char *tmp = (char *) mymalloc (FILLSZ);
2608
2609 for (uint i = 0; i < size; i += FILLSZ)
2610 {
2611 const int left = size - i;
2612
2613 const int fillsz = MIN (FILLSZ, left);
2614
2615 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2616 }
2617
2618 myfree (tmp);
2619 }
2620 }
2621
2622 static int run_rule_engine (const int rule_len, const char *rule_buf)
2623 {
2624 if (rule_len == 0)
2625 {
2626 return 0;
2627 }
2628 else if (rule_len == 1)
2629 {
2630 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2631 }
2632
2633 return 1;
2634 }
2635
2636 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2637 {
2638 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2639 {
2640 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);
2641 }
2642 else if (data.attack_kern == ATTACK_KERN_COMBI)
2643 {
2644 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);
2645 }
2646 else if (data.attack_kern == ATTACK_KERN_BF)
2647 {
2648 const u64 off = device_param->words_off;
2649
2650 device_param->kernel_params_mp_l_buf64[3] = off;
2651
2652 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2653 }
2654 }
2655
2656 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2657 {
2658 const uint kernel_loops = data.kernel_loops;
2659
2660 // init speed timer
2661
2662 uint speed_pos = device_param->speed_pos;
2663
2664 #ifdef _POSIX
2665 if (device_param->timer_speed.tv_sec == 0)
2666 {
2667 hc_timer_set (&device_param->timer_speed);
2668 }
2669 #endif
2670
2671 #ifdef _WIN
2672 if (device_param->timer_speed.QuadPart == 0)
2673 {
2674 hc_timer_set (&device_param->timer_speed);
2675 }
2676 #endif
2677
2678 // find higest password length, this is for optimization stuff
2679
2680 uint highest_pw_len = 0;
2681
2682 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2683 {
2684 }
2685 else if (data.attack_kern == ATTACK_KERN_COMBI)
2686 {
2687 }
2688 else if (data.attack_kern == ATTACK_KERN_BF)
2689 {
2690 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2691 + device_param->kernel_params_mp_l_buf32[5];
2692 }
2693
2694 // bitslice optimization stuff
2695
2696 if (data.attack_mode == ATTACK_MODE_BF)
2697 {
2698 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2699 {
2700 run_kernel_tb (device_param, pws_cnt);
2701 }
2702 }
2703
2704 // iteration type
2705
2706 uint innerloop_step = 0;
2707 uint innerloop_cnt = 0;
2708
2709 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2710 else innerloop_step = 1;
2711
2712 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2713 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2714 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2715
2716 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2717
2718 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2719 {
2720 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2721
2722 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2723
2724 if (data.devices_status == STATUS_CRACKED) break;
2725 if (data.devices_status == STATUS_ABORTED) break;
2726 if (data.devices_status == STATUS_QUIT) break;
2727 if (data.devices_status == STATUS_BYPASS) break;
2728
2729 if (data.salts_shown[salt_pos] == 1) continue;
2730
2731 salt_t *salt_buf = &data.salts_buf[salt_pos];
2732
2733 device_param->kernel_params_buf32[24] = salt_pos;
2734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2736
2737 FILE *combs_fp = device_param->combs_fp;
2738
2739 if (data.attack_mode == ATTACK_MODE_COMBI)
2740 {
2741 rewind (combs_fp);
2742 }
2743
2744 // innerloops
2745
2746 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2747 {
2748 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2749
2750 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2751
2752 if (data.devices_status == STATUS_CRACKED) break;
2753 if (data.devices_status == STATUS_ABORTED) break;
2754 if (data.devices_status == STATUS_QUIT) break;
2755 if (data.devices_status == STATUS_BYPASS) break;
2756
2757 uint innerloop_left = innerloop_cnt - innerloop_pos;
2758
2759 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2760
2761 device_param->innerloop_pos = innerloop_pos;
2762 device_param->innerloop_left = innerloop_left;
2763
2764 device_param->kernel_params_buf32[27] = innerloop_left;
2765
2766 if (innerloop_left == 0) continue;
2767
2768 // initialize amplifiers
2769
2770 if (data.attack_mode == ATTACK_MODE_COMBI)
2771 {
2772 char line_buf[BUFSIZ] = { 0 };
2773
2774 uint i = 0;
2775
2776 while (i < innerloop_left)
2777 {
2778 if (feof (combs_fp)) break;
2779
2780 int line_len = fgetl (combs_fp, line_buf);
2781
2782 if (line_len >= PW_MAX1) continue;
2783
2784 line_len = convert_from_hex (line_buf, line_len);
2785
2786 char *line_buf_new = line_buf;
2787
2788 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2789 {
2790 char rule_buf_out[BLOCK_SIZE] = { 0 };
2791
2792 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2793
2794 if (rule_len_out < 0)
2795 {
2796 data.words_progress_rejected[salt_pos] += pw_cnt;
2797
2798 continue;
2799 }
2800
2801 line_len = rule_len_out;
2802
2803 line_buf_new = rule_buf_out;
2804 }
2805
2806 line_len = MIN (line_len, PW_DICTMAX);
2807
2808 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2809
2810 memcpy (ptr, line_buf_new, line_len);
2811
2812 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2813
2814 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2815 {
2816 uppercase (ptr, line_len);
2817 }
2818
2819 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2820 {
2821 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2822 {
2823 ptr[line_len] = 0x80;
2824 }
2825
2826 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2827 {
2828 ptr[line_len] = 0x01;
2829 }
2830 }
2831
2832 device_param->combs_buf[i].pw_len = line_len;
2833
2834 i++;
2835 }
2836
2837 for (uint j = i; j < innerloop_left; j++)
2838 {
2839 device_param->combs_buf[j].i[0] = 0;
2840 device_param->combs_buf[j].i[1] = 0;
2841 device_param->combs_buf[j].i[2] = 0;
2842 device_param->combs_buf[j].i[3] = 0;
2843 device_param->combs_buf[j].i[4] = 0;
2844 device_param->combs_buf[j].i[5] = 0;
2845 device_param->combs_buf[j].i[6] = 0;
2846 device_param->combs_buf[j].i[7] = 0;
2847
2848 device_param->combs_buf[j].pw_len = 0;
2849 }
2850
2851 innerloop_left = i;
2852 }
2853 else if (data.attack_mode == ATTACK_MODE_BF)
2854 {
2855 u64 off = innerloop_pos;
2856
2857 device_param->kernel_params_mp_r_buf64[3] = off;
2858
2859 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2860 }
2861 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2862 {
2863 u64 off = innerloop_pos;
2864
2865 device_param->kernel_params_mp_buf64[3] = off;
2866
2867 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2868 }
2869 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2870 {
2871 u64 off = innerloop_pos;
2872
2873 device_param->kernel_params_mp_buf64[3] = off;
2874
2875 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2876 }
2877
2878 // copy amplifiers
2879
2880 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2881 {
2882 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);
2883 }
2884 else if (data.attack_mode == ATTACK_MODE_COMBI)
2885 {
2886 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);
2887 }
2888 else if (data.attack_mode == ATTACK_MODE_BF)
2889 {
2890 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);
2891 }
2892 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2893 {
2894 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);
2895 }
2896 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2897 {
2898 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);
2899 }
2900
2901 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2902 {
2903 if (data.attack_mode == ATTACK_MODE_BF)
2904 {
2905 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2906 {
2907 const uint size_tm = 32 * sizeof (bs_word_t);
2908
2909 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2910
2911 run_kernel_tm (device_param);
2912
2913 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);
2914 }
2915 }
2916
2917 if (highest_pw_len < 16)
2918 {
2919 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2920 }
2921 else if (highest_pw_len < 32)
2922 {
2923 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2924 }
2925 else
2926 {
2927 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2928 }
2929 }
2930 else
2931 {
2932 run_kernel_amp (device_param, pws_cnt);
2933
2934 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2935
2936 if (data.opts_type & OPTS_TYPE_HOOK12)
2937 {
2938 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2939 }
2940
2941 uint iter = salt_buf->salt_iter;
2942
2943 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2944 {
2945 uint loop_left = iter - loop_pos;
2946
2947 loop_left = MIN (loop_left, kernel_loops);
2948
2949 device_param->kernel_params_buf32[25] = loop_pos;
2950 device_param->kernel_params_buf32[26] = loop_left;
2951
2952 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2953
2954 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2955
2956 if (data.devices_status == STATUS_CRACKED) break;
2957 if (data.devices_status == STATUS_ABORTED) break;
2958 if (data.devices_status == STATUS_QUIT) break;
2959 }
2960
2961 if (data.opts_type & OPTS_TYPE_HOOK23)
2962 {
2963 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2964
2965 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);
2966
2967 // do something with data
2968
2969 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);
2970 }
2971
2972 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2973 }
2974
2975 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2976
2977 if (data.devices_status == STATUS_CRACKED) break;
2978 if (data.devices_status == STATUS_ABORTED) break;
2979 if (data.devices_status == STATUS_QUIT) break;
2980
2981 /**
2982 * result
2983 */
2984
2985 hc_thread_mutex_lock (mux_display);
2986
2987 check_cracked (device_param, salt_pos);
2988
2989 hc_thread_mutex_unlock (mux_display);
2990
2991 /**
2992 * progress
2993 */
2994
2995 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2996
2997 hc_thread_mutex_lock (mux_counter);
2998
2999 data.words_progress_done[salt_pos] += perf_sum_all;
3000
3001 hc_thread_mutex_unlock (mux_counter);
3002
3003 /**
3004 * speed
3005 */
3006
3007 float speed_ms;
3008
3009 hc_timer_get (device_param->timer_speed, speed_ms);
3010
3011 hc_timer_set (&device_param->timer_speed);
3012
3013 hc_thread_mutex_lock (mux_display);
3014
3015 device_param->speed_cnt[speed_pos] = perf_sum_all;
3016
3017 device_param->speed_ms[speed_pos] = speed_ms;
3018
3019 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3020
3021 hc_thread_mutex_unlock (mux_display);
3022
3023 speed_pos++;
3024
3025 if (speed_pos == SPEED_CACHE)
3026 {
3027 speed_pos = 0;
3028 }
3029 }
3030 }
3031
3032 device_param->speed_pos = speed_pos;
3033 }
3034
3035 static void load_segment (wl_data_t *wl_data, FILE *fd)
3036 {
3037 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3038
3039 wl_data->pos = 0;
3040
3041 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3042
3043 wl_data->buf[wl_data->cnt] = 0;
3044
3045 if (wl_data->cnt == 0) return;
3046
3047 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3048
3049 while (!feof (fd))
3050 {
3051 if (wl_data->cnt == wl_data->avail)
3052 {
3053 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3054
3055 wl_data->avail += wl_data->incr;
3056 }
3057
3058 const int c = fgetc (fd);
3059
3060 if (c == EOF) break;
3061
3062 wl_data->buf[wl_data->cnt] = (char) c;
3063
3064 wl_data->cnt++;
3065
3066 if (c == '\n') break;
3067 }
3068
3069 // ensure stream ends with a newline
3070
3071 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3072 {
3073 wl_data->cnt++;
3074
3075 wl_data->buf[wl_data->cnt - 1] = '\n';
3076 }
3077
3078 return;
3079 }
3080
3081 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3082 {
3083 char *ptr = buf;
3084
3085 for (u32 i = 0; i < sz; i++, ptr++)
3086 {
3087 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3088
3089 if (i == 7)
3090 {
3091 *off = i;
3092 *len = i;
3093
3094 return;
3095 }
3096
3097 if (*ptr != '\n') continue;
3098
3099 *off = i + 1;
3100
3101 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3102
3103 *len = i;
3104
3105 return;
3106 }
3107
3108 *off = sz;
3109 *len = sz;
3110 }
3111
3112 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3113 {
3114 char *ptr = buf;
3115
3116 for (u32 i = 0; i < sz; i++, ptr++)
3117 {
3118 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3119
3120 if (*ptr != '\n') continue;
3121
3122 *off = i + 1;
3123
3124 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3125
3126 *len = i;
3127
3128 return;
3129 }
3130
3131 *off = sz;
3132 *len = sz;
3133 }
3134
3135 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3136 {
3137 char *ptr = buf;
3138
3139 for (u32 i = 0; i < sz; i++, ptr++)
3140 {
3141 if (*ptr != '\n') continue;
3142
3143 *off = i + 1;
3144
3145 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3146
3147 *len = i;
3148
3149 return;
3150 }
3151
3152 *off = sz;
3153 *len = sz;
3154 }
3155
3156 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3157 {
3158 while (wl_data->pos < wl_data->cnt)
3159 {
3160 uint off;
3161 uint len;
3162
3163 char *ptr = wl_data->buf + wl_data->pos;
3164
3165 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3166
3167 wl_data->pos += off;
3168
3169 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3170 {
3171 char rule_buf_out[BLOCK_SIZE] = { 0 };
3172
3173 int rule_len_out = -1;
3174
3175 if (len < BLOCK_SIZE)
3176 {
3177 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3178 }
3179
3180 if (rule_len_out < 0)
3181 {
3182 continue;
3183 }
3184
3185 if (rule_len_out > PW_MAX)
3186 {
3187 continue;
3188 }
3189 }
3190 else
3191 {
3192 if (len > PW_MAX)
3193 {
3194 continue;
3195 }
3196 }
3197
3198 *out_buf = ptr;
3199 *out_len = len;
3200
3201 return;
3202 }
3203
3204 if (feof (fd))
3205 {
3206 fprintf (stderr, "bug!!\n");
3207
3208 return;
3209 }
3210
3211 load_segment (wl_data, fd);
3212
3213 get_next_word (wl_data, fd, out_buf, out_len);
3214 }
3215
3216 #ifdef _POSIX
3217 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3218 #endif
3219
3220 #ifdef _WIN
3221 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3222 #endif
3223 {
3224 hc_signal (NULL);
3225
3226 dictstat_t d;
3227
3228 d.cnt = 0;
3229
3230 #ifdef _POSIX
3231 fstat (fileno (fd), &d.stat);
3232 #endif
3233
3234 #ifdef _WIN
3235 _fstat64 (fileno (fd), &d.stat);
3236 #endif
3237
3238 d.stat.st_mode = 0;
3239 d.stat.st_nlink = 0;
3240 d.stat.st_uid = 0;
3241 d.stat.st_gid = 0;
3242 d.stat.st_rdev = 0;
3243 d.stat.st_atime = 0;
3244
3245 #ifdef _POSIX
3246 d.stat.st_blksize = 0;
3247 d.stat.st_blocks = 0;
3248 #endif
3249
3250 if (d.stat.st_size == 0) return 0;
3251
3252 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3253
3254 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3255 {
3256 if (d_cache)
3257 {
3258 u64 cnt = d_cache->cnt;
3259
3260 u64 keyspace = cnt;
3261
3262 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3263 {
3264 keyspace *= data.kernel_rules_cnt;
3265 }
3266 else if (data.attack_kern == ATTACK_KERN_COMBI)
3267 {
3268 keyspace *= data.combs_cnt;
3269 }
3270
3271 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);
3272 if (data.quiet == 0) log_info ("");
3273
3274 hc_signal (sigHandler_default);
3275
3276 return (keyspace);
3277 }
3278 }
3279
3280 time_t now = 0;
3281 time_t prev = 0;
3282
3283 u64 comp = 0;
3284 u64 cnt = 0;
3285 u64 cnt2 = 0;
3286
3287 while (!feof (fd))
3288 {
3289 load_segment (wl_data, fd);
3290
3291 comp += wl_data->cnt;
3292
3293 u32 i = 0;
3294
3295 while (i < wl_data->cnt)
3296 {
3297 u32 len;
3298 u32 off;
3299
3300 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3301
3302 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3303 {
3304 char rule_buf_out[BLOCK_SIZE] = { 0 };
3305
3306 int rule_len_out = -1;
3307
3308 if (len < BLOCK_SIZE)
3309 {
3310 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3311 }
3312
3313 if (rule_len_out < 0)
3314 {
3315 len = PW_MAX1;
3316 }
3317 else
3318 {
3319 len = rule_len_out;
3320 }
3321 }
3322
3323 if (len < PW_MAX1)
3324 {
3325 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3326 {
3327 cnt += data.kernel_rules_cnt;
3328 }
3329 else if (data.attack_kern == ATTACK_KERN_COMBI)
3330 {
3331 cnt += data.combs_cnt;
3332 }
3333
3334 d.cnt++;
3335 }
3336
3337 i += off;
3338
3339 cnt2++;
3340 }
3341
3342 time (&now);
3343
3344 if ((now - prev) == 0) continue;
3345
3346 float percent = (float) comp / (float) d.stat.st_size;
3347
3348 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);
3349
3350 time (&prev);
3351 }
3352
3353 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);
3354 if (data.quiet == 0) log_info ("");
3355
3356 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3357
3358 hc_signal (sigHandler_default);
3359
3360 return (cnt);
3361 }
3362
3363 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3364 {
3365 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3366 }
3367
3368 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3369 {
3370 if (data.devices_status == STATUS_BYPASS) return 0;
3371
3372 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3373
3374 uint cache_cnt = pw_cache->cnt;
3375
3376 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3377
3378 memcpy (pw_hc1, pw_buf, pw_len);
3379
3380 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3381
3382 uint pws_cnt = device_param->pws_cnt;
3383
3384 cache_cnt++;
3385
3386 pw_t *pw = device_param->pws_buf + pws_cnt;
3387
3388 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3389
3390 pw->pw_len = pw_len;
3391
3392 pws_cnt++;
3393
3394 device_param->pws_cnt = pws_cnt;
3395 device_param->pw_cnt = pws_cnt * 1;
3396
3397 cache_cnt = 0;
3398
3399 pw_cache->cnt = cache_cnt;
3400
3401 return pws_cnt;
3402 }
3403
3404 static void *thread_monitor (void *p)
3405 {
3406 uint runtime_check = 0;
3407 uint remove_check = 0;
3408 uint status_check = 0;
3409 uint restore_check = 0;
3410
3411 uint restore_left = data.restore_timer;
3412 uint remove_left = data.remove_timer;
3413 uint status_left = data.status_timer;
3414
3415 #ifdef HAVE_HWMON
3416 uint hwmon_check = 0;
3417
3418 // these variables are mainly used for fan control (AMD only)
3419
3420 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3421
3422 // temperature controller "loopback" values
3423
3424 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3425 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3426
3427 #ifdef HAVE_ADL
3428 int temp_threshold = 1; // degrees celcius
3429
3430 int fan_speed_min = 15; // in percentage
3431 int fan_speed_max = 100;
3432 #endif // HAVE_ADL
3433
3434 time_t last_temp_check_time;
3435 #endif // HAVE_HWMON
3436
3437 uint sleep_time = 1;
3438
3439 if (data.runtime)
3440 {
3441 runtime_check = 1;
3442 }
3443
3444 if (data.restore_timer)
3445 {
3446 restore_check = 1;
3447 }
3448
3449 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3450 {
3451 remove_check = 1;
3452 }
3453
3454 if (data.status == 1)
3455 {
3456 status_check = 1;
3457 }
3458
3459 #ifdef HAVE_HWMON
3460 if (data.gpu_temp_disable == 0)
3461 {
3462 time (&last_temp_check_time);
3463
3464 hwmon_check = 1;
3465 }
3466 #endif
3467
3468 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3469 {
3470 #ifdef HAVE_HWMON
3471 if (hwmon_check == 0)
3472 #endif
3473 return (p);
3474 }
3475
3476 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3477 {
3478 hc_sleep (sleep_time);
3479
3480 if (data.devices_status != STATUS_RUNNING) continue;
3481
3482 #ifdef HAVE_HWMON
3483 if (hwmon_check == 1)
3484 {
3485 hc_thread_mutex_lock (mux_adl);
3486
3487 time_t temp_check_time;
3488
3489 time (&temp_check_time);
3490
3491 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3492
3493 if (Ta == 0) Ta = 1;
3494
3495 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3496 {
3497 hc_device_param_t *device_param = &data.devices_param[device_id];
3498
3499 if (device_param->skipped) continue;
3500
3501 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3502
3503 const int temperature = hm_get_temperature_with_device_id (device_id);
3504
3505 if (temperature > (int) data.gpu_temp_abort)
3506 {
3507 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3508
3509 if (data.devices_status != STATUS_QUIT) myabort ();
3510
3511 break;
3512 }
3513
3514 #ifdef HAVE_ADL
3515 const int gpu_temp_retain = data.gpu_temp_retain;
3516
3517 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3518 {
3519 if (data.hm_device[device_id].fan_supported == 1)
3520 {
3521 int temp_cur = temperature;
3522
3523 int temp_diff_new = gpu_temp_retain - temp_cur;
3524
3525 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3526
3527 // calculate Ta value (time difference in seconds between the last check and this check)
3528
3529 last_temp_check_time = temp_check_time;
3530
3531 float Kp = 1.8;
3532 float Ki = 0.005;
3533 float Kd = 6;
3534
3535 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3536
3537 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);
3538
3539 if (abs (fan_diff_required) >= temp_threshold)
3540 {
3541 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3542
3543 int fan_speed_level = fan_speed_cur;
3544
3545 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3546
3547 int fan_speed_new = fan_speed_level - fan_diff_required;
3548
3549 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3550 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3551
3552 if (fan_speed_new != fan_speed_cur)
3553 {
3554 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3555 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3556
3557 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3558 {
3559 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3560
3561 fan_speed_chgd[device_id] = 1;
3562 }
3563
3564 temp_diff_old[device_id] = temp_diff_new;
3565 }
3566 }
3567 }
3568 }
3569 #endif // HAVE_ADL
3570 }
3571
3572 hc_thread_mutex_unlock (mux_adl);
3573 }
3574 #endif // HAVE_HWMON
3575
3576 if (restore_check == 1)
3577 {
3578 restore_left--;
3579
3580 if (restore_left == 0)
3581 {
3582 if (data.restore_disable == 0) cycle_restore ();
3583
3584 restore_left = data.restore_timer;
3585 }
3586 }
3587
3588 if ((runtime_check == 1) && (data.runtime_start > 0))
3589 {
3590 time_t runtime_cur;
3591
3592 time (&runtime_cur);
3593
3594 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3595
3596 if (runtime_left <= 0)
3597 {
3598 if (data.benchmark == 0)
3599 {
3600 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3601 }
3602
3603 if (data.devices_status != STATUS_QUIT) myabort ();
3604 }
3605 }
3606
3607 if (remove_check == 1)
3608 {
3609 remove_left--;
3610
3611 if (remove_left == 0)
3612 {
3613 if (data.digests_saved != data.digests_done)
3614 {
3615 data.digests_saved = data.digests_done;
3616
3617 save_hash ();
3618 }
3619
3620 remove_left = data.remove_timer;
3621 }
3622 }
3623
3624 if (status_check == 1)
3625 {
3626 status_left--;
3627
3628 if (status_left == 0)
3629 {
3630 hc_thread_mutex_lock (mux_display);
3631
3632 if (data.quiet == 0) clear_prompt ();
3633
3634 if (data.quiet == 0) log_info ("");
3635
3636 status_display ();
3637
3638 if (data.quiet == 0) log_info ("");
3639
3640 hc_thread_mutex_unlock (mux_display);
3641
3642 status_left = data.status_timer;
3643 }
3644 }
3645 }
3646
3647 #ifdef HAVE_HWMON
3648 myfree (fan_speed_chgd);
3649
3650 myfree (temp_diff_old);
3651 myfree (temp_diff_sum);
3652 #endif
3653
3654 p = NULL;
3655
3656 return (p);
3657 }
3658
3659 static void *thread_outfile_remove (void *p)
3660 {
3661 // some hash-dependent constants
3662 char *outfile_dir = data.outfile_check_directory;
3663 uint dgst_size = data.dgst_size;
3664 uint isSalted = data.isSalted;
3665 uint esalt_size = data.esalt_size;
3666 uint hash_mode = data.hash_mode;
3667
3668 uint outfile_check_timer = data.outfile_check_timer;
3669
3670 char separator = data.separator;
3671
3672 // some hash-dependent functions
3673 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3674 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3675
3676 // buffers
3677 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3678
3679 hash_buf.digest = mymalloc (dgst_size);
3680
3681 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3682
3683 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3684
3685 uint digest_buf[64] = { 0 };
3686
3687 outfile_data_t *out_info = NULL;
3688
3689 char **out_files = NULL;
3690
3691 time_t folder_mtime = 0;
3692
3693 int out_cnt = 0;
3694
3695 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3696
3697 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3698 {
3699 hc_sleep (1);
3700
3701 if (data.devices_status != STATUS_RUNNING) continue;
3702
3703 check_left--;
3704
3705 if (check_left == 0)
3706 {
3707 struct stat outfile_check_stat;
3708
3709 if (stat (outfile_dir, &outfile_check_stat) == 0)
3710 {
3711 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3712
3713 if (is_dir == 1)
3714 {
3715 if (outfile_check_stat.st_mtime > folder_mtime)
3716 {
3717 char **out_files_new = scan_directory (outfile_dir);
3718
3719 int out_cnt_new = count_dictionaries (out_files_new);
3720
3721 outfile_data_t *out_info_new = NULL;
3722
3723 if (out_cnt_new > 0)
3724 {
3725 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3726
3727 for (int i = 0; i < out_cnt_new; i++)
3728 {
3729 out_info_new[i].file_name = out_files_new[i];
3730
3731 // check if there are files that we have seen/checked before (and not changed)
3732
3733 for (int j = 0; j < out_cnt; j++)
3734 {
3735 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3736 {
3737 struct stat outfile_stat;
3738
3739 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3740 {
3741 if (outfile_stat.st_ctime == out_info[j].ctime)
3742 {
3743 out_info_new[i].ctime = out_info[j].ctime;
3744 out_info_new[i].seek = out_info[j].seek;
3745 }
3746 }
3747 }
3748 }
3749 }
3750 }
3751
3752 local_free (out_info);
3753 local_free (out_files);
3754
3755 out_files = out_files_new;
3756 out_cnt = out_cnt_new;
3757 out_info = out_info_new;
3758
3759 folder_mtime = outfile_check_stat.st_mtime;
3760 }
3761
3762 for (int j = 0; j < out_cnt; j++)
3763 {
3764 FILE *fp = fopen (out_info[j].file_name, "rb");
3765
3766 if (fp != NULL)
3767 {
3768 //hc_thread_mutex_lock (mux_display);
3769
3770 #ifdef _POSIX
3771 struct stat outfile_stat;
3772
3773 fstat (fileno (fp), &outfile_stat);
3774 #endif
3775
3776 #ifdef _WIN
3777 struct stat64 outfile_stat;
3778
3779 _fstat64 (fileno (fp), &outfile_stat);
3780 #endif
3781
3782 if (outfile_stat.st_ctime > out_info[j].ctime)
3783 {
3784 out_info[j].ctime = outfile_stat.st_ctime;
3785 out_info[j].seek = 0;
3786 }
3787
3788 fseek (fp, out_info[j].seek, SEEK_SET);
3789
3790 while (!feof (fp))
3791 {
3792 char line_buf[BUFSIZ] = { 0 };
3793
3794 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3795
3796 if (ptr == NULL) break;
3797
3798 int line_len = strlen (line_buf);
3799
3800 if (line_len <= 0) continue;
3801
3802 int iter = MAX_CUT_TRIES;
3803
3804 for (uint i = line_len - 1; i && iter; i--, line_len--)
3805 {
3806 if (line_buf[i] != separator) continue;
3807
3808 int parser_status = PARSER_OK;
3809
3810 if ((hash_mode != 2500) && (hash_mode != 6800))
3811 {
3812 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3813 }
3814
3815 uint found = 0;
3816
3817 if (parser_status == PARSER_OK)
3818 {
3819 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3820 {
3821 if (data.salts_shown[salt_pos] == 1) continue;
3822
3823 salt_t *salt_buf = &data.salts_buf[salt_pos];
3824
3825 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3826 {
3827 uint idx = salt_buf->digests_offset + digest_pos;
3828
3829 if (data.digests_shown[idx] == 1) continue;
3830
3831 uint cracked = 0;
3832
3833 if (hash_mode == 6800)
3834 {
3835 if (i == salt_buf->salt_len)
3836 {
3837 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3838 }
3839 }
3840 else if (hash_mode == 2500)
3841 {
3842 // BSSID : MAC1 : MAC2 (:plain)
3843 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3844 {
3845 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3846
3847 if (!cracked) continue;
3848
3849 // now compare MAC1 and MAC2 too, since we have this additional info
3850 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3851 char *mac2_pos = mac1_pos + 12 + 1;
3852
3853 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3854 wpa_t *wpa = &wpas[salt_pos];
3855
3856 uint pke[25] = { 0 };
3857
3858 char *pke_ptr = (char *) pke;
3859
3860 for (uint i = 0; i < 25; i++)
3861 {
3862 pke[i] = byte_swap_32 (wpa->pke[i]);
3863 }
3864
3865 u8 mac1[6] = { 0 };
3866 u8 mac2[6] = { 0 };
3867
3868 memcpy (mac1, pke_ptr + 23, 6);
3869 memcpy (mac2, pke_ptr + 29, 6);
3870
3871 // compare hex string(s) vs binary MAC address(es)
3872
3873 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3874 {
3875 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3876 {
3877 cracked = 0;
3878 break;
3879 }
3880 }
3881
3882 // early skip ;)
3883 if (!cracked) continue;
3884
3885 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3886 {
3887 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3888 {
3889 cracked = 0;
3890 break;
3891 }
3892 }
3893 }
3894 }
3895 else
3896 {
3897 char *digests_buf_ptr = (char *) data.digests_buf;
3898
3899 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3900
3901 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3902 }
3903
3904 if (cracked == 1)
3905 {
3906 found = 1;
3907
3908 data.digests_shown[idx] = 1;
3909
3910 data.digests_done++;
3911
3912 salt_buf->digests_done++;
3913
3914 if (salt_buf->digests_done == salt_buf->digests_cnt)
3915 {
3916 data.salts_shown[salt_pos] = 1;
3917
3918 data.salts_done++;
3919
3920 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3921 }
3922 }
3923 }
3924
3925 if (data.devices_status == STATUS_CRACKED) break;
3926 }
3927 }
3928
3929 if (found) break;
3930
3931 if (data.devices_status == STATUS_CRACKED) break;
3932
3933 iter--;
3934 }
3935
3936 if (data.devices_status == STATUS_CRACKED) break;
3937 }
3938
3939 out_info[j].seek = ftell (fp);
3940
3941 //hc_thread_mutex_unlock (mux_display);
3942
3943 fclose (fp);
3944 }
3945 }
3946 }
3947 }
3948
3949 check_left = outfile_check_timer;
3950 }
3951 }
3952
3953 if (esalt_size) local_free (hash_buf.esalt);
3954
3955 if (isSalted) local_free (hash_buf.salt);
3956
3957 local_free (hash_buf.digest);
3958
3959 local_free (out_info);
3960
3961 local_free (out_files);
3962
3963 p = NULL;
3964
3965 return (p);
3966 }
3967
3968 static uint get_work (hc_device_param_t *device_param, const u64 max)
3969 {
3970 hc_thread_mutex_lock (mux_dispatcher);
3971
3972 const u64 words_cur = data.words_cur;
3973 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3974
3975 device_param->words_off = words_cur;
3976
3977 const u64 words_left = words_base - words_cur;
3978
3979 if (data.kernel_blocks_all > words_left)
3980 {
3981 if (data.kernel_blocks_div == 0)
3982 {
3983 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3984 }
3985 }
3986
3987 if (data.kernel_blocks_div)
3988 {
3989 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3990 {
3991 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3992 const u32 kernel_power_new = kernel_blocks_new;
3993
3994 if (kernel_blocks_new < device_param->kernel_blocks)
3995 {
3996 device_param->kernel_blocks = kernel_blocks_new;
3997 device_param->kernel_power = kernel_power_new;
3998 }
3999 }
4000 }
4001
4002 const uint kernel_blocks = device_param->kernel_blocks;
4003
4004 uint work = MIN (words_left, kernel_blocks);
4005
4006 work = MIN (work, max);
4007
4008 data.words_cur += work;
4009
4010 hc_thread_mutex_unlock (mux_dispatcher);
4011
4012 return work;
4013 }
4014
4015 static void *thread_calc_stdin (void *p)
4016 {
4017 hc_device_param_t *device_param = (hc_device_param_t *) p;
4018
4019 if (device_param->skipped) return NULL;
4020
4021 const uint attack_kern = data.attack_kern;
4022
4023 const uint kernel_blocks = device_param->kernel_blocks;
4024
4025 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4026 {
4027 hc_thread_mutex_lock (mux_dispatcher);
4028
4029 if (feof (stdin) != 0)
4030 {
4031 hc_thread_mutex_unlock (mux_dispatcher);
4032
4033 break;
4034 }
4035
4036 uint words_cur = 0;
4037
4038 while (words_cur < kernel_blocks)
4039 {
4040 char buf[BUFSIZ] = { 0 };
4041
4042 char *line_buf = fgets (buf, sizeof (buf), stdin);
4043
4044 if (line_buf == NULL) break;
4045
4046 uint line_len = in_superchop (line_buf);
4047
4048 line_len = convert_from_hex (line_buf, line_len);
4049
4050 // post-process rule engine
4051
4052 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4053 {
4054 char rule_buf_out[BLOCK_SIZE] = { 0 };
4055
4056 int rule_len_out = -1;
4057
4058 if (line_len < BLOCK_SIZE)
4059 {
4060 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4061 }
4062
4063 if (rule_len_out < 0) continue;
4064
4065 line_buf = rule_buf_out;
4066 line_len = rule_len_out;
4067 }
4068
4069 if (line_len > PW_MAX)
4070 {
4071 continue;
4072 }
4073
4074 if (attack_kern == ATTACK_KERN_STRAIGHT)
4075 {
4076 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4077 {
4078 hc_thread_mutex_lock (mux_counter);
4079
4080 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4081 {
4082 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4083 }
4084
4085 hc_thread_mutex_unlock (mux_counter);
4086
4087 continue;
4088 }
4089 }
4090 else if (attack_kern == ATTACK_KERN_COMBI)
4091 {
4092 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4093 // since we still need to combine the plains
4094
4095 if (line_len > data.pw_max)
4096 {
4097 hc_thread_mutex_lock (mux_counter);
4098
4099 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4100 {
4101 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4102 }
4103
4104 hc_thread_mutex_unlock (mux_counter);
4105
4106 continue;
4107 }
4108 }
4109
4110 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4111
4112 words_cur++;
4113
4114 if (data.devices_status == STATUS_CRACKED) break;
4115 if (data.devices_status == STATUS_ABORTED) break;
4116 if (data.devices_status == STATUS_QUIT) break;
4117 if (data.devices_status == STATUS_BYPASS) break;
4118 }
4119
4120 hc_thread_mutex_unlock (mux_dispatcher);
4121
4122 if (data.devices_status == STATUS_CRACKED) break;
4123 if (data.devices_status == STATUS_ABORTED) break;
4124 if (data.devices_status == STATUS_QUIT) break;
4125 if (data.devices_status == STATUS_BYPASS) break;
4126
4127 // we need 2 flushing because we have two independant caches and it can occur
4128 // that one buffer is already at threshold plus for that length also exists
4129 // more data in the 2nd buffer so it would overflow
4130
4131 // flush session 1
4132
4133 {
4134 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4135 {
4136 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4137
4138 const uint pw_cache_cnt = pw_cache->cnt;
4139
4140 if (pw_cache_cnt == 0) continue;
4141
4142 pw_cache->cnt = 0;
4143
4144 uint pws_cnt = device_param->pws_cnt;
4145
4146 pw_t *pw = device_param->pws_buf + pws_cnt;
4147
4148 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4149
4150 pw->pw_len = pw_len;
4151
4152 uint pw_cnt = device_param->pw_cnt;
4153
4154 pw_cnt += pw_cache_cnt;
4155
4156 device_param->pw_cnt = pw_cnt;
4157
4158 pws_cnt++;
4159
4160 device_param->pws_cnt = pws_cnt;
4161
4162 if (pws_cnt == device_param->kernel_power_user) break;
4163 }
4164
4165 const uint pw_cnt = device_param->pw_cnt;
4166 const uint pws_cnt = device_param->pws_cnt;
4167
4168 if (pws_cnt)
4169 {
4170 run_copy (device_param, pws_cnt);
4171
4172 run_cracker (device_param, pw_cnt, pws_cnt);
4173
4174 device_param->pw_cnt = 0;
4175 device_param->pws_cnt = 0;
4176 }
4177 }
4178
4179 // flush session 2
4180
4181 {
4182 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4183 {
4184 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4185
4186 const uint pw_cache_cnt = pw_cache->cnt;
4187
4188 if (pw_cache_cnt == 0) continue;
4189
4190 pw_cache->cnt = 0;
4191
4192 uint pws_cnt = device_param->pws_cnt;
4193
4194 pw_t *pw = device_param->pws_buf + pws_cnt;
4195
4196 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4197
4198 pw->pw_len = pw_len;
4199
4200 uint pw_cnt = device_param->pw_cnt;
4201
4202 pw_cnt += pw_cache_cnt;
4203
4204 device_param->pw_cnt = pw_cnt;
4205
4206 pws_cnt++;
4207
4208 device_param->pws_cnt = pws_cnt;
4209 }
4210
4211 const uint pw_cnt = device_param->pw_cnt;
4212 const uint pws_cnt = device_param->pws_cnt;
4213
4214 if (pws_cnt)
4215 {
4216 run_copy (device_param, pws_cnt);
4217
4218 run_cracker (device_param, pw_cnt, pws_cnt);
4219
4220 device_param->pw_cnt = 0;
4221 device_param->pws_cnt = 0;
4222 }
4223 }
4224 }
4225
4226 return NULL;
4227 }
4228
4229 static void *thread_calc (void *p)
4230 {
4231 hc_device_param_t *device_param = (hc_device_param_t *) p;
4232
4233 if (device_param->skipped) return NULL;
4234
4235 const uint attack_mode = data.attack_mode;
4236 const uint attack_kern = data.attack_kern;
4237
4238 if (attack_mode == ATTACK_MODE_BF)
4239 {
4240 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4241 {
4242 const uint work = get_work (device_param, -1);
4243
4244 if (work == 0) break;
4245
4246 const u64 words_off = device_param->words_off;
4247 const u64 words_fin = words_off + work;
4248
4249 const uint pw_cnt = work;
4250 const uint pws_cnt = work;
4251
4252 device_param->pw_cnt = pw_cnt;
4253 device_param->pws_cnt = pws_cnt;
4254
4255 if (pws_cnt)
4256 {
4257 run_copy (device_param, pws_cnt);
4258
4259 run_cracker (device_param, pw_cnt, pws_cnt);
4260
4261 device_param->pw_cnt = 0;
4262 device_param->pws_cnt = 0;
4263 }
4264
4265 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268 if (data.devices_status == STATUS_ABORTED) break;
4269 if (data.devices_status == STATUS_QUIT) break;
4270 if (data.devices_status == STATUS_BYPASS) break;
4271
4272 device_param->words_done = words_fin;
4273 }
4274 }
4275 else
4276 {
4277 const uint segment_size = data.segment_size;
4278
4279 char *dictfile = data.dictfile;
4280
4281 if (attack_mode == ATTACK_MODE_COMBI)
4282 {
4283 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4284 {
4285 dictfile = data.dictfile2;
4286 }
4287 }
4288
4289 FILE *fd = fopen (dictfile, "rb");
4290
4291 if (fd == NULL)
4292 {
4293 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4294
4295 return NULL;
4296 }
4297
4298 if (attack_mode == ATTACK_MODE_COMBI)
4299 {
4300 const uint combs_mode = data.combs_mode;
4301
4302 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4303 {
4304 const char *dictfilec = data.dictfile2;
4305
4306 FILE *combs_fp = fopen (dictfilec, "rb");
4307
4308 if (combs_fp == NULL)
4309 {
4310 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4311
4312 fclose (fd);
4313
4314 return NULL;
4315 }
4316
4317 device_param->combs_fp = combs_fp;
4318 }
4319 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4320 {
4321 const char *dictfilec = data.dictfile;
4322
4323 FILE *combs_fp = fopen (dictfilec, "rb");
4324
4325 if (combs_fp == NULL)
4326 {
4327 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4328
4329 fclose (fd);
4330
4331 return NULL;
4332 }
4333
4334 device_param->combs_fp = combs_fp;
4335 }
4336 }
4337
4338 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4339
4340 wl_data->buf = (char *) mymalloc (segment_size);
4341 wl_data->avail = segment_size;
4342 wl_data->incr = segment_size;
4343 wl_data->cnt = 0;
4344 wl_data->pos = 0;
4345
4346 u64 words_cur = 0;
4347
4348 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4349 {
4350 u64 words_off = 0;
4351 u64 words_fin = 0;
4352
4353 u64 max = -1;
4354
4355 while (max)
4356 {
4357 const uint work = get_work (device_param, max);
4358
4359 if (work == 0) break;
4360
4361 words_off = device_param->words_off;
4362 words_fin = words_off + work;
4363
4364 char *line_buf;
4365 uint line_len;
4366
4367 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4368
4369 max = 0;
4370
4371 for ( ; words_cur < words_fin; words_cur++)
4372 {
4373 get_next_word (wl_data, fd, &line_buf, &line_len);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (attack_kern == ATTACK_KERN_STRAIGHT)
4397 {
4398 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4399 {
4400 max++;
4401
4402 hc_thread_mutex_lock (mux_counter);
4403
4404 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4405 {
4406 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4407 }
4408
4409 hc_thread_mutex_unlock (mux_counter);
4410
4411 continue;
4412 }
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4417 // since we still need to combine the plains
4418
4419 if (line_len > data.pw_max)
4420 {
4421 max++;
4422
4423 hc_thread_mutex_lock (mux_counter);
4424
4425 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4426 {
4427 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4428 }
4429
4430 hc_thread_mutex_unlock (mux_counter);
4431
4432 continue;
4433 }
4434 }
4435
4436 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4437
4438 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4439
4440 if (data.devices_status == STATUS_CRACKED) break;
4441 if (data.devices_status == STATUS_ABORTED) break;
4442 if (data.devices_status == STATUS_QUIT) break;
4443 if (data.devices_status == STATUS_BYPASS) break;
4444 }
4445
4446 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4447
4448 if (data.devices_status == STATUS_CRACKED) break;
4449 if (data.devices_status == STATUS_ABORTED) break;
4450 if (data.devices_status == STATUS_QUIT) break;
4451 if (data.devices_status == STATUS_BYPASS) break;
4452 }
4453
4454 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4455
4456 if (data.devices_status == STATUS_CRACKED) break;
4457 if (data.devices_status == STATUS_ABORTED) break;
4458 if (data.devices_status == STATUS_QUIT) break;
4459 if (data.devices_status == STATUS_BYPASS) break;
4460
4461 // we need 2 flushing because we have two independant caches and it can occur
4462 // that one buffer is already at threshold plus for that length also exists
4463 // more data in the 2nd buffer so it would overflow
4464
4465 //
4466 // flush session 1
4467 //
4468
4469 {
4470 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4471 {
4472 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4473
4474 const uint pw_cache_cnt = pw_cache->cnt;
4475
4476 if (pw_cache_cnt == 0) continue;
4477
4478 pw_cache->cnt = 0;
4479
4480 uint pws_cnt = device_param->pws_cnt;
4481
4482 pw_t *pw = device_param->pws_buf + pws_cnt;
4483
4484 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4485
4486 pw->pw_len = pw_len;
4487
4488 uint pw_cnt = device_param->pw_cnt;
4489
4490 pw_cnt += pw_cache_cnt;
4491
4492 device_param->pw_cnt = pw_cnt;
4493
4494 pws_cnt++;
4495
4496 device_param->pws_cnt = pws_cnt;
4497
4498 if (pws_cnt == device_param->kernel_power_user) break;
4499 }
4500
4501 const uint pw_cnt = device_param->pw_cnt;
4502 const uint pws_cnt = device_param->pws_cnt;
4503
4504 if (pws_cnt)
4505 {
4506 run_copy (device_param, pws_cnt);
4507
4508 run_cracker (device_param, pw_cnt, pws_cnt);
4509
4510 device_param->pw_cnt = 0;
4511 device_param->pws_cnt = 0;
4512 }
4513
4514 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4515
4516 if (data.devices_status == STATUS_CRACKED) break;
4517 if (data.devices_status == STATUS_ABORTED) break;
4518 if (data.devices_status == STATUS_QUIT) break;
4519 if (data.devices_status == STATUS_BYPASS) break;
4520 }
4521
4522 //
4523 // flush session 2
4524 //
4525
4526 {
4527 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4528 {
4529 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4530
4531 const uint pw_cache_cnt = pw_cache->cnt;
4532
4533 if (pw_cache_cnt == 0) continue;
4534
4535 pw_cache->cnt = 0;
4536
4537 uint pws_cnt = device_param->pws_cnt;
4538
4539 pw_t *pw = device_param->pws_buf + pws_cnt;
4540
4541 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4542
4543 pw->pw_len = pw_len;
4544
4545 uint pw_cnt = device_param->pw_cnt;
4546
4547 pw_cnt += pw_cache_cnt;
4548
4549 device_param->pw_cnt = pw_cnt;
4550
4551 pws_cnt++;
4552
4553 device_param->pws_cnt = pws_cnt;
4554 }
4555
4556 const uint pw_cnt = device_param->pw_cnt;
4557 const uint pws_cnt = device_param->pws_cnt;
4558
4559 if (pws_cnt)
4560 {
4561 run_copy (device_param, pws_cnt);
4562
4563 run_cracker (device_param, pw_cnt, pws_cnt);
4564
4565 device_param->pw_cnt = 0;
4566 device_param->pws_cnt = 0;
4567 }
4568
4569 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4570
4571 if (data.devices_status == STATUS_CRACKED) break;
4572 if (data.devices_status == STATUS_ABORTED) break;
4573 if (data.devices_status == STATUS_QUIT) break;
4574 if (data.devices_status == STATUS_BYPASS) break;
4575 }
4576
4577 if (words_fin == 0) break;
4578
4579 device_param->words_done = words_fin;
4580 }
4581
4582 if (attack_mode == ATTACK_MODE_COMBI)
4583 {
4584 fclose (device_param->combs_fp);
4585 }
4586
4587 free (wl_data->buf);
4588 free (wl_data);
4589
4590 fclose (fd);
4591 }
4592
4593 return NULL;
4594 }
4595
4596 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4597 {
4598 salt_t *salt_buf = &data.salts_buf[salt_pos];
4599
4600 device_param->kernel_params_buf32[24] = salt_pos;
4601 device_param->kernel_params_buf32[27] = 1;
4602 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4603 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4604 device_param->kernel_params_buf32[30] = 0;
4605 device_param->kernel_params_buf32[31] = 1;
4606
4607 char *dictfile_old = data.dictfile;
4608
4609 const char *weak_hash_check = "weak-hash-check";
4610
4611 data.dictfile = (char *) weak_hash_check;
4612
4613 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4614
4615 data.kernel_rules_buf[0].cmds[0] = 0;
4616
4617 /**
4618 * run the kernel
4619 */
4620
4621 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4622 {
4623 run_kernel (KERN_RUN_1, device_param, 1);
4624 }
4625 else
4626 {
4627 run_kernel (KERN_RUN_1, device_param, 1);
4628
4629 const uint iter = salt_buf->salt_iter;
4630
4631 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4632 {
4633 uint loop_left = iter - loop_pos;
4634
4635 loop_left = MIN (loop_left, kernel_loops);
4636
4637 device_param->kernel_params_buf32[25] = loop_pos;
4638 device_param->kernel_params_buf32[26] = loop_left;
4639
4640 run_kernel (KERN_RUN_2, device_param, 1);
4641 }
4642
4643 run_kernel (KERN_RUN_3, device_param, 1);
4644 }
4645
4646 /**
4647 * result
4648 */
4649
4650 check_cracked (device_param, salt_pos);
4651
4652 /**
4653 * cleanup
4654 */
4655
4656 device_param->kernel_params_buf32[24] = 0;
4657 device_param->kernel_params_buf32[25] = 0;
4658 device_param->kernel_params_buf32[26] = 0;
4659 device_param->kernel_params_buf32[27] = 0;
4660 device_param->kernel_params_buf32[28] = 0;
4661 device_param->kernel_params_buf32[29] = 0;
4662 device_param->kernel_params_buf32[30] = 0;
4663 device_param->kernel_params_buf32[31] = 0;
4664
4665 data.dictfile = dictfile_old;
4666
4667 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4668 }
4669
4670 // hlfmt hashcat
4671
4672 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4673 {
4674 if (data.username == 0)
4675 {
4676 *hashbuf_pos = line_buf;
4677 *hashbuf_len = line_len;
4678 }
4679 else
4680 {
4681 char *pos = line_buf;
4682 int len = line_len;
4683
4684 for (int i = 0; i < line_len; i++, pos++, len--)
4685 {
4686 if (line_buf[i] == data.separator)
4687 {
4688 pos++;
4689
4690 len--;
4691
4692 break;
4693 }
4694 }
4695
4696 *hashbuf_pos = pos;
4697 *hashbuf_len = len;
4698 }
4699 }
4700
4701 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4702 {
4703 char *pos = NULL;
4704 int len = 0;
4705
4706 int sep_cnt = 0;
4707
4708 for (int i = 0; i < line_len; i++)
4709 {
4710 if (line_buf[i] == data.separator)
4711 {
4712 sep_cnt++;
4713
4714 continue;
4715 }
4716
4717 if (sep_cnt == 0)
4718 {
4719 if (pos == NULL) pos = line_buf + i;
4720
4721 len++;
4722 }
4723 }
4724
4725 *userbuf_pos = pos;
4726 *userbuf_len = len;
4727 }
4728
4729 // hlfmt pwdump
4730
4731 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4732 {
4733 int sep_cnt = 0;
4734
4735 int sep2_len = 0;
4736 int sep3_len = 0;
4737
4738 for (int i = 0; i < line_len; i++)
4739 {
4740 if (line_buf[i] == ':')
4741 {
4742 sep_cnt++;
4743
4744 continue;
4745 }
4746
4747 if (sep_cnt == 2) sep2_len++;
4748 if (sep_cnt == 3) sep3_len++;
4749 }
4750
4751 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4752
4753 return 0;
4754 }
4755
4756 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4757 {
4758 char *pos = NULL;
4759 int len = 0;
4760
4761 int sep_cnt = 0;
4762
4763 for (int i = 0; i < line_len; i++)
4764 {
4765 if (line_buf[i] == ':')
4766 {
4767 sep_cnt++;
4768
4769 continue;
4770 }
4771
4772 if (data.hash_mode == 1000)
4773 {
4774 if (sep_cnt == 3)
4775 {
4776 if (pos == NULL) pos = line_buf + i;
4777
4778 len++;
4779 }
4780 }
4781 else if (data.hash_mode == 3000)
4782 {
4783 if (sep_cnt == 2)
4784 {
4785 if (pos == NULL) pos = line_buf + i;
4786
4787 len++;
4788 }
4789 }
4790 }
4791
4792 *hashbuf_pos = pos;
4793 *hashbuf_len = len;
4794 }
4795
4796 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4797 {
4798 char *pos = NULL;
4799 int len = 0;
4800
4801 int sep_cnt = 0;
4802
4803 for (int i = 0; i < line_len; i++)
4804 {
4805 if (line_buf[i] == ':')
4806 {
4807 sep_cnt++;
4808
4809 continue;
4810 }
4811
4812 if (sep_cnt == 0)
4813 {
4814 if (pos == NULL) pos = line_buf + i;
4815
4816 len++;
4817 }
4818 }
4819
4820 *userbuf_pos = pos;
4821 *userbuf_len = len;
4822 }
4823
4824 // hlfmt passwd
4825
4826 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4827 {
4828 int sep_cnt = 0;
4829
4830 char sep5_first = 0;
4831 char sep6_first = 0;
4832
4833 for (int i = 0; i < line_len; i++)
4834 {
4835 if (line_buf[i] == ':')
4836 {
4837 sep_cnt++;
4838
4839 continue;
4840 }
4841
4842 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4843 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4844 }
4845
4846 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4847
4848 return 0;
4849 }
4850
4851 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4852 {
4853 char *pos = NULL;
4854 int len = 0;
4855
4856 int sep_cnt = 0;
4857
4858 for (int i = 0; i < line_len; i++)
4859 {
4860 if (line_buf[i] == ':')
4861 {
4862 sep_cnt++;
4863
4864 continue;
4865 }
4866
4867 if (sep_cnt == 1)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874
4875 *hashbuf_pos = pos;
4876 *hashbuf_len = len;
4877 }
4878
4879 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4880 {
4881 char *pos = NULL;
4882 int len = 0;
4883
4884 int sep_cnt = 0;
4885
4886 for (int i = 0; i < line_len; i++)
4887 {
4888 if (line_buf[i] == ':')
4889 {
4890 sep_cnt++;
4891
4892 continue;
4893 }
4894
4895 if (sep_cnt == 0)
4896 {
4897 if (pos == NULL) pos = line_buf + i;
4898
4899 len++;
4900 }
4901 }
4902
4903 *userbuf_pos = pos;
4904 *userbuf_len = len;
4905 }
4906
4907 // hlfmt shadow
4908
4909 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4910 {
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':') sep_cnt++;
4916 }
4917
4918 if (sep_cnt == 8) return 1;
4919
4920 return 0;
4921 }
4922
4923 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4924 {
4925 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4926 }
4927
4928 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4929 {
4930 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4931 }
4932
4933 // hlfmt main
4934
4935 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4936 {
4937 switch (hashfile_format)
4938 {
4939 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4940 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4941 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4942 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4943 }
4944 }
4945
4946 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4947 {
4948 switch (hashfile_format)
4949 {
4950 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4951 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4952 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4953 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4954 }
4955 }
4956
4957 static uint hlfmt_detect (FILE *fp, uint max_check)
4958 {
4959 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4960
4961 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4962 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4963
4964 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4965
4966 uint num_check = 0;
4967
4968 while (!feof (fp))
4969 {
4970 char line_buf[BUFSIZ] = { 0 };
4971
4972 int line_len = fgetl (fp, line_buf);
4973
4974 if (line_len == 0) continue;
4975
4976 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4977 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4978 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4979
4980 if (num_check == max_check) break;
4981
4982 num_check++;
4983 }
4984
4985 uint hashlist_format = HLFMT_HASHCAT;
4986
4987 for (int i = 1; i < HLFMTS_CNT; i++)
4988 {
4989 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4990
4991 hashlist_format = i;
4992 }
4993
4994 free (formats_cnt);
4995
4996 return hashlist_format;
4997 }
4998
4999 /**
5000 * some further helper function
5001 */
5002
5003 // wrapper around mymalloc for ADL
5004
5005 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5006 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5007 {
5008 return mymalloc (iSize);
5009 }
5010 #endif
5011
5012 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)
5013 {
5014 u64 collisions = 0;
5015
5016 const uint dgst_pos0 = data.dgst_pos0;
5017 const uint dgst_pos1 = data.dgst_pos1;
5018 const uint dgst_pos2 = data.dgst_pos2;
5019 const uint dgst_pos3 = data.dgst_pos3;
5020
5021 memset (bitmap_a, 0, bitmap_size);
5022 memset (bitmap_b, 0, bitmap_size);
5023 memset (bitmap_c, 0, bitmap_size);
5024 memset (bitmap_d, 0, bitmap_size);
5025
5026 for (uint i = 0; i < digests_cnt; i++)
5027 {
5028 uint *digest_ptr = (uint *) digests_buf_ptr;
5029
5030 digests_buf_ptr += dgst_size;
5031
5032 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5033 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5034 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5035 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5036
5037 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5038 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5039 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5040 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5041
5042 if (bitmap_a[idx0] & val0) collisions++;
5043 if (bitmap_b[idx1] & val1) collisions++;
5044 if (bitmap_c[idx2] & val2) collisions++;
5045 if (bitmap_d[idx3] & val3) collisions++;
5046
5047 bitmap_a[idx0] |= val0;
5048 bitmap_b[idx1] |= val1;
5049 bitmap_c[idx2] |= val2;
5050 bitmap_d[idx3] |= val3;
5051
5052 if (collisions >= collisions_max) return 0x7fffffff;
5053 }
5054
5055 return collisions;
5056 }
5057
5058 /**
5059 * main
5060 */
5061
5062 int main (int argc, char **argv)
5063 {
5064 /**
5065 * To help users a bit
5066 */
5067
5068 char *compute = getenv ("COMPUTE");
5069
5070 if (compute)
5071 {
5072 char display[100] = { 0 };
5073
5074 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5075
5076 putenv (display);
5077 }
5078 else
5079 {
5080 if (getenv ("DISPLAY") == NULL)
5081 putenv ((char *) "DISPLAY=:0");
5082 }
5083
5084 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5085 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5086
5087 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5088 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5089
5090 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5091 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5092
5093 /**
5094 * Real init
5095 */
5096
5097 memset (&data, 0, sizeof (hc_global_data_t));
5098
5099 time_t proc_start;
5100
5101 time (&proc_start);
5102
5103 data.proc_start = proc_start;
5104
5105 int myargc = argc;
5106 char **myargv = argv;
5107
5108 hc_thread_mutex_init (mux_dispatcher);
5109 hc_thread_mutex_init (mux_counter);
5110 hc_thread_mutex_init (mux_display);
5111 hc_thread_mutex_init (mux_adl);
5112
5113 /**
5114 * commandline parameters
5115 */
5116
5117 uint usage = USAGE;
5118 uint version = VERSION;
5119 uint quiet = QUIET;
5120 uint benchmark = BENCHMARK;
5121 uint benchmark_mode = BENCHMARK_MODE;
5122 uint show = SHOW;
5123 uint left = LEFT;
5124 uint username = USERNAME;
5125 uint remove = REMOVE;
5126 uint remove_timer = REMOVE_TIMER;
5127 u64 skip = SKIP;
5128 u64 limit = LIMIT;
5129 uint keyspace = KEYSPACE;
5130 uint potfile_disable = POTFILE_DISABLE;
5131 uint debug_mode = DEBUG_MODE;
5132 char *debug_file = NULL;
5133 char *induction_dir = NULL;
5134 char *outfile_check_dir = NULL;
5135 uint force = FORCE;
5136 uint runtime = RUNTIME;
5137 uint hash_mode = HASH_MODE;
5138 uint attack_mode = ATTACK_MODE;
5139 uint markov_disable = MARKOV_DISABLE;
5140 uint markov_classic = MARKOV_CLASSIC;
5141 uint markov_threshold = MARKOV_THRESHOLD;
5142 char *markov_hcstat = NULL;
5143 char *outfile = NULL;
5144 uint outfile_format = OUTFILE_FORMAT;
5145 uint outfile_autohex = OUTFILE_AUTOHEX;
5146 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5147 uint restore = RESTORE;
5148 uint restore_timer = RESTORE_TIMER;
5149 uint restore_disable = RESTORE_DISABLE;
5150 uint status = STATUS;
5151 uint status_timer = STATUS_TIMER;
5152 uint status_automat = STATUS_AUTOMAT;
5153 uint loopback = LOOPBACK;
5154 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5155 char *session = NULL;
5156 uint hex_charset = HEX_CHARSET;
5157 uint hex_salt = HEX_SALT;
5158 uint hex_wordlist = HEX_WORDLIST;
5159 uint rp_gen = RP_GEN;
5160 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5161 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5162 uint rp_gen_seed = RP_GEN_SEED;
5163 char *rule_buf_l = (char *) RULE_BUF_L;
5164 char *rule_buf_r = (char *) RULE_BUF_R;
5165 uint increment = INCREMENT;
5166 uint increment_min = INCREMENT_MIN;
5167 uint increment_max = INCREMENT_MAX;
5168 #ifndef OSX
5169 char *cpu_affinity = NULL;
5170 #endif
5171 OCL_PTR *ocl = NULL;
5172 char *opencl_devices = NULL;
5173 char *opencl_platforms = NULL;
5174 char *opencl_device_types = NULL;
5175 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5176 char *truecrypt_keyfiles = NULL;
5177 uint workload_profile = WORKLOAD_PROFILE;
5178 uint kernel_accel = KERNEL_ACCEL;
5179 uint kernel_loops = KERNEL_LOOPS;
5180 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5181 #ifdef HAVE_HWMON
5182 uint gpu_temp_abort = GPU_TEMP_ABORT;
5183 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5184 #ifdef HAVE_ADL
5185 uint powertune_enable = POWERTUNE_ENABLE;
5186 #endif
5187 #endif
5188 uint logfile_disable = LOGFILE_DISABLE;
5189 uint segment_size = SEGMENT_SIZE;
5190 uint scrypt_tmto = SCRYPT_TMTO;
5191 char separator = SEPARATOR;
5192 uint bitmap_min = BITMAP_MIN;
5193 uint bitmap_max = BITMAP_MAX;
5194 char *custom_charset_1 = NULL;
5195 char *custom_charset_2 = NULL;
5196 char *custom_charset_3 = NULL;
5197 char *custom_charset_4 = NULL;
5198
5199 #define IDX_HELP 'h'
5200 #define IDX_VERSION 'V'
5201 #define IDX_VERSION_LOWER 'v'
5202 #define IDX_QUIET 0xff02
5203 #define IDX_SHOW 0xff03
5204 #define IDX_LEFT 0xff04
5205 #define IDX_REMOVE 0xff05
5206 #define IDX_REMOVE_TIMER 0xff37
5207 #define IDX_SKIP 's'
5208 #define IDX_LIMIT 'l'
5209 #define IDX_KEYSPACE 0xff35
5210 #define IDX_POTFILE_DISABLE 0xff06
5211 #define IDX_DEBUG_MODE 0xff43
5212 #define IDX_DEBUG_FILE 0xff44
5213 #define IDX_INDUCTION_DIR 0xff46
5214 #define IDX_OUTFILE_CHECK_DIR 0xff47
5215 #define IDX_USERNAME 0xff07
5216 #define IDX_FORCE 0xff08
5217 #define IDX_RUNTIME 0xff09
5218 #define IDX_BENCHMARK 'b'
5219 #define IDX_BENCHMARK_MODE 0xff32
5220 #define IDX_HASH_MODE 'm'
5221 #define IDX_ATTACK_MODE 'a'
5222 #define IDX_RP_FILE 'r'
5223 #define IDX_RP_GEN 'g'
5224 #define IDX_RP_GEN_FUNC_MIN 0xff10
5225 #define IDX_RP_GEN_FUNC_MAX 0xff11
5226 #define IDX_RP_GEN_SEED 0xff34
5227 #define IDX_RULE_BUF_L 'j'
5228 #define IDX_RULE_BUF_R 'k'
5229 #define IDX_INCREMENT 'i'
5230 #define IDX_INCREMENT_MIN 0xff12
5231 #define IDX_INCREMENT_MAX 0xff13
5232 #define IDX_OUTFILE 'o'
5233 #define IDX_OUTFILE_FORMAT 0xff14
5234 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5235 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5236 #define IDX_RESTORE 0xff15
5237 #define IDX_RESTORE_DISABLE 0xff27
5238 #define IDX_STATUS 0xff17
5239 #define IDX_STATUS_TIMER 0xff18
5240 #define IDX_STATUS_AUTOMAT 0xff50
5241 #define IDX_LOOPBACK 0xff38
5242 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5243 #define IDX_SESSION 0xff19
5244 #define IDX_HEX_CHARSET 0xff20
5245 #define IDX_HEX_SALT 0xff21
5246 #define IDX_HEX_WORDLIST 0xff40
5247 #define IDX_MARKOV_DISABLE 0xff22
5248 #define IDX_MARKOV_CLASSIC 0xff23
5249 #define IDX_MARKOV_THRESHOLD 't'
5250 #define IDX_MARKOV_HCSTAT 0xff24
5251 #define IDX_CPU_AFFINITY 0xff25
5252 #define IDX_OPENCL_DEVICES 'd'
5253 #define IDX_OPENCL_PLATFORMS 0xff72
5254 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5255 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5256 #define IDX_WORKLOAD_PROFILE 'w'
5257 #define IDX_KERNEL_ACCEL 'n'
5258 #define IDX_KERNEL_LOOPS 'u'
5259 #define IDX_GPU_TEMP_DISABLE 0xff29
5260 #define IDX_GPU_TEMP_ABORT 0xff30
5261 #define IDX_GPU_TEMP_RETAIN 0xff31
5262 #define IDX_POWERTUNE_ENABLE 0xff41
5263 #define IDX_LOGFILE_DISABLE 0xff51
5264 #define IDX_TRUECRYPT_KEYFILES 0xff52
5265 #define IDX_SCRYPT_TMTO 0xff61
5266 #define IDX_SEGMENT_SIZE 'c'
5267 #define IDX_SEPARATOR 'p'
5268 #define IDX_BITMAP_MIN 0xff70
5269 #define IDX_BITMAP_MAX 0xff71
5270 #define IDX_CUSTOM_CHARSET_1 '1'
5271 #define IDX_CUSTOM_CHARSET_2 '2'
5272 #define IDX_CUSTOM_CHARSET_3 '3'
5273 #define IDX_CUSTOM_CHARSET_4 '4'
5274
5275 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5276
5277 struct option long_options[] =
5278 {
5279 {"help", no_argument, 0, IDX_HELP},
5280 {"version", no_argument, 0, IDX_VERSION},
5281 {"quiet", no_argument, 0, IDX_QUIET},
5282 {"show", no_argument, 0, IDX_SHOW},
5283 {"left", no_argument, 0, IDX_LEFT},
5284 {"username", no_argument, 0, IDX_USERNAME},
5285 {"remove", no_argument, 0, IDX_REMOVE},
5286 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5287 {"skip", required_argument, 0, IDX_SKIP},
5288 {"limit", required_argument, 0, IDX_LIMIT},
5289 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5290 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5291 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5292 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5293 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5294 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5295 {"force", no_argument, 0, IDX_FORCE},
5296 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5297 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5298 {"restore", no_argument, 0, IDX_RESTORE},
5299 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5300 {"status", no_argument, 0, IDX_STATUS},
5301 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5302 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5303 {"loopback", no_argument, 0, IDX_LOOPBACK},
5304 {"weak-hash-threshold",
5305 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5306 {"session", required_argument, 0, IDX_SESSION},
5307 {"runtime", required_argument, 0, IDX_RUNTIME},
5308 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5309 {"generate-rules-func-min",
5310 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5311 {"generate-rules-func-max",
5312 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5313 {"generate-rules-seed",
5314 required_argument, 0, IDX_RP_GEN_SEED},
5315 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5316 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5317 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5318 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5319 {"rules-file", required_argument, 0, IDX_RP_FILE},
5320 {"outfile", required_argument, 0, IDX_OUTFILE},
5321 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5322 {"outfile-autohex-disable",
5323 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5324 {"outfile-check-timer",
5325 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5326 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5327 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5328 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5329 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5330 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5331 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5332 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5333 #ifndef OSX
5334 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5335 #endif
5336 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5337 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5338 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5339 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5340 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5341 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5342 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5343 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5344 #ifdef HAVE_HWMON
5345 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5346 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5347 #ifdef HAVE_ADL
5348 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5349 #endif
5350 #endif // HAVE_HWMON
5351 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5352 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5353 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5354 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5355 // deprecated
5356 {"seperator", required_argument, 0, IDX_SEPARATOR},
5357 {"separator", required_argument, 0, IDX_SEPARATOR},
5358 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5359 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5360 {"increment", no_argument, 0, IDX_INCREMENT},
5361 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5362 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5363 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5364 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5365 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5366 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5367
5368 {0, 0, 0, 0}
5369 };
5370
5371 uint rp_files_cnt = 0;
5372
5373 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5374
5375 int option_index = 0;
5376 int c = -1;
5377
5378 optind = 1;
5379 optopt = 0;
5380
5381 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5382 {
5383 switch (c)
5384 {
5385 case IDX_HELP: usage = 1; break;
5386 case IDX_VERSION:
5387 case IDX_VERSION_LOWER: version = 1; break;
5388 case IDX_RESTORE: restore = 1; break;
5389 case IDX_SESSION: session = optarg; break;
5390 case IDX_SHOW: show = 1; break;
5391 case IDX_LEFT: left = 1; break;
5392 case '?': return (-1);
5393 }
5394 }
5395
5396 if (optopt != 0)
5397 {
5398 log_error ("ERROR: Invalid argument specified");
5399
5400 return (-1);
5401 }
5402
5403 /**
5404 * exit functions
5405 */
5406
5407 if (version)
5408 {
5409 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5410
5411 return (0);
5412 }
5413
5414 if (usage)
5415 {
5416 usage_big_print (PROGNAME);
5417
5418 return (0);
5419 }
5420
5421 /**
5422 * session needs to be set, always!
5423 */
5424
5425 if (session == NULL) session = (char *) PROGNAME;
5426
5427 /**
5428 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5429 */
5430
5431 char *exec_path = get_exec_path ();
5432
5433 #ifdef LINUX
5434
5435 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5436 char *resolved_exec_path = realpath (exec_path, NULL);
5437
5438 char *install_dir = get_install_dir (resolved_exec_path);
5439 char *profile_dir = NULL;
5440 char *session_dir = NULL;
5441 char *shared_dir = NULL;
5442
5443 if (strcmp (install_dir, resolved_install_folder) == 0)
5444 {
5445 struct passwd *pw = getpwuid (getuid ());
5446
5447 const char *homedir = pw->pw_dir;
5448
5449 profile_dir = get_profile_dir (homedir);
5450 session_dir = get_session_dir (profile_dir);
5451 shared_dir = strdup (SHARED_FOLDER);
5452
5453 mkdir (profile_dir, 0700);
5454 mkdir (session_dir, 0700);
5455 }
5456 else
5457 {
5458 profile_dir = install_dir;
5459 session_dir = install_dir;
5460 shared_dir = install_dir;
5461 }
5462
5463 myfree (resolved_install_folder);
5464 myfree (resolved_exec_path);
5465
5466 #else
5467
5468 char *install_dir = get_install_dir (exec_path);
5469 char *profile_dir = install_dir;
5470 char *session_dir = install_dir;
5471 char *shared_dir = install_dir;
5472
5473 #endif
5474
5475 data.install_dir = install_dir;
5476 data.profile_dir = profile_dir;
5477 data.session_dir = session_dir;
5478 data.shared_dir = shared_dir;
5479
5480 myfree (exec_path);
5481
5482 /**
5483 * kernel cache, we need to make sure folder exist
5484 */
5485
5486 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5487
5488 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5489
5490 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5491
5492 mkdir (kernels_folder, 0700);
5493
5494 myfree (kernels_folder);
5495
5496 /**
5497 * session
5498 */
5499
5500 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5501
5502 data.session = session;
5503
5504 char *eff_restore_file = (char *) mymalloc (session_size);
5505 char *new_restore_file = (char *) mymalloc (session_size);
5506
5507 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5508 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5509
5510 data.eff_restore_file = eff_restore_file;
5511 data.new_restore_file = new_restore_file;
5512
5513 if (((show == 1) || (left == 1)) && (restore == 1))
5514 {
5515 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5516 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5517
5518 return (-1);
5519 }
5520
5521 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5522 if ((show == 1) || (left == 1))
5523 {
5524 restore_disable = 1;
5525
5526 restore = 0;
5527 }
5528
5529 data.restore_disable = restore_disable;
5530
5531 restore_data_t *rd = init_restore (argc, argv);
5532
5533 data.rd = rd;
5534
5535 /**
5536 * restore file
5537 */
5538
5539 if (restore == 1)
5540 {
5541 read_restore (eff_restore_file, rd);
5542
5543 if (rd->version_bin < RESTORE_MIN)
5544 {
5545 log_error ("ERROR: Incompatible restore-file version");
5546
5547 return (-1);
5548 }
5549
5550 myargc = rd->argc;
5551 myargv = rd->argv;
5552
5553 #ifdef _POSIX
5554 rd->pid = getpid ();
5555 #elif _WIN
5556 rd->pid = GetCurrentProcessId ();
5557 #endif
5558 }
5559
5560 uint hash_mode_chgd = 0;
5561 uint runtime_chgd = 0;
5562 uint kernel_loops_chgd = 0;
5563 uint kernel_accel_chgd = 0;
5564 uint attack_mode_chgd = 0;
5565 uint outfile_format_chgd = 0;
5566 uint rp_gen_seed_chgd = 0;
5567 uint remove_timer_chgd = 0;
5568 uint increment_min_chgd = 0;
5569 uint increment_max_chgd = 0;
5570 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5571 uint gpu_temp_retain_chgd = 0;
5572 uint gpu_temp_abort_chgd = 0;
5573 #endif
5574
5575 optind = 1;
5576 optopt = 0;
5577 option_index = 0;
5578
5579 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5580 {
5581 switch (c)
5582 {
5583 //case IDX_HELP: usage = 1; break;
5584 //case IDX_VERSION: version = 1; break;
5585 //case IDX_RESTORE: restore = 1; break;
5586 case IDX_QUIET: quiet = 1; break;
5587 //case IDX_SHOW: show = 1; break;
5588 case IDX_SHOW: break;
5589 //case IDX_LEFT: left = 1; break;
5590 case IDX_LEFT: break;
5591 case IDX_USERNAME: username = 1; break;
5592 case IDX_REMOVE: remove = 1; break;
5593 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5594 remove_timer_chgd = 1; break;
5595 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5596 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5597 case IDX_DEBUG_FILE: debug_file = optarg; break;
5598 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5599 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5600 case IDX_FORCE: force = 1; break;
5601 case IDX_SKIP: skip = atoll (optarg); break;
5602 case IDX_LIMIT: limit = atoll (optarg); break;
5603 case IDX_KEYSPACE: keyspace = 1; break;
5604 case IDX_BENCHMARK: benchmark = 1; break;
5605 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5606 case IDX_RESTORE: break;
5607 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5608 case IDX_STATUS: status = 1; break;
5609 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5610 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5611 case IDX_LOOPBACK: loopback = 1; break;
5612 case IDX_WEAK_HASH_THRESHOLD:
5613 weak_hash_threshold = atoi (optarg); break;
5614 //case IDX_SESSION: session = optarg; break;
5615 case IDX_SESSION: break;
5616 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5617 hash_mode_chgd = 1; break;
5618 case IDX_RUNTIME: runtime = atoi (optarg);
5619 runtime_chgd = 1; break;
5620 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5621 attack_mode_chgd = 1; break;
5622 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5623 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5624 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5625 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5626 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5627 rp_gen_seed_chgd = 1; break;
5628 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5629 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5630 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5631 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5632 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5633 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5634 case IDX_OUTFILE: outfile = optarg; break;
5635 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5636 outfile_format_chgd = 1; break;
5637 case IDX_OUTFILE_AUTOHEX_DISABLE:
5638 outfile_autohex = 0; break;
5639 case IDX_OUTFILE_CHECK_TIMER:
5640 outfile_check_timer = atoi (optarg); break;
5641 case IDX_HEX_CHARSET: hex_charset = 1; break;
5642 case IDX_HEX_SALT: hex_salt = 1; break;
5643 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5644 #ifndef OSX
5645 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5646 #endif
5647 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5648 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5649 case IDX_OPENCL_DEVICE_TYPES:
5650 opencl_device_types = optarg; break;
5651 case IDX_OPENCL_VECTOR_WIDTH:
5652 opencl_vector_width = atoi (optarg); break;
5653 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5654 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5655 kernel_accel_chgd = 1; break;
5656 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5657 kernel_loops_chgd = 1; break;
5658 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5659 #ifdef HAVE_HWMON
5660 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5661 #ifdef HAVE_ADL
5662 gpu_temp_abort_chgd = 1;
5663 #endif
5664 break;
5665 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5666 #ifdef HAVE_ADL
5667 gpu_temp_retain_chgd = 1;
5668 #endif
5669 break;
5670 #ifdef HAVE_ADL
5671 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5672 #endif
5673 #endif // HAVE_HWMON
5674 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5675 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5676 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5677 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5678 case IDX_SEPARATOR: separator = optarg[0]; break;
5679 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5680 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5681 case IDX_INCREMENT: increment = 1; break;
5682 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5683 increment_min_chgd = 1; break;
5684 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5685 increment_max_chgd = 1; break;
5686 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5687 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5688 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5689 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5690
5691 default:
5692 log_error ("ERROR: Invalid argument specified");
5693 return (-1);
5694 }
5695 }
5696
5697 if (optopt != 0)
5698 {
5699 log_error ("ERROR: Invalid argument specified");
5700
5701 return (-1);
5702 }
5703
5704 /**
5705 * Inform user things getting started,
5706 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5707 * - we do not need to check algorithm_pos
5708 */
5709
5710 if (quiet == 0)
5711 {
5712 if (benchmark == 1)
5713 {
5714 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5715
5716 log_info ("");
5717 }
5718 else if (restore == 1)
5719 {
5720 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5721
5722 log_info ("");
5723 }
5724 else
5725 {
5726 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5727
5728 log_info ("");
5729 }
5730 }
5731
5732 /**
5733 * sanity check
5734 */
5735
5736 if (attack_mode > 7)
5737 {
5738 log_error ("ERROR: Invalid attack-mode specified");
5739
5740 return (-1);
5741 }
5742
5743 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5744 {
5745 log_error ("ERROR: Invalid runtime specified");
5746
5747 return (-1);
5748 }
5749
5750 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5751 {
5752 log_error ("ERROR: Invalid hash-type specified");
5753
5754 return (-1);
5755 }
5756
5757 // renamed hash modes
5758
5759 if (hash_mode_chgd)
5760 {
5761 int n = -1;
5762
5763 switch (hash_mode)
5764 {
5765 case 123: n = 124;
5766 break;
5767 }
5768
5769 if (n >= 0)
5770 {
5771 log_error ("Old -m specified, use -m %d instead", n);
5772
5773 return (-1);
5774 }
5775 }
5776
5777 if (username == 1)
5778 {
5779 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5780 {
5781 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5782
5783 return (-1);
5784 }
5785 }
5786
5787 if (outfile_format > 16)
5788 {
5789 log_error ("ERROR: Invalid outfile-format specified");
5790
5791 return (-1);
5792 }
5793
5794 if (left == 1)
5795 {
5796 if (outfile_format_chgd == 1)
5797 {
5798 if (outfile_format > 1)
5799 {
5800 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5801
5802 return (-1);
5803 }
5804 }
5805 else
5806 {
5807 outfile_format = OUTFILE_FMT_HASH;
5808 }
5809 }
5810
5811 if (show == 1)
5812 {
5813 if (outfile_format_chgd == 1)
5814 {
5815 if ((outfile_format > 7) && (outfile_format < 16))
5816 {
5817 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5818
5819 return (-1);
5820 }
5821 }
5822 }
5823
5824 if (increment_min < INCREMENT_MIN)
5825 {
5826 log_error ("ERROR: Invalid increment-min specified");
5827
5828 return (-1);
5829 }
5830
5831 if (increment_max > INCREMENT_MAX)
5832 {
5833 log_error ("ERROR: Invalid increment-max specified");
5834
5835 return (-1);
5836 }
5837
5838 if (increment_min > increment_max)
5839 {
5840 log_error ("ERROR: Invalid increment-min specified");
5841
5842 return (-1);
5843 }
5844
5845 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5846 {
5847 log_error ("ERROR: increment is not allowed in attack-mode 0");
5848
5849 return (-1);
5850 }
5851
5852 if ((increment == 0) && (increment_min_chgd == 1))
5853 {
5854 log_error ("ERROR: increment-min is only supported together with increment switch");
5855
5856 return (-1);
5857 }
5858
5859 if ((increment == 0) && (increment_max_chgd == 1))
5860 {
5861 log_error ("ERROR: increment-max is only supported together with increment switch");
5862
5863 return (-1);
5864 }
5865
5866 if (rp_files_cnt && rp_gen)
5867 {
5868 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5869
5870 return (-1);
5871 }
5872
5873 if (rp_files_cnt || rp_gen)
5874 {
5875 if (attack_mode != ATTACK_MODE_STRAIGHT)
5876 {
5877 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5878
5879 return (-1);
5880 }
5881 }
5882
5883 if (rp_gen_func_min > rp_gen_func_max)
5884 {
5885 log_error ("ERROR: Invalid rp-gen-func-min specified");
5886
5887 return (-1);
5888 }
5889
5890 if (kernel_accel_chgd == 1)
5891 {
5892 if (workload_profile != WORKLOAD_PROFILE)
5893 {
5894 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5895
5896 return (-1);
5897 }
5898
5899 if (kernel_accel < 1)
5900 {
5901 log_error ("ERROR: Invalid kernel-accel specified");
5902
5903 return (-1);
5904 }
5905
5906 if (kernel_accel > 800)
5907 {
5908 log_error ("ERROR: Invalid kernel-accel specified");
5909
5910 return (-1);
5911 }
5912 }
5913
5914 if (kernel_loops_chgd == 1)
5915 {
5916 if (workload_profile != WORKLOAD_PROFILE)
5917 {
5918 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5919
5920 return (-1);
5921 }
5922
5923 if (kernel_loops < 1)
5924 {
5925 log_error ("ERROR: Invalid kernel-loops specified");
5926
5927 return (-1);
5928 }
5929
5930 if (kernel_loops > 1024)
5931 {
5932 log_error ("ERROR: Invalid kernel-loops specified");
5933
5934 return (-1);
5935 }
5936 }
5937
5938 if (benchmark == 1)
5939 {
5940 if (workload_profile != WORKLOAD_PROFILE)
5941 {
5942 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5943
5944 return (-1);
5945 }
5946 }
5947
5948 if ((workload_profile < 1) || (workload_profile > 3))
5949 {
5950 log_error ("ERROR: workload-profile %i not available", workload_profile);
5951
5952 return (-1);
5953 }
5954
5955 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5956 {
5957 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5958
5959 return (-1);
5960 }
5961
5962 if (show == 1 || left == 1)
5963 {
5964 attack_mode = ATTACK_MODE_NONE;
5965
5966 if (remove == 1)
5967 {
5968 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5969
5970 return (-1);
5971 }
5972
5973 if (potfile_disable == 1)
5974 {
5975 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5976
5977 return (-1);
5978 }
5979 }
5980
5981 uint attack_kern = ATTACK_KERN_NONE;
5982
5983 switch (attack_mode)
5984 {
5985 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5986 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5987 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5988 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5989 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5990 }
5991
5992 if (benchmark == 0)
5993 {
5994 if (keyspace == 1)
5995 {
5996 int num_additional_params = 1;
5997
5998 if (attack_kern == ATTACK_KERN_COMBI)
5999 {
6000 num_additional_params = 2;
6001 }
6002
6003 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6004
6005 if (keyspace_wordlist_specified == 0) optind--;
6006 }
6007
6008 if (attack_kern == ATTACK_KERN_NONE)
6009 {
6010 if ((optind + 1) != myargc)
6011 {
6012 usage_mini_print (myargv[0]);
6013
6014 return (-1);
6015 }
6016 }
6017 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6018 {
6019 if ((optind + 1) > myargc)
6020 {
6021 usage_mini_print (myargv[0]);
6022
6023 return (-1);
6024 }
6025 }
6026 else if (attack_kern == ATTACK_KERN_COMBI)
6027 {
6028 if ((optind + 3) != myargc)
6029 {
6030 usage_mini_print (myargv[0]);
6031
6032 return (-1);
6033 }
6034 }
6035 else if (attack_kern == ATTACK_KERN_BF)
6036 {
6037 if ((optind + 1) > myargc)
6038 {
6039 usage_mini_print (myargv[0]);
6040
6041 return (-1);
6042 }
6043 }
6044 else
6045 {
6046 usage_mini_print (myargv[0]);
6047
6048 return (-1);
6049 }
6050 }
6051 else
6052 {
6053 if (myargv[optind] != 0)
6054 {
6055 log_error ("ERROR: Invalid argument for benchmark mode specified");
6056
6057 return (-1);
6058 }
6059
6060 if (attack_mode_chgd == 1)
6061 {
6062 if (attack_mode != ATTACK_MODE_BF)
6063 {
6064 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6065
6066 return (-1);
6067 }
6068 }
6069
6070 if (benchmark_mode == 0)
6071 {
6072 // nothing to do
6073 }
6074 else if (benchmark_mode == 1)
6075 {
6076 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6077 {
6078 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6079
6080 return (-1);
6081 }
6082 }
6083 else
6084 {
6085 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 if (skip != 0 && limit != 0)
6092 {
6093 limit += skip;
6094 }
6095
6096 if (keyspace == 1)
6097 {
6098 if (show == 1)
6099 {
6100 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6101
6102 return (-1);
6103 }
6104 else if (left == 1)
6105 {
6106 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6107
6108 return (-1);
6109 }
6110
6111 potfile_disable = 1;
6112
6113 restore_disable = 1;
6114
6115 restore = 0;
6116
6117 weak_hash_threshold = 0;
6118
6119 quiet = 1;
6120 }
6121
6122 if (remove_timer_chgd == 1)
6123 {
6124 if (remove == 0)
6125 {
6126 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6127
6128 return (-1);
6129 }
6130
6131 if (remove_timer < 1)
6132 {
6133 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6134
6135 return (-1);
6136 }
6137 }
6138
6139 if (loopback == 1)
6140 {
6141 if (attack_mode == ATTACK_MODE_BF)
6142 {
6143 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6144
6145 return (-1);
6146 }
6147 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6148 {
6149 if ((rp_files_cnt == 0) && (rp_gen == 0))
6150 {
6151 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6152
6153 return (-1);
6154 }
6155 }
6156 }
6157
6158 if (debug_mode > 0)
6159 {
6160 if (attack_mode != ATTACK_MODE_STRAIGHT)
6161 {
6162 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6163
6164 return (-1);
6165 }
6166
6167 if ((rp_files_cnt == 0) && (rp_gen == 0))
6168 {
6169 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6170
6171 return (-1);
6172 }
6173 }
6174
6175 if (debug_mode > 4)
6176 {
6177 log_error ("ERROR: Invalid debug-mode specified");
6178
6179 return (-1);
6180 }
6181
6182 if (debug_file != NULL)
6183 {
6184 if (debug_mode < 1)
6185 {
6186 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6187
6188 return (-1);
6189 }
6190 }
6191
6192 if (induction_dir != NULL)
6193 {
6194 if (attack_mode == ATTACK_MODE_BF)
6195 {
6196 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6197
6198 return (-1);
6199 }
6200 }
6201
6202 if (attack_mode != ATTACK_MODE_STRAIGHT)
6203 {
6204 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6205 {
6206 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6207
6208 return (-1);
6209 }
6210
6211 weak_hash_threshold = 0;
6212 }
6213
6214 /**
6215 * induction directory
6216 */
6217
6218 char *induction_directory = NULL;
6219
6220 if (attack_mode != ATTACK_MODE_BF)
6221 {
6222 if (induction_dir == NULL)
6223 {
6224 induction_directory = (char *) mymalloc (session_size);
6225
6226 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6227
6228 // create induction folder if it does not already exist
6229
6230 if (keyspace == 0)
6231 {
6232 if (rmdir (induction_directory) == -1)
6233 {
6234 if (errno == ENOENT)
6235 {
6236 // good, we can ignore
6237 }
6238 else if (errno == ENOTEMPTY)
6239 {
6240 char *induction_directory_mv = (char *) mymalloc (session_size);
6241
6242 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6243
6244 if (rename (induction_directory, induction_directory_mv) != 0)
6245 {
6246 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (mkdir (induction_directory, 0700) == -1)
6260 {
6261 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6262
6263 return (-1);
6264 }
6265 }
6266 }
6267 else
6268 {
6269 induction_directory = induction_dir;
6270 }
6271 }
6272
6273 data.induction_directory = induction_directory;
6274
6275 /**
6276 * loopback
6277 */
6278
6279 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6280
6281 char *loopback_file = (char *) mymalloc (loopback_size);
6282
6283 /**
6284 * outfile-check directory
6285 */
6286
6287 char *outfile_check_directory = NULL;
6288
6289 if (outfile_check_dir == NULL)
6290 {
6291 outfile_check_directory = (char *) mymalloc (session_size);
6292
6293 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6294 }
6295 else
6296 {
6297 outfile_check_directory = outfile_check_dir;
6298 }
6299
6300 data.outfile_check_directory = outfile_check_directory;
6301
6302 if (keyspace == 0)
6303 {
6304 struct stat outfile_check_stat;
6305
6306 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6307 {
6308 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6309
6310 if (is_dir == 0)
6311 {
6312 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6313
6314 return (-1);
6315 }
6316 }
6317 else if (outfile_check_dir == NULL)
6318 {
6319 if (mkdir (outfile_check_directory, 0700) == -1)
6320 {
6321 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6322
6323 return (-1);
6324 }
6325 }
6326 }
6327
6328 /**
6329 * special other stuff
6330 */
6331
6332 if (hash_mode == 9710)
6333 {
6334 outfile_format = 5;
6335 outfile_format_chgd = 1;
6336 }
6337
6338 if (hash_mode == 9810)
6339 {
6340 outfile_format = 5;
6341 outfile_format_chgd = 1;
6342 }
6343
6344 if (hash_mode == 10410)
6345 {
6346 outfile_format = 5;
6347 outfile_format_chgd = 1;
6348 }
6349
6350 /**
6351 * store stuff
6352 */
6353
6354 data.hash_mode = hash_mode;
6355 data.restore = restore;
6356 data.restore_timer = restore_timer;
6357 data.restore_disable = restore_disable;
6358 data.status = status;
6359 data.status_timer = status_timer;
6360 data.status_automat = status_automat;
6361 data.loopback = loopback;
6362 data.runtime = runtime;
6363 data.remove = remove;
6364 data.remove_timer = remove_timer;
6365 data.debug_mode = debug_mode;
6366 data.debug_file = debug_file;
6367 data.username = username;
6368 data.quiet = quiet;
6369 data.outfile = outfile;
6370 data.outfile_format = outfile_format;
6371 data.outfile_autohex = outfile_autohex;
6372 data.hex_charset = hex_charset;
6373 data.hex_salt = hex_salt;
6374 data.hex_wordlist = hex_wordlist;
6375 data.separator = separator;
6376 data.rp_files = rp_files;
6377 data.rp_files_cnt = rp_files_cnt;
6378 data.rp_gen = rp_gen;
6379 data.rp_gen_seed = rp_gen_seed;
6380 data.force = force;
6381 data.benchmark = benchmark;
6382 data.skip = skip;
6383 data.limit = limit;
6384 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6385 data.powertune_enable = powertune_enable;
6386 #endif
6387 data.logfile_disable = logfile_disable;
6388 data.truecrypt_keyfiles = truecrypt_keyfiles;
6389 data.scrypt_tmto = scrypt_tmto;
6390
6391 /**
6392 * cpu affinity
6393 */
6394
6395 #ifndef OSX
6396 if (cpu_affinity)
6397 {
6398 set_cpu_affinity (cpu_affinity);
6399 }
6400 #endif
6401
6402 if (rp_gen_seed_chgd == 0)
6403 {
6404 srand (proc_start);
6405 }
6406 else
6407 {
6408 srand (rp_gen_seed);
6409 }
6410
6411 /**
6412 * logfile init
6413 */
6414
6415 if (logfile_disable == 0)
6416 {
6417 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6418
6419 char *logfile = (char *) mymalloc (logfile_size);
6420
6421 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6422
6423 data.logfile = logfile;
6424
6425 char *topid = logfile_generate_topid ();
6426
6427 data.topid = topid;
6428 }
6429
6430 // logfile_append() checks for logfile_disable internally to make it easier from here
6431
6432 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6433 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6434 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6435 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6436 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6437 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6438 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6439 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6440 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6441 #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));
6442
6443 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6444 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6445 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6446 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6447 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6448 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6449 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6450 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6451
6452 logfile_top_msg ("START");
6453
6454 logfile_top_uint (attack_mode);
6455 logfile_top_uint (attack_kern);
6456 logfile_top_uint (benchmark);
6457 logfile_top_uint (benchmark_mode);
6458 logfile_top_uint (bitmap_min);
6459 logfile_top_uint (bitmap_max);
6460 logfile_top_uint (debug_mode);
6461 logfile_top_uint (force);
6462 logfile_top_uint (kernel_accel);
6463 logfile_top_uint (kernel_loops);
6464 logfile_top_uint (gpu_temp_disable);
6465 #ifdef HAVE_HWMON
6466 logfile_top_uint (gpu_temp_abort);
6467 logfile_top_uint (gpu_temp_retain);
6468 #endif
6469 logfile_top_uint (hash_mode);
6470 logfile_top_uint (hex_charset);
6471 logfile_top_uint (hex_salt);
6472 logfile_top_uint (hex_wordlist);
6473 logfile_top_uint (increment);
6474 logfile_top_uint (increment_max);
6475 logfile_top_uint (increment_min);
6476 logfile_top_uint (keyspace);
6477 logfile_top_uint (left);
6478 logfile_top_uint (logfile_disable);
6479 logfile_top_uint (loopback);
6480 logfile_top_uint (markov_classic);
6481 logfile_top_uint (markov_disable);
6482 logfile_top_uint (markov_threshold);
6483 logfile_top_uint (outfile_autohex);
6484 logfile_top_uint (outfile_check_timer);
6485 logfile_top_uint (outfile_format);
6486 logfile_top_uint (potfile_disable);
6487 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6488 logfile_top_uint (powertune_enable);
6489 #endif
6490 logfile_top_uint (scrypt_tmto);
6491 logfile_top_uint (quiet);
6492 logfile_top_uint (remove);
6493 logfile_top_uint (remove_timer);
6494 logfile_top_uint (restore);
6495 logfile_top_uint (restore_disable);
6496 logfile_top_uint (restore_timer);
6497 logfile_top_uint (rp_gen);
6498 logfile_top_uint (rp_gen_func_max);
6499 logfile_top_uint (rp_gen_func_min);
6500 logfile_top_uint (rp_gen_seed);
6501 logfile_top_uint (runtime);
6502 logfile_top_uint (segment_size);
6503 logfile_top_uint (show);
6504 logfile_top_uint (status);
6505 logfile_top_uint (status_automat);
6506 logfile_top_uint (status_timer);
6507 logfile_top_uint (usage);
6508 logfile_top_uint (username);
6509 logfile_top_uint (version);
6510 logfile_top_uint (weak_hash_threshold);
6511 logfile_top_uint (workload_profile);
6512 logfile_top_uint64 (limit);
6513 logfile_top_uint64 (skip);
6514 logfile_top_char (separator);
6515 #ifndef OSX
6516 logfile_top_string (cpu_affinity);
6517 #endif
6518 logfile_top_string (custom_charset_1);
6519 logfile_top_string (custom_charset_2);
6520 logfile_top_string (custom_charset_3);
6521 logfile_top_string (custom_charset_4);
6522 logfile_top_string (debug_file);
6523 logfile_top_string (opencl_devices);
6524 logfile_top_string (opencl_platforms);
6525 logfile_top_string (opencl_device_types);
6526 logfile_top_uint (opencl_vector_width);
6527 logfile_top_string (induction_dir);
6528 logfile_top_string (markov_hcstat);
6529 logfile_top_string (outfile);
6530 logfile_top_string (outfile_check_dir);
6531 logfile_top_string (rule_buf_l);
6532 logfile_top_string (rule_buf_r);
6533 logfile_top_string (session);
6534 logfile_top_string (truecrypt_keyfiles);
6535
6536 /**
6537 * Init OpenCL library loader
6538 */
6539
6540 if (keyspace == 0)
6541 {
6542 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6543
6544 ocl_init(ocl);
6545
6546 data.ocl = ocl;
6547 }
6548
6549 /**
6550 * OpenCL platform selection
6551 */
6552
6553 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6554
6555 /**
6556 * OpenCL device selection
6557 */
6558
6559 u32 devices_filter = setup_devices_filter (opencl_devices);
6560
6561 /**
6562 * OpenCL device type selection
6563 */
6564
6565 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6566
6567 /**
6568 * benchmark
6569 */
6570
6571 if (benchmark == 1)
6572 {
6573 /**
6574 * disable useless stuff for benchmark
6575 */
6576
6577 restore_timer = 0;
6578 status_timer = 0;
6579 restore_disable = 1;
6580 potfile_disable = 1;
6581 weak_hash_threshold = 0;
6582
6583 data.restore_timer = restore_timer;
6584 data.status_timer = status_timer;
6585 data.restore_disable = restore_disable;
6586
6587 if (benchmark_mode == 1)
6588 {
6589 markov_disable = 1;
6590 }
6591
6592 /**
6593 * force attack mode to be bruteforce
6594 */
6595
6596 attack_mode = ATTACK_MODE_BF;
6597 attack_kern = ATTACK_KERN_BF;
6598
6599 if (runtime_chgd == 0)
6600 {
6601 runtime = 8;
6602
6603 if (benchmark_mode == 1) runtime = 17;
6604
6605 data.runtime = runtime;
6606 }
6607 }
6608
6609 /**
6610 * config
6611 */
6612
6613 uint hash_type = 0;
6614 uint salt_type = 0;
6615 uint attack_exec = 0;
6616 uint opts_type = 0;
6617 uint kern_type = 0;
6618 uint dgst_size = 0;
6619 uint esalt_size = 0;
6620 uint opti_type = 0;
6621 uint dgst_pos0 = -1;
6622 uint dgst_pos1 = -1;
6623 uint dgst_pos2 = -1;
6624 uint dgst_pos3 = -1;
6625
6626 int (*parse_func) (char *, uint, hash_t *);
6627 int (*sort_by_digest) (const void *, const void *);
6628
6629 uint algorithm_pos = 0;
6630 uint algorithm_max = 1;
6631
6632 uint *algorithms = default_benchmark_algorithms;
6633
6634 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6635
6636 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6637 {
6638 /*
6639 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6640 * the following algos are skipped entirely
6641 */
6642
6643 if (algorithm_pos > 0)
6644 {
6645 local_free (rd);
6646
6647 rd = init_restore (argc, argv);
6648
6649 data.rd = rd;
6650 }
6651
6652 /**
6653 * update hash_mode in case of multihash benchmark
6654 */
6655
6656 if (benchmark == 1)
6657 {
6658 if (hash_mode_chgd == 0)
6659 {
6660 hash_mode = algorithms[algorithm_pos];
6661
6662 data.hash_mode = hash_mode;
6663 }
6664
6665 quiet = 1;
6666
6667 data.quiet = quiet;
6668 }
6669
6670 switch (hash_mode)
6671 {
6672 case 0: hash_type = HASH_TYPE_MD5;
6673 salt_type = SALT_TYPE_NONE;
6674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6675 opts_type = OPTS_TYPE_PT_GENERATE_LE
6676 | OPTS_TYPE_PT_ADD80
6677 | OPTS_TYPE_PT_ADDBITS14;
6678 kern_type = KERN_TYPE_MD5;
6679 dgst_size = DGST_SIZE_4_4;
6680 parse_func = md5_parse_hash;
6681 sort_by_digest = sort_by_digest_4_4;
6682 opti_type = OPTI_TYPE_ZERO_BYTE
6683 | OPTI_TYPE_PRECOMPUTE_INIT
6684 | OPTI_TYPE_PRECOMPUTE_MERKLE
6685 | OPTI_TYPE_MEET_IN_MIDDLE
6686 | OPTI_TYPE_EARLY_SKIP
6687 | OPTI_TYPE_NOT_ITERATED
6688 | OPTI_TYPE_NOT_SALTED
6689 | OPTI_TYPE_RAW_HASH;
6690 dgst_pos0 = 0;
6691 dgst_pos1 = 3;
6692 dgst_pos2 = 2;
6693 dgst_pos3 = 1;
6694 break;
6695
6696 case 10: hash_type = HASH_TYPE_MD5;
6697 salt_type = SALT_TYPE_INTERN;
6698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6699 opts_type = OPTS_TYPE_PT_GENERATE_LE
6700 | OPTS_TYPE_ST_ADD80
6701 | OPTS_TYPE_ST_ADDBITS14;
6702 kern_type = KERN_TYPE_MD5_PWSLT;
6703 dgst_size = DGST_SIZE_4_4;
6704 parse_func = md5s_parse_hash;
6705 sort_by_digest = sort_by_digest_4_4;
6706 opti_type = OPTI_TYPE_ZERO_BYTE
6707 | OPTI_TYPE_PRECOMPUTE_INIT
6708 | OPTI_TYPE_PRECOMPUTE_MERKLE
6709 | OPTI_TYPE_MEET_IN_MIDDLE
6710 | OPTI_TYPE_EARLY_SKIP
6711 | OPTI_TYPE_NOT_ITERATED
6712 | OPTI_TYPE_APPENDED_SALT
6713 | OPTI_TYPE_RAW_HASH;
6714 dgst_pos0 = 0;
6715 dgst_pos1 = 3;
6716 dgst_pos2 = 2;
6717 dgst_pos3 = 1;
6718 break;
6719
6720 case 11: hash_type = HASH_TYPE_MD5;
6721 salt_type = SALT_TYPE_INTERN;
6722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6723 opts_type = OPTS_TYPE_PT_GENERATE_LE
6724 | OPTS_TYPE_ST_ADD80
6725 | OPTS_TYPE_ST_ADDBITS14;
6726 kern_type = KERN_TYPE_MD5_PWSLT;
6727 dgst_size = DGST_SIZE_4_4;
6728 parse_func = joomla_parse_hash;
6729 sort_by_digest = sort_by_digest_4_4;
6730 opti_type = OPTI_TYPE_ZERO_BYTE
6731 | OPTI_TYPE_PRECOMPUTE_INIT
6732 | OPTI_TYPE_PRECOMPUTE_MERKLE
6733 | OPTI_TYPE_MEET_IN_MIDDLE
6734 | OPTI_TYPE_EARLY_SKIP
6735 | OPTI_TYPE_NOT_ITERATED
6736 | OPTI_TYPE_APPENDED_SALT
6737 | OPTI_TYPE_RAW_HASH;
6738 dgst_pos0 = 0;
6739 dgst_pos1 = 3;
6740 dgst_pos2 = 2;
6741 dgst_pos3 = 1;
6742 break;
6743
6744 case 12: hash_type = HASH_TYPE_MD5;
6745 salt_type = SALT_TYPE_INTERN;
6746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6747 opts_type = OPTS_TYPE_PT_GENERATE_LE
6748 | OPTS_TYPE_ST_ADD80
6749 | OPTS_TYPE_ST_ADDBITS14;
6750 kern_type = KERN_TYPE_MD5_PWSLT;
6751 dgst_size = DGST_SIZE_4_4;
6752 parse_func = postgresql_parse_hash;
6753 sort_by_digest = sort_by_digest_4_4;
6754 opti_type = OPTI_TYPE_ZERO_BYTE
6755 | OPTI_TYPE_PRECOMPUTE_INIT
6756 | OPTI_TYPE_PRECOMPUTE_MERKLE
6757 | OPTI_TYPE_MEET_IN_MIDDLE
6758 | OPTI_TYPE_EARLY_SKIP
6759 | OPTI_TYPE_NOT_ITERATED
6760 | OPTI_TYPE_APPENDED_SALT
6761 | OPTI_TYPE_RAW_HASH;
6762 dgst_pos0 = 0;
6763 dgst_pos1 = 3;
6764 dgst_pos2 = 2;
6765 dgst_pos3 = 1;
6766 break;
6767
6768 case 20: hash_type = HASH_TYPE_MD5;
6769 salt_type = SALT_TYPE_INTERN;
6770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6771 opts_type = OPTS_TYPE_PT_GENERATE_LE
6772 | OPTS_TYPE_PT_ADD80
6773 | OPTS_TYPE_PT_ADDBITS14;
6774 kern_type = KERN_TYPE_MD5_SLTPW;
6775 dgst_size = DGST_SIZE_4_4;
6776 parse_func = md5s_parse_hash;
6777 sort_by_digest = sort_by_digest_4_4;
6778 opti_type = OPTI_TYPE_ZERO_BYTE
6779 | OPTI_TYPE_PRECOMPUTE_INIT
6780 | OPTI_TYPE_PRECOMPUTE_MERKLE
6781 | OPTI_TYPE_EARLY_SKIP
6782 | OPTI_TYPE_NOT_ITERATED
6783 | OPTI_TYPE_PREPENDED_SALT
6784 | OPTI_TYPE_RAW_HASH;
6785 dgst_pos0 = 0;
6786 dgst_pos1 = 3;
6787 dgst_pos2 = 2;
6788 dgst_pos3 = 1;
6789 break;
6790
6791 case 21: hash_type = HASH_TYPE_MD5;
6792 salt_type = SALT_TYPE_INTERN;
6793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6794 opts_type = OPTS_TYPE_PT_GENERATE_LE
6795 | OPTS_TYPE_PT_ADD80
6796 | OPTS_TYPE_PT_ADDBITS14;
6797 kern_type = KERN_TYPE_MD5_SLTPW;
6798 dgst_size = DGST_SIZE_4_4;
6799 parse_func = osc_parse_hash;
6800 sort_by_digest = sort_by_digest_4_4;
6801 opti_type = OPTI_TYPE_ZERO_BYTE
6802 | OPTI_TYPE_PRECOMPUTE_INIT
6803 | OPTI_TYPE_PRECOMPUTE_MERKLE
6804 | OPTI_TYPE_EARLY_SKIP
6805 | OPTI_TYPE_NOT_ITERATED
6806 | OPTI_TYPE_PREPENDED_SALT
6807 | OPTI_TYPE_RAW_HASH;
6808 dgst_pos0 = 0;
6809 dgst_pos1 = 3;
6810 dgst_pos2 = 2;
6811 dgst_pos3 = 1;
6812 break;
6813
6814 case 22: hash_type = HASH_TYPE_MD5;
6815 salt_type = SALT_TYPE_EMBEDDED;
6816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6817 opts_type = OPTS_TYPE_PT_GENERATE_LE
6818 | OPTS_TYPE_PT_ADD80
6819 | OPTS_TYPE_PT_ADDBITS14;
6820 kern_type = KERN_TYPE_MD5_SLTPW;
6821 dgst_size = DGST_SIZE_4_4;
6822 parse_func = netscreen_parse_hash;
6823 sort_by_digest = sort_by_digest_4_4;
6824 opti_type = OPTI_TYPE_ZERO_BYTE
6825 | OPTI_TYPE_PRECOMPUTE_INIT
6826 | OPTI_TYPE_PRECOMPUTE_MERKLE
6827 | OPTI_TYPE_EARLY_SKIP
6828 | OPTI_TYPE_NOT_ITERATED
6829 | OPTI_TYPE_PREPENDED_SALT
6830 | OPTI_TYPE_RAW_HASH;
6831 dgst_pos0 = 0;
6832 dgst_pos1 = 3;
6833 dgst_pos2 = 2;
6834 dgst_pos3 = 1;
6835 break;
6836
6837 case 23: hash_type = HASH_TYPE_MD5;
6838 salt_type = SALT_TYPE_EMBEDDED;
6839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6840 opts_type = OPTS_TYPE_PT_GENERATE_LE
6841 | OPTS_TYPE_PT_ADD80
6842 | OPTS_TYPE_PT_ADDBITS14;
6843 kern_type = KERN_TYPE_MD5_SLTPW;
6844 dgst_size = DGST_SIZE_4_4;
6845 parse_func = skype_parse_hash;
6846 sort_by_digest = sort_by_digest_4_4;
6847 opti_type = OPTI_TYPE_ZERO_BYTE
6848 | OPTI_TYPE_PRECOMPUTE_INIT
6849 | OPTI_TYPE_PRECOMPUTE_MERKLE
6850 | OPTI_TYPE_EARLY_SKIP
6851 | OPTI_TYPE_NOT_ITERATED
6852 | OPTI_TYPE_PREPENDED_SALT
6853 | OPTI_TYPE_RAW_HASH;
6854 dgst_pos0 = 0;
6855 dgst_pos1 = 3;
6856 dgst_pos2 = 2;
6857 dgst_pos3 = 1;
6858 break;
6859
6860 case 30: hash_type = HASH_TYPE_MD5;
6861 salt_type = SALT_TYPE_INTERN;
6862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6863 opts_type = OPTS_TYPE_PT_GENERATE_LE
6864 | OPTS_TYPE_PT_UNICODE
6865 | OPTS_TYPE_ST_ADD80
6866 | OPTS_TYPE_ST_ADDBITS14;
6867 kern_type = KERN_TYPE_MD5_PWUSLT;
6868 dgst_size = DGST_SIZE_4_4;
6869 parse_func = md5s_parse_hash;
6870 sort_by_digest = sort_by_digest_4_4;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_MEET_IN_MIDDLE
6875 | OPTI_TYPE_EARLY_SKIP
6876 | OPTI_TYPE_NOT_ITERATED
6877 | OPTI_TYPE_APPENDED_SALT
6878 | OPTI_TYPE_RAW_HASH;
6879 dgst_pos0 = 0;
6880 dgst_pos1 = 3;
6881 dgst_pos2 = 2;
6882 dgst_pos3 = 1;
6883 break;
6884
6885 case 40: hash_type = HASH_TYPE_MD5;
6886 salt_type = SALT_TYPE_INTERN;
6887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6888 opts_type = OPTS_TYPE_PT_GENERATE_LE
6889 | OPTS_TYPE_PT_ADD80
6890 | OPTS_TYPE_PT_ADDBITS14
6891 | OPTS_TYPE_PT_UNICODE;
6892 kern_type = KERN_TYPE_MD5_SLTPWU;
6893 dgst_size = DGST_SIZE_4_4;
6894 parse_func = md5s_parse_hash;
6895 sort_by_digest = sort_by_digest_4_4;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_EARLY_SKIP
6900 | OPTI_TYPE_NOT_ITERATED
6901 | OPTI_TYPE_PREPENDED_SALT
6902 | OPTI_TYPE_RAW_HASH;
6903 dgst_pos0 = 0;
6904 dgst_pos1 = 3;
6905 dgst_pos2 = 2;
6906 dgst_pos3 = 1;
6907 break;
6908
6909 case 50: hash_type = HASH_TYPE_MD5;
6910 salt_type = SALT_TYPE_INTERN;
6911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6912 opts_type = OPTS_TYPE_PT_GENERATE_LE
6913 | OPTS_TYPE_ST_ADD80
6914 | OPTS_TYPE_ST_ADDBITS14;
6915 kern_type = KERN_TYPE_HMACMD5_PW;
6916 dgst_size = DGST_SIZE_4_4;
6917 parse_func = hmacmd5_parse_hash;
6918 sort_by_digest = sort_by_digest_4_4;
6919 opti_type = OPTI_TYPE_ZERO_BYTE
6920 | OPTI_TYPE_NOT_ITERATED;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 60: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_PT_ADD80
6932 | OPTS_TYPE_PT_ADDBITS14;
6933 kern_type = KERN_TYPE_HMACMD5_SLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = hmacmd5_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_NOT_ITERATED;
6939 dgst_pos0 = 0;
6940 dgst_pos1 = 3;
6941 dgst_pos2 = 2;
6942 dgst_pos3 = 1;
6943 break;
6944
6945 case 100: hash_type = HASH_TYPE_SHA1;
6946 salt_type = SALT_TYPE_NONE;
6947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6948 opts_type = OPTS_TYPE_PT_GENERATE_BE
6949 | OPTS_TYPE_PT_ADD80
6950 | OPTS_TYPE_PT_ADDBITS15;
6951 kern_type = KERN_TYPE_SHA1;
6952 dgst_size = DGST_SIZE_4_5;
6953 parse_func = sha1_parse_hash;
6954 sort_by_digest = sort_by_digest_4_5;
6955 opti_type = OPTI_TYPE_ZERO_BYTE
6956 | OPTI_TYPE_PRECOMPUTE_INIT
6957 | OPTI_TYPE_PRECOMPUTE_MERKLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_NOT_SALTED
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 3;
6963 dgst_pos1 = 4;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 101: hash_type = HASH_TYPE_SHA1;
6969 salt_type = SALT_TYPE_NONE;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_BE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS15;
6974 kern_type = KERN_TYPE_SHA1;
6975 dgst_size = DGST_SIZE_4_5;
6976 parse_func = sha1b64_parse_hash;
6977 sort_by_digest = sort_by_digest_4_5;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_NOT_SALTED
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 3;
6986 dgst_pos1 = 4;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 110: hash_type = HASH_TYPE_SHA1;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_BE
6995 | OPTS_TYPE_ST_ADD80
6996 | OPTS_TYPE_ST_ADDBITS15;
6997 kern_type = KERN_TYPE_SHA1_PWSLT;
6998 dgst_size = DGST_SIZE_4_5;
6999 parse_func = sha1s_parse_hash;
7000 sort_by_digest = sort_by_digest_4_5;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_APPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 3;
7009 dgst_pos1 = 4;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 111: hash_type = HASH_TYPE_SHA1;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_BE
7018 | OPTS_TYPE_ST_ADD80
7019 | OPTS_TYPE_ST_ADDBITS15;
7020 kern_type = KERN_TYPE_SHA1_PWSLT;
7021 dgst_size = DGST_SIZE_4_5;
7022 parse_func = sha1b64s_parse_hash;
7023 sort_by_digest = sort_by_digest_4_5;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_APPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 3;
7032 dgst_pos1 = 4;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 112: hash_type = HASH_TYPE_SHA1;
7038 salt_type = SALT_TYPE_INTERN;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_BE
7041 | OPTS_TYPE_ST_ADD80
7042 | OPTS_TYPE_ST_ADDBITS15
7043 | OPTS_TYPE_ST_HEX;
7044 kern_type = KERN_TYPE_SHA1_PWSLT;
7045 dgst_size = DGST_SIZE_4_5;
7046 parse_func = oracles_parse_hash;
7047 sort_by_digest = sort_by_digest_4_5;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 3;
7056 dgst_pos1 = 4;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 120: hash_type = HASH_TYPE_SHA1;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_BE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS15;
7067 kern_type = KERN_TYPE_SHA1_SLTPW;
7068 dgst_size = DGST_SIZE_4_5;
7069 parse_func = sha1s_parse_hash;
7070 sort_by_digest = sort_by_digest_4_5;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_PREPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 3;
7079 dgst_pos1 = 4;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 121: hash_type = HASH_TYPE_SHA1;
7085 salt_type = SALT_TYPE_INTERN;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_BE
7088 | OPTS_TYPE_PT_ADD80
7089 | OPTS_TYPE_PT_ADDBITS15
7090 | OPTS_TYPE_ST_LOWER;
7091 kern_type = KERN_TYPE_SHA1_SLTPW;
7092 dgst_size = DGST_SIZE_4_5;
7093 parse_func = smf_parse_hash;
7094 sort_by_digest = sort_by_digest_4_5;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_PRECOMPUTE_INIT
7097 | OPTI_TYPE_PRECOMPUTE_MERKLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_PREPENDED_SALT
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 3;
7103 dgst_pos1 = 4;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 122: hash_type = HASH_TYPE_SHA1;
7109 salt_type = SALT_TYPE_EMBEDDED;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_BE
7112 | OPTS_TYPE_PT_ADD80
7113 | OPTS_TYPE_PT_ADDBITS15
7114 | OPTS_TYPE_ST_HEX;
7115 kern_type = KERN_TYPE_SHA1_SLTPW;
7116 dgst_size = DGST_SIZE_4_5;
7117 parse_func = osx1_parse_hash;
7118 sort_by_digest = sort_by_digest_4_5;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_PRECOMPUTE_INIT
7121 | OPTI_TYPE_PRECOMPUTE_MERKLE
7122 | OPTI_TYPE_EARLY_SKIP
7123 | OPTI_TYPE_NOT_ITERATED
7124 | OPTI_TYPE_PREPENDED_SALT
7125 | OPTI_TYPE_RAW_HASH;
7126 dgst_pos0 = 3;
7127 dgst_pos1 = 4;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 124: hash_type = HASH_TYPE_SHA1;
7133 salt_type = SALT_TYPE_EMBEDDED;
7134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7135 opts_type = OPTS_TYPE_PT_GENERATE_BE
7136 | OPTS_TYPE_PT_ADD80
7137 | OPTS_TYPE_PT_ADDBITS15;
7138 kern_type = KERN_TYPE_SHA1_SLTPW;
7139 dgst_size = DGST_SIZE_4_5;
7140 parse_func = djangosha1_parse_hash;
7141 sort_by_digest = sort_by_digest_4_5;
7142 opti_type = OPTI_TYPE_ZERO_BYTE
7143 | OPTI_TYPE_PRECOMPUTE_INIT
7144 | OPTI_TYPE_PRECOMPUTE_MERKLE
7145 | OPTI_TYPE_EARLY_SKIP
7146 | OPTI_TYPE_NOT_ITERATED
7147 | OPTI_TYPE_PREPENDED_SALT
7148 | OPTI_TYPE_RAW_HASH;
7149 dgst_pos0 = 3;
7150 dgst_pos1 = 4;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 130: hash_type = HASH_TYPE_SHA1;
7156 salt_type = SALT_TYPE_INTERN;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_BE
7159 | OPTS_TYPE_PT_UNICODE
7160 | OPTS_TYPE_ST_ADD80
7161 | OPTS_TYPE_ST_ADDBITS15;
7162 kern_type = KERN_TYPE_SHA1_PWUSLT;
7163 dgst_size = DGST_SIZE_4_5;
7164 parse_func = sha1s_parse_hash;
7165 sort_by_digest = sort_by_digest_4_5;
7166 opti_type = OPTI_TYPE_ZERO_BYTE
7167 | OPTI_TYPE_PRECOMPUTE_INIT
7168 | OPTI_TYPE_PRECOMPUTE_MERKLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_APPENDED_SALT
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 131: hash_type = HASH_TYPE_SHA1;
7180 salt_type = SALT_TYPE_EMBEDDED;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_BE
7183 | OPTS_TYPE_PT_UNICODE
7184 | OPTS_TYPE_PT_UPPER
7185 | OPTS_TYPE_ST_ADD80
7186 | OPTS_TYPE_ST_ADDBITS15
7187 | OPTS_TYPE_ST_HEX;
7188 kern_type = KERN_TYPE_SHA1_PWUSLT;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = mssql2000_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_APPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 132: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_EMBEDDED;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_PT_UNICODE
7210 | OPTS_TYPE_ST_ADD80
7211 | OPTS_TYPE_ST_ADDBITS15
7212 | OPTS_TYPE_ST_HEX;
7213 kern_type = KERN_TYPE_SHA1_PWUSLT;
7214 dgst_size = DGST_SIZE_4_5;
7215 parse_func = mssql2005_parse_hash;
7216 sort_by_digest = sort_by_digest_4_5;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_APPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 4;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 133: hash_type = HASH_TYPE_SHA1;
7231 salt_type = SALT_TYPE_EMBEDDED;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_PT_UNICODE
7235 | OPTS_TYPE_ST_ADD80
7236 | OPTS_TYPE_ST_ADDBITS15;
7237 kern_type = KERN_TYPE_SHA1_PWUSLT;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = peoplesoft_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 140: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15
7260 | OPTS_TYPE_PT_UNICODE;
7261 kern_type = KERN_TYPE_SHA1_SLTPWU;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = sha1s_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 141: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_EMBEDDED;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15
7284 | OPTS_TYPE_PT_UNICODE
7285 | OPTS_TYPE_ST_BASE64;
7286 kern_type = KERN_TYPE_SHA1_SLTPWU;
7287 dgst_size = DGST_SIZE_4_5;
7288 parse_func = episerver_parse_hash;
7289 sort_by_digest = sort_by_digest_4_5;
7290 opti_type = OPTI_TYPE_ZERO_BYTE
7291 | OPTI_TYPE_PRECOMPUTE_INIT
7292 | OPTI_TYPE_PRECOMPUTE_MERKLE
7293 | OPTI_TYPE_EARLY_SKIP
7294 | OPTI_TYPE_NOT_ITERATED
7295 | OPTI_TYPE_PREPENDED_SALT
7296 | OPTI_TYPE_RAW_HASH;
7297 dgst_pos0 = 3;
7298 dgst_pos1 = 4;
7299 dgst_pos2 = 2;
7300 dgst_pos3 = 1;
7301 break;
7302
7303 case 150: hash_type = HASH_TYPE_SHA1;
7304 salt_type = SALT_TYPE_INTERN;
7305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7306 opts_type = OPTS_TYPE_PT_GENERATE_BE
7307 | OPTS_TYPE_ST_ADD80
7308 | OPTS_TYPE_ST_ADDBITS15;
7309 kern_type = KERN_TYPE_HMACSHA1_PW;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = hmacsha1_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_NOT_ITERATED;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 160: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_INTERN;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_ADD80
7326 | OPTS_TYPE_PT_ADDBITS15;
7327 kern_type = KERN_TYPE_HMACSHA1_SLT;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = hmacsha1_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_NOT_ITERATED;
7333 dgst_pos0 = 3;
7334 dgst_pos1 = 4;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 1;
7337 break;
7338
7339 case 190: hash_type = HASH_TYPE_SHA1;
7340 salt_type = SALT_TYPE_NONE;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_BE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS15;
7345 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = sha1linkedin_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_NOT_SALTED;
7354 dgst_pos0 = 0;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 3;
7357 dgst_pos3 = 2;
7358 break;
7359
7360 case 200: hash_type = HASH_TYPE_MYSQL;
7361 salt_type = SALT_TYPE_NONE;
7362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7363 opts_type = 0;
7364 kern_type = KERN_TYPE_MYSQL;
7365 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7366 parse_func = mysql323_parse_hash;
7367 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7368 opti_type = OPTI_TYPE_ZERO_BYTE;
7369 dgst_pos0 = 0;
7370 dgst_pos1 = 1;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 3;
7373 break;
7374
7375 case 300: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_NONE;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_ADD80
7380 | OPTS_TYPE_PT_ADDBITS15;
7381 kern_type = KERN_TYPE_MYSQL41;
7382 dgst_size = DGST_SIZE_4_5;
7383 parse_func = sha1_parse_hash;
7384 sort_by_digest = sort_by_digest_4_5;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED
7390 | OPTI_TYPE_NOT_SALTED;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 400: hash_type = HASH_TYPE_MD5;
7398 salt_type = SALT_TYPE_EMBEDDED;
7399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7401 kern_type = KERN_TYPE_PHPASS;
7402 dgst_size = DGST_SIZE_4_4;
7403 parse_func = phpass_parse_hash;
7404 sort_by_digest = sort_by_digest_4_4;
7405 opti_type = OPTI_TYPE_ZERO_BYTE;
7406 dgst_pos0 = 0;
7407 dgst_pos1 = 1;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 3;
7410 break;
7411
7412 case 500: hash_type = HASH_TYPE_MD5;
7413 salt_type = SALT_TYPE_EMBEDDED;
7414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7416 kern_type = KERN_TYPE_MD5CRYPT;
7417 dgst_size = DGST_SIZE_4_4;
7418 parse_func = md5crypt_parse_hash;
7419 sort_by_digest = sort_by_digest_4_4;
7420 opti_type = OPTI_TYPE_ZERO_BYTE;
7421 dgst_pos0 = 0;
7422 dgst_pos1 = 1;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 3;
7425 break;
7426
7427 case 501: hash_type = HASH_TYPE_MD5;
7428 salt_type = SALT_TYPE_EMBEDDED;
7429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_LE
7431 | OPTS_TYPE_HASH_COPY;
7432 kern_type = KERN_TYPE_MD5CRYPT;
7433 dgst_size = DGST_SIZE_4_4;
7434 parse_func = juniper_parse_hash;
7435 sort_by_digest = sort_by_digest_4_4;
7436 opti_type = OPTI_TYPE_ZERO_BYTE;
7437 dgst_pos0 = 0;
7438 dgst_pos1 = 1;
7439 dgst_pos2 = 2;
7440 dgst_pos3 = 3;
7441 break;
7442
7443 case 900: hash_type = HASH_TYPE_MD4;
7444 salt_type = SALT_TYPE_NONE;
7445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7446 opts_type = OPTS_TYPE_PT_GENERATE_LE
7447 | OPTS_TYPE_PT_ADD80
7448 | OPTS_TYPE_PT_ADDBITS14;
7449 kern_type = KERN_TYPE_MD4;
7450 dgst_size = DGST_SIZE_4_4;
7451 parse_func = md4_parse_hash;
7452 sort_by_digest = sort_by_digest_4_4;
7453 opti_type = OPTI_TYPE_ZERO_BYTE
7454 | OPTI_TYPE_PRECOMPUTE_INIT
7455 | OPTI_TYPE_PRECOMPUTE_MERKLE
7456 | OPTI_TYPE_MEET_IN_MIDDLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_NOT_SALTED
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 0;
7462 dgst_pos1 = 3;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 1000: hash_type = HASH_TYPE_MD4;
7468 salt_type = SALT_TYPE_NONE;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_LE
7471 | OPTS_TYPE_PT_ADD80
7472 | OPTS_TYPE_PT_ADDBITS14
7473 | OPTS_TYPE_PT_UNICODE;
7474 kern_type = KERN_TYPE_MD4_PWU;
7475 dgst_size = DGST_SIZE_4_4;
7476 parse_func = md4_parse_hash;
7477 sort_by_digest = sort_by_digest_4_4;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_MEET_IN_MIDDLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_NOT_SALTED
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 0;
7487 dgst_pos1 = 3;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 1100: hash_type = HASH_TYPE_MD4;
7493 salt_type = SALT_TYPE_INTERN;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_LE
7496 | OPTS_TYPE_PT_ADD80
7497 | OPTS_TYPE_PT_ADDBITS14
7498 | OPTS_TYPE_PT_UNICODE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_UNICODE
7501 | OPTS_TYPE_ST_LOWER;
7502 kern_type = KERN_TYPE_MD44_PWUSLT;
7503 dgst_size = DGST_SIZE_4_4;
7504 parse_func = dcc_parse_hash;
7505 sort_by_digest = sort_by_digest_4_4;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 1400: hash_type = HASH_TYPE_SHA256;
7518 salt_type = SALT_TYPE_NONE;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_BE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS15;
7523 kern_type = KERN_TYPE_SHA256;
7524 dgst_size = DGST_SIZE_4_8;
7525 parse_func = sha256_parse_hash;
7526 sort_by_digest = sort_by_digest_4_8;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_NOT_SALTED
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 3;
7535 dgst_pos1 = 7;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 6;
7538 break;
7539
7540 case 1410: hash_type = HASH_TYPE_SHA256;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_BE
7544 | OPTS_TYPE_ST_ADD80
7545 | OPTS_TYPE_ST_ADDBITS15;
7546 kern_type = KERN_TYPE_SHA256_PWSLT;
7547 dgst_size = DGST_SIZE_4_8;
7548 parse_func = sha256s_parse_hash;
7549 sort_by_digest = sort_by_digest_4_8;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_PRECOMPUTE_INIT
7552 | OPTI_TYPE_PRECOMPUTE_MERKLE
7553 | OPTI_TYPE_EARLY_SKIP
7554 | OPTI_TYPE_NOT_ITERATED
7555 | OPTI_TYPE_APPENDED_SALT
7556 | OPTI_TYPE_RAW_HASH;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 7;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 6;
7561 break;
7562
7563 case 1420: hash_type = HASH_TYPE_SHA256;
7564 salt_type = SALT_TYPE_INTERN;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_SHA256_SLTPW;
7570 dgst_size = DGST_SIZE_4_8;
7571 parse_func = sha256s_parse_hash;
7572 sort_by_digest = sort_by_digest_4_8;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_PRECOMPUTE_MERKLE
7576 | OPTI_TYPE_EARLY_SKIP
7577 | OPTI_TYPE_NOT_ITERATED
7578 | OPTI_TYPE_PREPENDED_SALT
7579 | OPTI_TYPE_RAW_HASH;
7580 dgst_pos0 = 3;
7581 dgst_pos1 = 7;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 6;
7584 break;
7585
7586 case 1421: hash_type = HASH_TYPE_SHA256;
7587 salt_type = SALT_TYPE_EMBEDDED;
7588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_BE
7590 | OPTS_TYPE_PT_ADD80
7591 | OPTS_TYPE_PT_ADDBITS15;
7592 kern_type = KERN_TYPE_SHA256_SLTPW;
7593 dgst_size = DGST_SIZE_4_8;
7594 parse_func = hmailserver_parse_hash;
7595 sort_by_digest = sort_by_digest_4_8;
7596 opti_type = OPTI_TYPE_ZERO_BYTE
7597 | OPTI_TYPE_PRECOMPUTE_INIT
7598 | OPTI_TYPE_PRECOMPUTE_MERKLE
7599 | OPTI_TYPE_EARLY_SKIP
7600 | OPTI_TYPE_NOT_ITERATED
7601 | OPTI_TYPE_PREPENDED_SALT
7602 | OPTI_TYPE_RAW_HASH;
7603 dgst_pos0 = 3;
7604 dgst_pos1 = 7;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 6;
7607 break;
7608
7609 case 1430: hash_type = HASH_TYPE_SHA256;
7610 salt_type = SALT_TYPE_INTERN;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_BE
7613 | OPTS_TYPE_PT_UNICODE
7614 | OPTS_TYPE_ST_ADD80
7615 | OPTS_TYPE_ST_ADDBITS15;
7616 kern_type = KERN_TYPE_SHA256_PWUSLT;
7617 dgst_size = DGST_SIZE_4_8;
7618 parse_func = sha256s_parse_hash;
7619 sort_by_digest = sort_by_digest_4_8;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_APPENDED_SALT
7626 | OPTI_TYPE_RAW_HASH;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 7;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 6;
7631 break;
7632
7633 case 1440: hash_type = HASH_TYPE_SHA256;
7634 salt_type = SALT_TYPE_INTERN;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS15
7639 | OPTS_TYPE_PT_UNICODE;
7640 kern_type = KERN_TYPE_SHA256_SLTPWU;
7641 dgst_size = DGST_SIZE_4_8;
7642 parse_func = sha256s_parse_hash;
7643 sort_by_digest = sort_by_digest_4_8;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_PREPENDED_SALT
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 3;
7652 dgst_pos1 = 7;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 6;
7655 break;
7656
7657 case 1441: hash_type = HASH_TYPE_SHA256;
7658 salt_type = SALT_TYPE_EMBEDDED;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS15
7663 | OPTS_TYPE_PT_UNICODE
7664 | OPTS_TYPE_ST_BASE64;
7665 kern_type = KERN_TYPE_SHA256_SLTPWU;
7666 dgst_size = DGST_SIZE_4_8;
7667 parse_func = episerver4_parse_hash;
7668 sort_by_digest = sort_by_digest_4_8;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_PRECOMPUTE_INIT
7671 | OPTI_TYPE_PRECOMPUTE_MERKLE
7672 | OPTI_TYPE_EARLY_SKIP
7673 | OPTI_TYPE_NOT_ITERATED
7674 | OPTI_TYPE_PREPENDED_SALT
7675 | OPTI_TYPE_RAW_HASH;
7676 dgst_pos0 = 3;
7677 dgst_pos1 = 7;
7678 dgst_pos2 = 2;
7679 dgst_pos3 = 6;
7680 break;
7681
7682 case 1450: hash_type = HASH_TYPE_SHA256;
7683 salt_type = SALT_TYPE_INTERN;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_BE
7686 | OPTS_TYPE_ST_ADD80;
7687 kern_type = KERN_TYPE_HMACSHA256_PW;
7688 dgst_size = DGST_SIZE_4_8;
7689 parse_func = hmacsha256_parse_hash;
7690 sort_by_digest = sort_by_digest_4_8;
7691 opti_type = OPTI_TYPE_ZERO_BYTE
7692 | OPTI_TYPE_NOT_ITERATED;
7693 dgst_pos0 = 3;
7694 dgst_pos1 = 7;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 6;
7697 break;
7698
7699 case 1460: hash_type = HASH_TYPE_SHA256;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_BE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS15;
7705 kern_type = KERN_TYPE_HMACSHA256_SLT;
7706 dgst_size = DGST_SIZE_4_8;
7707 parse_func = hmacsha256_parse_hash;
7708 sort_by_digest = sort_by_digest_4_8;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_NOT_ITERATED;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 7;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 6;
7715 break;
7716
7717 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7718 salt_type = SALT_TYPE_EMBEDDED;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_LE
7721 | OPTS_TYPE_PT_BITSLICE;
7722 kern_type = KERN_TYPE_DESCRYPT;
7723 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7724 parse_func = descrypt_parse_hash;
7725 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7728 dgst_pos0 = 0;
7729 dgst_pos1 = 1;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 3;
7732 break;
7733
7734 case 1600: hash_type = HASH_TYPE_MD5;
7735 salt_type = SALT_TYPE_EMBEDDED;
7736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7738 kern_type = KERN_TYPE_APR1CRYPT;
7739 dgst_size = DGST_SIZE_4_4;
7740 parse_func = md5apr1_parse_hash;
7741 sort_by_digest = sort_by_digest_4_4;
7742 opti_type = OPTI_TYPE_ZERO_BYTE;
7743 dgst_pos0 = 0;
7744 dgst_pos1 = 1;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 3;
7747 break;
7748
7749 case 1700: hash_type = HASH_TYPE_SHA512;
7750 salt_type = SALT_TYPE_NONE;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA512;
7756 dgst_size = DGST_SIZE_8_8;
7757 parse_func = sha512_parse_hash;
7758 sort_by_digest = sort_by_digest_8_8;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_PRECOMPUTE_MERKLE
7762 | OPTI_TYPE_EARLY_SKIP
7763 | OPTI_TYPE_NOT_ITERATED
7764 | OPTI_TYPE_NOT_SALTED
7765 | OPTI_TYPE_USES_BITS_64
7766 | OPTI_TYPE_RAW_HASH;
7767 dgst_pos0 = 14;
7768 dgst_pos1 = 15;
7769 dgst_pos2 = 6;
7770 dgst_pos3 = 7;
7771 break;
7772
7773 case 1710: hash_type = HASH_TYPE_SHA512;
7774 salt_type = SALT_TYPE_INTERN;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_ST_ADD80
7778 | OPTS_TYPE_ST_ADDBITS15;
7779 kern_type = KERN_TYPE_SHA512_PWSLT;
7780 dgst_size = DGST_SIZE_8_8;
7781 parse_func = sha512s_parse_hash;
7782 sort_by_digest = sort_by_digest_8_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_APPENDED_SALT
7789 | OPTI_TYPE_USES_BITS_64
7790 | OPTI_TYPE_RAW_HASH;
7791 dgst_pos0 = 14;
7792 dgst_pos1 = 15;
7793 dgst_pos2 = 6;
7794 dgst_pos3 = 7;
7795 break;
7796
7797 case 1711: hash_type = HASH_TYPE_SHA512;
7798 salt_type = SALT_TYPE_EMBEDDED;
7799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7800 opts_type = OPTS_TYPE_PT_GENERATE_BE
7801 | OPTS_TYPE_ST_ADD80
7802 | OPTS_TYPE_ST_ADDBITS15;
7803 kern_type = KERN_TYPE_SHA512_PWSLT;
7804 dgst_size = DGST_SIZE_8_8;
7805 parse_func = sha512b64s_parse_hash;
7806 sort_by_digest = sort_by_digest_8_8;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_APPENDED_SALT
7813 | OPTI_TYPE_USES_BITS_64
7814 | OPTI_TYPE_RAW_HASH;
7815 dgst_pos0 = 14;
7816 dgst_pos1 = 15;
7817 dgst_pos2 = 6;
7818 dgst_pos3 = 7;
7819 break;
7820
7821 case 1720: hash_type = HASH_TYPE_SHA512;
7822 salt_type = SALT_TYPE_INTERN;
7823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_BE
7825 | OPTS_TYPE_PT_ADD80
7826 | OPTS_TYPE_PT_ADDBITS15;
7827 kern_type = KERN_TYPE_SHA512_SLTPW;
7828 dgst_size = DGST_SIZE_8_8;
7829 parse_func = sha512s_parse_hash;
7830 sort_by_digest = sort_by_digest_8_8;
7831 opti_type = OPTI_TYPE_ZERO_BYTE
7832 | OPTI_TYPE_PRECOMPUTE_INIT
7833 | OPTI_TYPE_PRECOMPUTE_MERKLE
7834 | OPTI_TYPE_EARLY_SKIP
7835 | OPTI_TYPE_NOT_ITERATED
7836 | OPTI_TYPE_PREPENDED_SALT
7837 | OPTI_TYPE_USES_BITS_64
7838 | OPTI_TYPE_RAW_HASH;
7839 dgst_pos0 = 14;
7840 dgst_pos1 = 15;
7841 dgst_pos2 = 6;
7842 dgst_pos3 = 7;
7843 break;
7844
7845 case 1722: hash_type = HASH_TYPE_SHA512;
7846 salt_type = SALT_TYPE_EMBEDDED;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_ADD80
7850 | OPTS_TYPE_PT_ADDBITS15
7851 | OPTS_TYPE_ST_HEX;
7852 kern_type = KERN_TYPE_SHA512_SLTPW;
7853 dgst_size = DGST_SIZE_8_8;
7854 parse_func = osx512_parse_hash;
7855 sort_by_digest = sort_by_digest_8_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_PREPENDED_SALT
7862 | OPTI_TYPE_USES_BITS_64
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 14;
7865 dgst_pos1 = 15;
7866 dgst_pos2 = 6;
7867 dgst_pos3 = 7;
7868 break;
7869
7870 case 1730: hash_type = HASH_TYPE_SHA512;
7871 salt_type = SALT_TYPE_INTERN;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_UNICODE
7875 | OPTS_TYPE_ST_ADD80
7876 | OPTS_TYPE_ST_ADDBITS15;
7877 kern_type = KERN_TYPE_SHA512_PWSLTU;
7878 dgst_size = DGST_SIZE_8_8;
7879 parse_func = sha512s_parse_hash;
7880 sort_by_digest = sort_by_digest_8_8;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_APPENDED_SALT
7887 | OPTI_TYPE_USES_BITS_64
7888 | OPTI_TYPE_RAW_HASH;
7889 dgst_pos0 = 14;
7890 dgst_pos1 = 15;
7891 dgst_pos2 = 6;
7892 dgst_pos3 = 7;
7893 break;
7894
7895 case 1731: hash_type = HASH_TYPE_SHA512;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_BE
7899 | OPTS_TYPE_PT_UNICODE
7900 | OPTS_TYPE_ST_ADD80
7901 | OPTS_TYPE_ST_ADDBITS15
7902 | OPTS_TYPE_ST_HEX;
7903 kern_type = KERN_TYPE_SHA512_PWSLTU;
7904 dgst_size = DGST_SIZE_8_8;
7905 parse_func = mssql2012_parse_hash;
7906 sort_by_digest = sort_by_digest_8_8;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_EARLY_SKIP
7911 | OPTI_TYPE_NOT_ITERATED
7912 | OPTI_TYPE_APPENDED_SALT
7913 | OPTI_TYPE_USES_BITS_64
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 14;
7916 dgst_pos1 = 15;
7917 dgst_pos2 = 6;
7918 dgst_pos3 = 7;
7919 break;
7920
7921 case 1740: hash_type = HASH_TYPE_SHA512;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15
7927 | OPTS_TYPE_PT_UNICODE;
7928 kern_type = KERN_TYPE_SHA512_SLTPWU;
7929 dgst_size = DGST_SIZE_8_8;
7930 parse_func = sha512s_parse_hash;
7931 sort_by_digest = sort_by_digest_8_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_USES_BITS_64
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 14;
7941 dgst_pos1 = 15;
7942 dgst_pos2 = 6;
7943 dgst_pos3 = 7;
7944 break;
7945
7946 case 1750: hash_type = HASH_TYPE_SHA512;
7947 salt_type = SALT_TYPE_INTERN;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_ST_ADD80;
7951 kern_type = KERN_TYPE_HMACSHA512_PW;
7952 dgst_size = DGST_SIZE_8_8;
7953 parse_func = hmacsha512_parse_hash;
7954 sort_by_digest = sort_by_digest_8_8;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_USES_BITS_64
7957 | OPTI_TYPE_NOT_ITERATED;
7958 dgst_pos0 = 14;
7959 dgst_pos1 = 15;
7960 dgst_pos2 = 6;
7961 dgst_pos3 = 7;
7962 break;
7963
7964 case 1760: hash_type = HASH_TYPE_SHA512;
7965 salt_type = SALT_TYPE_INTERN;
7966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7967 opts_type = OPTS_TYPE_PT_GENERATE_BE
7968 | OPTS_TYPE_PT_ADD80
7969 | OPTS_TYPE_PT_ADDBITS15;
7970 kern_type = KERN_TYPE_HMACSHA512_SLT;
7971 dgst_size = DGST_SIZE_8_8;
7972 parse_func = hmacsha512_parse_hash;
7973 sort_by_digest = sort_by_digest_8_8;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_USES_BITS_64
7976 | OPTI_TYPE_NOT_ITERATED;
7977 dgst_pos0 = 14;
7978 dgst_pos1 = 15;
7979 dgst_pos2 = 6;
7980 dgst_pos3 = 7;
7981 break;
7982
7983 case 1800: hash_type = HASH_TYPE_SHA512;
7984 salt_type = SALT_TYPE_EMBEDDED;
7985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7986 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7987 kern_type = KERN_TYPE_SHA512CRYPT;
7988 dgst_size = DGST_SIZE_8_8;
7989 parse_func = sha512crypt_parse_hash;
7990 sort_by_digest = sort_by_digest_8_8;
7991 opti_type = OPTI_TYPE_ZERO_BYTE
7992 | OPTI_TYPE_USES_BITS_64;
7993 dgst_pos0 = 0;
7994 dgst_pos1 = 1;
7995 dgst_pos2 = 2;
7996 dgst_pos3 = 3;
7997 break;
7998
7999 case 2100: hash_type = HASH_TYPE_DCC2;
8000 salt_type = SALT_TYPE_EMBEDDED;
8001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_ST_LOWER
8004 | OPTS_TYPE_ST_UNICODE;
8005 kern_type = KERN_TYPE_DCC2;
8006 dgst_size = DGST_SIZE_4_4;
8007 parse_func = dcc2_parse_hash;
8008 sort_by_digest = sort_by_digest_4_4;
8009 opti_type = OPTI_TYPE_ZERO_BYTE;
8010 dgst_pos0 = 0;
8011 dgst_pos1 = 1;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 3;
8014 break;
8015
8016 case 2400: hash_type = HASH_TYPE_MD5;
8017 salt_type = SALT_TYPE_NONE;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8020 kern_type = KERN_TYPE_MD5PIX;
8021 dgst_size = DGST_SIZE_4_4;
8022 parse_func = md5pix_parse_hash;
8023 sort_by_digest = sort_by_digest_4_4;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_NOT_SALTED;
8030 dgst_pos0 = 0;
8031 dgst_pos1 = 3;
8032 dgst_pos2 = 2;
8033 dgst_pos3 = 1;
8034 break;
8035
8036 case 2410: hash_type = HASH_TYPE_MD5;
8037 salt_type = SALT_TYPE_INTERN;
8038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8040 kern_type = KERN_TYPE_MD5ASA;
8041 dgst_size = DGST_SIZE_4_4;
8042 parse_func = md5asa_parse_hash;
8043 sort_by_digest = sort_by_digest_4_4;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED;
8049 dgst_pos0 = 0;
8050 dgst_pos1 = 3;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 1;
8053 break;
8054
8055 case 2500: hash_type = HASH_TYPE_WPA;
8056 salt_type = SALT_TYPE_EMBEDDED;
8057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8059 kern_type = KERN_TYPE_WPA;
8060 dgst_size = DGST_SIZE_4_4;
8061 parse_func = wpa_parse_hash;
8062 sort_by_digest = sort_by_digest_4_4;
8063 opti_type = OPTI_TYPE_ZERO_BYTE;
8064 dgst_pos0 = 0;
8065 dgst_pos1 = 1;
8066 dgst_pos2 = 2;
8067 dgst_pos3 = 3;
8068 break;
8069
8070 case 2600: hash_type = HASH_TYPE_MD5;
8071 salt_type = SALT_TYPE_VIRTUAL;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_LE
8074 | OPTS_TYPE_PT_ADD80
8075 | OPTS_TYPE_PT_ADDBITS14
8076 | OPTS_TYPE_ST_ADD80;
8077 kern_type = KERN_TYPE_MD55_PWSLT1;
8078 dgst_size = DGST_SIZE_4_4;
8079 parse_func = md5md5_parse_hash;
8080 sort_by_digest = sort_by_digest_4_4;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP;
8085 dgst_pos0 = 0;
8086 dgst_pos1 = 3;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 1;
8089 break;
8090
8091 case 2611: hash_type = HASH_TYPE_MD5;
8092 salt_type = SALT_TYPE_INTERN;
8093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_LE
8095 | OPTS_TYPE_PT_ADD80
8096 | OPTS_TYPE_PT_ADDBITS14
8097 | OPTS_TYPE_ST_ADD80;
8098 kern_type = KERN_TYPE_MD55_PWSLT1;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = vb3_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP;
8106 dgst_pos0 = 0;
8107 dgst_pos1 = 3;
8108 dgst_pos2 = 2;
8109 dgst_pos3 = 1;
8110 break;
8111
8112 case 2612: hash_type = HASH_TYPE_MD5;
8113 salt_type = SALT_TYPE_EMBEDDED;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_LE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS14
8118 | OPTS_TYPE_ST_ADD80
8119 | OPTS_TYPE_ST_HEX;
8120 kern_type = KERN_TYPE_MD55_PWSLT1;
8121 dgst_size = DGST_SIZE_4_4;
8122 parse_func = phps_parse_hash;
8123 sort_by_digest = sort_by_digest_4_4;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP;
8128 dgst_pos0 = 0;
8129 dgst_pos1 = 3;
8130 dgst_pos2 = 2;
8131 dgst_pos3 = 1;
8132 break;
8133
8134 case 2711: hash_type = HASH_TYPE_MD5;
8135 salt_type = SALT_TYPE_INTERN;
8136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE
8138 | OPTS_TYPE_PT_ADD80
8139 | OPTS_TYPE_PT_ADDBITS14
8140 | OPTS_TYPE_ST_ADD80;
8141 kern_type = KERN_TYPE_MD55_PWSLT2;
8142 dgst_size = DGST_SIZE_4_4;
8143 parse_func = vb30_parse_hash;
8144 sort_by_digest = sort_by_digest_4_4;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_EARLY_SKIP;
8148 dgst_pos0 = 0;
8149 dgst_pos1 = 3;
8150 dgst_pos2 = 2;
8151 dgst_pos3 = 1;
8152 break;
8153
8154 case 2811: hash_type = HASH_TYPE_MD5;
8155 salt_type = SALT_TYPE_INTERN;
8156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8157 opts_type = OPTS_TYPE_PT_GENERATE_LE
8158 | OPTS_TYPE_PT_ADD80
8159 | OPTS_TYPE_PT_ADDBITS14;
8160 kern_type = KERN_TYPE_MD55_SLTPW;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = ipb2_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_EARLY_SKIP;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 3;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 1;
8171 break;
8172
8173 case 3000: hash_type = HASH_TYPE_LM;
8174 salt_type = SALT_TYPE_NONE;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE
8177 | OPTS_TYPE_PT_UPPER
8178 | OPTS_TYPE_PT_BITSLICE;
8179 kern_type = KERN_TYPE_LM;
8180 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8181 parse_func = lm_parse_hash;
8182 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8185 dgst_pos0 = 0;
8186 dgst_pos1 = 1;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 3;
8189 break;
8190
8191 case 3100: hash_type = HASH_TYPE_ORACLEH;
8192 salt_type = SALT_TYPE_INTERN;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_UPPER
8196 | OPTS_TYPE_ST_UPPER;
8197 kern_type = KERN_TYPE_ORACLEH;
8198 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8199 parse_func = oracleh_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8201 opti_type = OPTI_TYPE_ZERO_BYTE;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 3200: hash_type = HASH_TYPE_BCRYPT;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE
8212 | OPTS_TYPE_ST_GENERATE_LE;
8213 kern_type = KERN_TYPE_BCRYPT;
8214 dgst_size = DGST_SIZE_4_6;
8215 parse_func = bcrypt_parse_hash;
8216 sort_by_digest = sort_by_digest_4_6;
8217 opti_type = OPTI_TYPE_ZERO_BYTE;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 1;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 3;
8222 break;
8223
8224 case 3710: hash_type = HASH_TYPE_MD5;
8225 salt_type = SALT_TYPE_INTERN;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE
8228 | OPTS_TYPE_PT_ADD80
8229 | OPTS_TYPE_PT_ADDBITS14;
8230 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = md5s_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_PRECOMPUTE_INIT
8236 | OPTI_TYPE_PRECOMPUTE_MERKLE
8237 | OPTI_TYPE_EARLY_SKIP;
8238 dgst_pos0 = 0;
8239 dgst_pos1 = 3;
8240 dgst_pos2 = 2;
8241 dgst_pos3 = 1;
8242 break;
8243
8244 case 3711: hash_type = HASH_TYPE_MD5;
8245 salt_type = SALT_TYPE_EMBEDDED;
8246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8247 opts_type = OPTS_TYPE_PT_GENERATE_LE
8248 | OPTS_TYPE_PT_ADD80
8249 | OPTS_TYPE_PT_ADDBITS14;
8250 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8251 dgst_size = DGST_SIZE_4_4;
8252 parse_func = mediawiki_b_parse_hash;
8253 sort_by_digest = sort_by_digest_4_4;
8254 opti_type = OPTI_TYPE_ZERO_BYTE
8255 | OPTI_TYPE_PRECOMPUTE_INIT
8256 | OPTI_TYPE_PRECOMPUTE_MERKLE
8257 | OPTI_TYPE_EARLY_SKIP;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 3800: hash_type = HASH_TYPE_MD5;
8265 salt_type = SALT_TYPE_INTERN;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE
8268 | OPTS_TYPE_ST_ADDBITS14;
8269 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8270 dgst_size = DGST_SIZE_4_4;
8271 parse_func = md5s_parse_hash;
8272 sort_by_digest = sort_by_digest_4_4;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_PRECOMPUTE_INIT
8275 | OPTI_TYPE_PRECOMPUTE_MERKLE
8276 | OPTI_TYPE_EARLY_SKIP
8277 | OPTI_TYPE_NOT_ITERATED
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 4300: hash_type = HASH_TYPE_MD5;
8286 salt_type = SALT_TYPE_VIRTUAL;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS14
8291 | OPTS_TYPE_ST_ADD80;
8292 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8293 dgst_size = DGST_SIZE_4_4;
8294 parse_func = md5md5_parse_hash;
8295 sort_by_digest = sort_by_digest_4_4;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP;
8300 dgst_pos0 = 0;
8301 dgst_pos1 = 3;
8302 dgst_pos2 = 2;
8303 dgst_pos3 = 1;
8304 break;
8305
8306
8307 case 4400: hash_type = HASH_TYPE_MD5;
8308 salt_type = SALT_TYPE_NONE;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_BE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS15;
8313 kern_type = KERN_TYPE_MD5_SHA1;
8314 dgst_size = DGST_SIZE_4_4;
8315 parse_func = md5_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 | OPTI_TYPE_NOT_ITERATED
8322 | OPTI_TYPE_NOT_SALTED
8323 | OPTI_TYPE_RAW_HASH;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 4500: hash_type = HASH_TYPE_SHA1;
8331 salt_type = SALT_TYPE_NONE;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_BE
8334 | OPTS_TYPE_PT_ADD80
8335 | OPTS_TYPE_PT_ADDBITS15;
8336 kern_type = KERN_TYPE_SHA11;
8337 dgst_size = DGST_SIZE_4_5;
8338 parse_func = sha1_parse_hash;
8339 sort_by_digest = sort_by_digest_4_5;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_PRECOMPUTE_MERKLE
8343 | OPTI_TYPE_EARLY_SKIP
8344 | OPTI_TYPE_NOT_SALTED;
8345 dgst_pos0 = 3;
8346 dgst_pos1 = 4;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 4700: hash_type = HASH_TYPE_SHA1;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_LE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS14;
8357 kern_type = KERN_TYPE_SHA1_MD5;
8358 dgst_size = DGST_SIZE_4_5;
8359 parse_func = sha1_parse_hash;
8360 sort_by_digest = sort_by_digest_4_5;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP
8365 | OPTI_TYPE_NOT_ITERATED
8366 | OPTI_TYPE_NOT_SALTED
8367 | OPTI_TYPE_RAW_HASH;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 4;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 4800: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADDBITS14;
8379 kern_type = KERN_TYPE_MD5_CHAP;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = chap_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_MEET_IN_MIDDLE
8387 | OPTI_TYPE_EARLY_SKIP
8388 | OPTI_TYPE_NOT_ITERATED
8389 | OPTI_TYPE_RAW_HASH;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 4900: hash_type = HASH_TYPE_SHA1;
8397 salt_type = SALT_TYPE_INTERN;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8400 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8401 dgst_size = DGST_SIZE_4_5;
8402 parse_func = sha1s_parse_hash;
8403 sort_by_digest = sort_by_digest_4_5;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_PRECOMPUTE_INIT
8406 | OPTI_TYPE_PRECOMPUTE_MERKLE
8407 | OPTI_TYPE_EARLY_SKIP;
8408 dgst_pos0 = 3;
8409 dgst_pos1 = 4;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414 case 5000: hash_type = HASH_TYPE_KECCAK;
8415 salt_type = SALT_TYPE_EMBEDDED;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_PT_ADD01;
8419 kern_type = KERN_TYPE_KECCAK;
8420 dgst_size = DGST_SIZE_8_25;
8421 parse_func = keccak_parse_hash;
8422 sort_by_digest = sort_by_digest_8_25;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_USES_BITS_64
8425 | OPTI_TYPE_RAW_HASH;
8426 dgst_pos0 = 2;
8427 dgst_pos1 = 3;
8428 dgst_pos2 = 4;
8429 dgst_pos3 = 5;
8430 break;
8431
8432 case 5100: hash_type = HASH_TYPE_MD5H;
8433 salt_type = SALT_TYPE_NONE;
8434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_LE
8436 | OPTS_TYPE_PT_ADD80
8437 | OPTS_TYPE_PT_ADDBITS14;
8438 kern_type = KERN_TYPE_MD5H;
8439 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8440 parse_func = md5half_parse_hash;
8441 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_RAW_HASH;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 1;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 3;
8448 break;
8449
8450 case 5200: hash_type = HASH_TYPE_SHA256;
8451 salt_type = SALT_TYPE_EMBEDDED;
8452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8454 kern_type = KERN_TYPE_PSAFE3;
8455 dgst_size = DGST_SIZE_4_8;
8456 parse_func = psafe3_parse_hash;
8457 sort_by_digest = sort_by_digest_4_8;
8458 opti_type = OPTI_TYPE_ZERO_BYTE;
8459 dgst_pos0 = 0;
8460 dgst_pos1 = 1;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 3;
8463 break;
8464
8465 case 5300: hash_type = HASH_TYPE_MD5;
8466 salt_type = SALT_TYPE_EMBEDDED;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_ST_ADD80;
8470 kern_type = KERN_TYPE_IKEPSK_MD5;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = ikepsk_md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 5400: hash_type = HASH_TYPE_SHA1;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_BE
8485 | OPTS_TYPE_ST_ADD80;
8486 kern_type = KERN_TYPE_IKEPSK_SHA1;
8487 dgst_size = DGST_SIZE_4_5;
8488 parse_func = ikepsk_sha1_parse_hash;
8489 sort_by_digest = sort_by_digest_4_5;
8490 opti_type = OPTI_TYPE_ZERO_BYTE;
8491 dgst_pos0 = 3;
8492 dgst_pos1 = 4;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 5500: hash_type = HASH_TYPE_NETNTLM;
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_ADD80
8502 | OPTS_TYPE_PT_ADDBITS14
8503 | OPTS_TYPE_PT_UNICODE
8504 | OPTS_TYPE_ST_HEX;
8505 kern_type = KERN_TYPE_NETNTLMv1;
8506 dgst_size = DGST_SIZE_4_4;
8507 parse_func = netntlmv1_parse_hash;
8508 sort_by_digest = sort_by_digest_4_4;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8511 dgst_pos0 = 0;
8512 dgst_pos1 = 1;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 3;
8515 break;
8516
8517 case 5600: hash_type = HASH_TYPE_MD5;
8518 salt_type = SALT_TYPE_EMBEDDED;
8519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520 opts_type = OPTS_TYPE_PT_GENERATE_LE
8521 | OPTS_TYPE_PT_ADD80
8522 | OPTS_TYPE_PT_ADDBITS14
8523 | OPTS_TYPE_PT_UNICODE;
8524 kern_type = KERN_TYPE_NETNTLMv2;
8525 dgst_size = DGST_SIZE_4_4;
8526 parse_func = netntlmv2_parse_hash;
8527 sort_by_digest = sort_by_digest_4_4;
8528 opti_type = OPTI_TYPE_ZERO_BYTE;
8529 dgst_pos0 = 0;
8530 dgst_pos1 = 3;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 1;
8533 break;
8534
8535 case 5700: hash_type = HASH_TYPE_SHA256;
8536 salt_type = SALT_TYPE_NONE;
8537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_BE
8539 | OPTS_TYPE_PT_ADD80
8540 | OPTS_TYPE_PT_ADDBITS15;
8541 kern_type = KERN_TYPE_SHA256;
8542 dgst_size = DGST_SIZE_4_8;
8543 parse_func = cisco4_parse_hash;
8544 sort_by_digest = sort_by_digest_4_8;
8545 opti_type = OPTI_TYPE_ZERO_BYTE
8546 | OPTI_TYPE_PRECOMPUTE_INIT
8547 | OPTI_TYPE_PRECOMPUTE_MERKLE
8548 | OPTI_TYPE_EARLY_SKIP
8549 | OPTI_TYPE_NOT_ITERATED
8550 | OPTI_TYPE_NOT_SALTED
8551 | OPTI_TYPE_RAW_HASH;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 7;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 6;
8556 break;
8557
8558 case 5800: hash_type = HASH_TYPE_SHA1;
8559 salt_type = SALT_TYPE_INTERN;
8560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8562 | OPTS_TYPE_ST_ADD80;
8563 kern_type = KERN_TYPE_ANDROIDPIN;
8564 dgst_size = DGST_SIZE_4_5;
8565 parse_func = androidpin_parse_hash;
8566 sort_by_digest = sort_by_digest_4_5;
8567 opti_type = OPTI_TYPE_ZERO_BYTE;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 1;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 3;
8572 break;
8573
8574 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8575 salt_type = SALT_TYPE_NONE;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADD80;
8579 kern_type = KERN_TYPE_RIPEMD160;
8580 dgst_size = DGST_SIZE_4_5;
8581 parse_func = ripemd160_parse_hash;
8582 sort_by_digest = sort_by_digest_4_5;
8583 opti_type = OPTI_TYPE_ZERO_BYTE;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 1;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 3;
8588 break;
8589
8590 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8591 salt_type = SALT_TYPE_NONE;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_BE
8594 | OPTS_TYPE_PT_ADD80;
8595 kern_type = KERN_TYPE_WHIRLPOOL;
8596 dgst_size = DGST_SIZE_4_16;
8597 parse_func = whirlpool_parse_hash;
8598 sort_by_digest = sort_by_digest_4_16;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 1;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 3;
8604 break;
8605
8606 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8610 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8611 dgst_size = DGST_SIZE_4_5;
8612 parse_func = truecrypt_parse_hash_2k;
8613 sort_by_digest = sort_by_digest_4_5;
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8625 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8626 dgst_size = DGST_SIZE_4_5;
8627 parse_func = truecrypt_parse_hash_2k;
8628 sort_by_digest = sort_by_digest_4_5;
8629 opti_type = OPTI_TYPE_ZERO_BYTE;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 1;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 3;
8634 break;
8635
8636 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8637 salt_type = SALT_TYPE_EMBEDDED;
8638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8640 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8641 dgst_size = DGST_SIZE_4_5;
8642 parse_func = truecrypt_parse_hash_2k;
8643 sort_by_digest = sort_by_digest_4_5;
8644 opti_type = OPTI_TYPE_ZERO_BYTE;
8645 dgst_pos0 = 0;
8646 dgst_pos1 = 1;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 3;
8649 break;
8650
8651 case 6221: hash_type = HASH_TYPE_SHA512;
8652 salt_type = SALT_TYPE_EMBEDDED;
8653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8655 kern_type = KERN_TYPE_TCSHA512_XTS512;
8656 dgst_size = DGST_SIZE_8_8;
8657 parse_func = truecrypt_parse_hash_1k;
8658 sort_by_digest = sort_by_digest_8_8;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_USES_BITS_64;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 6222: hash_type = HASH_TYPE_SHA512;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8671 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8672 dgst_size = DGST_SIZE_8_8;
8673 parse_func = truecrypt_parse_hash_1k;
8674 sort_by_digest = sort_by_digest_8_8;
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_USES_BITS_64;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6223: hash_type = HASH_TYPE_SHA512;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8688 dgst_size = DGST_SIZE_8_8;
8689 parse_func = truecrypt_parse_hash_1k;
8690 sort_by_digest = sort_by_digest_8_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_USES_BITS_64;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 1;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 3;
8697 break;
8698
8699 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8700 salt_type = SALT_TYPE_EMBEDDED;
8701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8703 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8704 dgst_size = DGST_SIZE_4_8;
8705 parse_func = truecrypt_parse_hash_1k;
8706 sort_by_digest = sort_by_digest_4_8;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8718 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8719 dgst_size = DGST_SIZE_4_8;
8720 parse_func = truecrypt_parse_hash_1k;
8721 sort_by_digest = sort_by_digest_4_8;
8722 opti_type = OPTI_TYPE_ZERO_BYTE;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 1;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 3;
8727 break;
8728
8729 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8730 salt_type = SALT_TYPE_EMBEDDED;
8731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8733 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8734 dgst_size = DGST_SIZE_4_8;
8735 parse_func = truecrypt_parse_hash_1k;
8736 sort_by_digest = sort_by_digest_4_8;
8737 opti_type = OPTI_TYPE_ZERO_BYTE;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8748 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = truecrypt_parse_hash_1k;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8763 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = truecrypt_parse_hash_1k;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8778 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8779 dgst_size = DGST_SIZE_4_5;
8780 parse_func = truecrypt_parse_hash_1k;
8781 sort_by_digest = sort_by_digest_4_5;
8782 opti_type = OPTI_TYPE_ZERO_BYTE;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 1;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 3;
8787 break;
8788
8789 case 6300: hash_type = HASH_TYPE_MD5;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8793 kern_type = KERN_TYPE_MD5AIX;
8794 dgst_size = DGST_SIZE_4_4;
8795 parse_func = md5aix_parse_hash;
8796 sort_by_digest = sort_by_digest_4_4;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 6400: hash_type = HASH_TYPE_SHA256;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8808 kern_type = KERN_TYPE_SHA256AIX;
8809 dgst_size = DGST_SIZE_4_8;
8810 parse_func = sha256aix_parse_hash;
8811 sort_by_digest = sort_by_digest_4_8;
8812 opti_type = OPTI_TYPE_ZERO_BYTE;
8813 dgst_pos0 = 0;
8814 dgst_pos1 = 1;
8815 dgst_pos2 = 2;
8816 dgst_pos3 = 3;
8817 break;
8818
8819 case 6500: hash_type = HASH_TYPE_SHA512;
8820 salt_type = SALT_TYPE_EMBEDDED;
8821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8822 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8823 kern_type = KERN_TYPE_SHA512AIX;
8824 dgst_size = DGST_SIZE_8_8;
8825 parse_func = sha512aix_parse_hash;
8826 sort_by_digest = sort_by_digest_8_8;
8827 opti_type = OPTI_TYPE_ZERO_BYTE
8828 | OPTI_TYPE_USES_BITS_64;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 1;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 3;
8833 break;
8834
8835 case 6600: hash_type = HASH_TYPE_AES;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8839 kern_type = KERN_TYPE_AGILEKEY;
8840 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8841 parse_func = agilekey_parse_hash;
8842 sort_by_digest = sort_by_digest_4_5;
8843 opti_type = OPTI_TYPE_ZERO_BYTE;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6700: hash_type = HASH_TYPE_SHA1;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8854 kern_type = KERN_TYPE_SHA1AIX;
8855 dgst_size = DGST_SIZE_4_5;
8856 parse_func = sha1aix_parse_hash;
8857 sort_by_digest = sort_by_digest_4_5;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6800: hash_type = HASH_TYPE_AES;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8869 kern_type = KERN_TYPE_LASTPASS;
8870 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8871 parse_func = lastpass_parse_hash;
8872 sort_by_digest = sort_by_digest_4_8;
8873 opti_type = OPTI_TYPE_ZERO_BYTE;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6900: hash_type = HASH_TYPE_GOST;
8881 salt_type = SALT_TYPE_NONE;
8882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_GOST;
8885 dgst_size = DGST_SIZE_4_8;
8886 parse_func = gost_parse_hash;
8887 sort_by_digest = sort_by_digest_4_8;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 7100: hash_type = HASH_TYPE_SHA512;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8899 kern_type = KERN_TYPE_PBKDF2_SHA512;
8900 dgst_size = DGST_SIZE_8_16;
8901 parse_func = sha512osx_parse_hash;
8902 sort_by_digest = sort_by_digest_8_16;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_USES_BITS_64;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 7200: hash_type = HASH_TYPE_SHA512;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8915 kern_type = KERN_TYPE_PBKDF2_SHA512;
8916 dgst_size = DGST_SIZE_8_16;
8917 parse_func = sha512grub_parse_hash;
8918 sort_by_digest = sort_by_digest_8_16;
8919 opti_type = OPTI_TYPE_ZERO_BYTE
8920 | OPTI_TYPE_USES_BITS_64;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 7300: hash_type = HASH_TYPE_SHA1;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_BE
8931 | OPTS_TYPE_ST_ADD80
8932 | OPTS_TYPE_ST_ADDBITS15;
8933 kern_type = KERN_TYPE_RAKP;
8934 dgst_size = DGST_SIZE_4_5;
8935 parse_func = rakp_parse_hash;
8936 sort_by_digest = sort_by_digest_4_5;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_NOT_ITERATED;
8939 dgst_pos0 = 3;
8940 dgst_pos1 = 4;
8941 dgst_pos2 = 2;
8942 dgst_pos3 = 1;
8943 break;
8944
8945 case 7400: hash_type = HASH_TYPE_SHA256;
8946 salt_type = SALT_TYPE_EMBEDDED;
8947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8948 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8949 kern_type = KERN_TYPE_SHA256CRYPT;
8950 dgst_size = DGST_SIZE_4_8;
8951 parse_func = sha256crypt_parse_hash;
8952 sort_by_digest = sort_by_digest_4_8;
8953 opti_type = OPTI_TYPE_ZERO_BYTE;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 1;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 3;
8958 break;
8959
8960 case 7500: hash_type = HASH_TYPE_KRB5PA;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8964 kern_type = KERN_TYPE_KRB5PA;
8965 dgst_size = DGST_SIZE_4_4;
8966 parse_func = krb5pa_parse_hash;
8967 sort_by_digest = sort_by_digest_4_4;
8968 opti_type = OPTI_TYPE_ZERO_BYTE
8969 | OPTI_TYPE_NOT_ITERATED;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 7600: hash_type = HASH_TYPE_SHA1;
8977 salt_type = SALT_TYPE_INTERN;
8978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_BE
8980 | OPTS_TYPE_PT_ADD80
8981 | OPTS_TYPE_PT_ADDBITS15;
8982 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8983 dgst_size = DGST_SIZE_4_5;
8984 parse_func = redmine_parse_hash;
8985 sort_by_digest = sort_by_digest_4_5;
8986 opti_type = OPTI_TYPE_ZERO_BYTE
8987 | OPTI_TYPE_PRECOMPUTE_INIT
8988 | OPTI_TYPE_EARLY_SKIP
8989 | OPTI_TYPE_NOT_ITERATED
8990 | OPTI_TYPE_PREPENDED_SALT;
8991 dgst_pos0 = 3;
8992 dgst_pos1 = 4;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 1;
8995 break;
8996
8997 case 7700: hash_type = HASH_TYPE_SAPB;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE
9001 | OPTS_TYPE_PT_UPPER
9002 | OPTS_TYPE_ST_UPPER;
9003 kern_type = KERN_TYPE_SAPB;
9004 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9005 parse_func = sapb_parse_hash;
9006 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9007 opti_type = OPTI_TYPE_ZERO_BYTE
9008 | OPTI_TYPE_PRECOMPUTE_INIT
9009 | OPTI_TYPE_NOT_ITERATED;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 7800: hash_type = HASH_TYPE_SAPG;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_BE
9020 | OPTS_TYPE_ST_ADD80
9021 | OPTS_TYPE_ST_UPPER;
9022 kern_type = KERN_TYPE_SAPG;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = sapg_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE
9027 | OPTI_TYPE_PRECOMPUTE_INIT
9028 | OPTI_TYPE_NOT_ITERATED;
9029 dgst_pos0 = 3;
9030 dgst_pos1 = 4;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 1;
9033 break;
9034
9035 case 7900: hash_type = HASH_TYPE_SHA512;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9039 kern_type = KERN_TYPE_DRUPAL7;
9040 dgst_size = DGST_SIZE_8_8;
9041 parse_func = drupal7_parse_hash;
9042 sort_by_digest = sort_by_digest_8_8;
9043 opti_type = OPTI_TYPE_ZERO_BYTE
9044 | OPTI_TYPE_USES_BITS_64;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 1;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 3;
9049 break;
9050
9051 case 8000: hash_type = HASH_TYPE_SHA256;
9052 salt_type = SALT_TYPE_EMBEDDED;
9053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9054 opts_type = OPTS_TYPE_PT_GENERATE_BE
9055 | OPTS_TYPE_PT_UNICODE
9056 | OPTS_TYPE_ST_ADD80
9057 | OPTS_TYPE_ST_HEX;
9058 kern_type = KERN_TYPE_SYBASEASE;
9059 dgst_size = DGST_SIZE_4_8;
9060 parse_func = sybasease_parse_hash;
9061 sort_by_digest = sort_by_digest_4_8;
9062 opti_type = OPTI_TYPE_ZERO_BYTE
9063 | OPTI_TYPE_PRECOMPUTE_INIT
9064 | OPTI_TYPE_EARLY_SKIP
9065 | OPTI_TYPE_NOT_ITERATED
9066 | OPTI_TYPE_RAW_HASH;
9067 dgst_pos0 = 3;
9068 dgst_pos1 = 7;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 6;
9071 break;
9072
9073 case 8100: hash_type = HASH_TYPE_SHA1;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9077 kern_type = KERN_TYPE_NETSCALER;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = netscaler_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_PRECOMPUTE_INIT
9083 | OPTI_TYPE_PRECOMPUTE_MERKLE
9084 | OPTI_TYPE_EARLY_SKIP
9085 | OPTI_TYPE_NOT_ITERATED
9086 | OPTI_TYPE_PREPENDED_SALT
9087 | OPTI_TYPE_RAW_HASH;
9088 dgst_pos0 = 3;
9089 dgst_pos1 = 4;
9090 dgst_pos2 = 2;
9091 dgst_pos3 = 1;
9092 break;
9093
9094 case 8200: hash_type = HASH_TYPE_SHA256;
9095 salt_type = SALT_TYPE_EMBEDDED;
9096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9098 kern_type = KERN_TYPE_CLOUDKEY;
9099 dgst_size = DGST_SIZE_4_8;
9100 parse_func = cloudkey_parse_hash;
9101 sort_by_digest = sort_by_digest_4_8;
9102 opti_type = OPTI_TYPE_ZERO_BYTE;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 8300: hash_type = HASH_TYPE_SHA1;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE
9113 | OPTS_TYPE_ST_HEX
9114 | OPTS_TYPE_ST_ADD80;
9115 kern_type = KERN_TYPE_NSEC3;
9116 dgst_size = DGST_SIZE_4_5;
9117 parse_func = nsec3_parse_hash;
9118 sort_by_digest = sort_by_digest_4_5;
9119 opti_type = OPTI_TYPE_ZERO_BYTE;
9120 dgst_pos0 = 3;
9121 dgst_pos1 = 4;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 1;
9124 break;
9125
9126 case 8400: hash_type = HASH_TYPE_SHA1;
9127 salt_type = SALT_TYPE_INTERN;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_BE
9130 | OPTS_TYPE_PT_ADD80
9131 | OPTS_TYPE_PT_ADDBITS15;
9132 kern_type = KERN_TYPE_WBB3;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = wbb3_parse_hash;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_PRECOMPUTE_INIT
9138 | OPTI_TYPE_NOT_ITERATED;
9139 dgst_pos0 = 3;
9140 dgst_pos1 = 4;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 1;
9143 break;
9144
9145 case 8500: hash_type = HASH_TYPE_DESRACF;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE
9149 | OPTS_TYPE_ST_UPPER;
9150 kern_type = KERN_TYPE_RACF;
9151 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9152 parse_func = racf_parse_hash;
9153 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9154 opti_type = OPTI_TYPE_ZERO_BYTE
9155 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 8600: hash_type = HASH_TYPE_LOTUS5;
9163 salt_type = SALT_TYPE_NONE;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_LOTUS5;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = lotus5_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_EARLY_SKIP
9171 | OPTI_TYPE_NOT_ITERATED
9172 | OPTI_TYPE_NOT_SALTED
9173 | OPTI_TYPE_RAW_HASH;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 8700: hash_type = HASH_TYPE_LOTUS6;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_LOTUS6;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = lotus6_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_EARLY_SKIP
9189 | OPTI_TYPE_NOT_ITERATED
9190 | OPTI_TYPE_RAW_HASH;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_ANDROIDFDE;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = androidfde_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 8900: hash_type = HASH_TYPE_SCRYPT;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9216 kern_type = KERN_TYPE_SCRYPT;
9217 dgst_size = DGST_SIZE_4_8;
9218 parse_func = scrypt_parse_hash;
9219 sort_by_digest = sort_by_digest_4_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 9000: hash_type = HASH_TYPE_SHA1;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE
9231 | OPTS_TYPE_ST_GENERATE_LE;
9232 kern_type = KERN_TYPE_PSAFE2;
9233 dgst_size = DGST_SIZE_4_5;
9234 parse_func = psafe2_parse_hash;
9235 sort_by_digest = sort_by_digest_4_5;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 9100: hash_type = HASH_TYPE_LOTUS8;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_LOTUS8;
9248 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9249 parse_func = lotus8_parse_hash;
9250 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 9200: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9262 kern_type = KERN_TYPE_PBKDF2_SHA256;
9263 dgst_size = DGST_SIZE_4_32;
9264 parse_func = cisco8_parse_hash;
9265 sort_by_digest = sort_by_digest_4_32;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 9300: hash_type = HASH_TYPE_SCRYPT;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_SCRYPT;
9278 dgst_size = DGST_SIZE_4_8;
9279 parse_func = cisco9_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9292 kern_type = KERN_TYPE_OFFICE2007;
9293 dgst_size = DGST_SIZE_4_4;
9294 parse_func = office2007_parse_hash;
9295 sort_by_digest = sort_by_digest_4_4;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9307 kern_type = KERN_TYPE_OFFICE2010;
9308 dgst_size = DGST_SIZE_4_4;
9309 parse_func = office2010_parse_hash;
9310 sort_by_digest = sort_by_digest_4_4;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_OFFICE2013;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = office2013_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE
9337 | OPTS_TYPE_PT_ADD80
9338 | OPTS_TYPE_PT_UNICODE;
9339 kern_type = KERN_TYPE_OLDOFFICE01;
9340 dgst_size = DGST_SIZE_4_4;
9341 parse_func = oldoffice01_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_PT_ADD80;
9357 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = oldoffice01cm1_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_NOT_ITERATED;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE
9374 | OPTS_TYPE_PT_ADD80
9375 | OPTS_TYPE_PT_UNICODE
9376 | OPTS_TYPE_PT_NEVERCRACK;
9377 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9378 dgst_size = DGST_SIZE_4_4;
9379 parse_func = oldoffice01cm2_parse_hash;
9380 sort_by_digest = sort_by_digest_4_4;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_PRECOMPUTE_INIT
9383 | OPTI_TYPE_NOT_ITERATED;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_BE
9394 | OPTS_TYPE_PT_ADD80
9395 | OPTS_TYPE_PT_UNICODE;
9396 kern_type = KERN_TYPE_OLDOFFICE34;
9397 dgst_size = DGST_SIZE_4_4;
9398 parse_func = oldoffice34_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4;
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_NOT_ITERATED;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = oldoffice34cm1_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_NOT_ITERATED;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_BE
9430 | OPTS_TYPE_PT_ADD80
9431 | OPTS_TYPE_PT_UNICODE
9432 | OPTS_TYPE_PT_NEVERCRACK;
9433 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9434 dgst_size = DGST_SIZE_4_4;
9435 parse_func = oldoffice34cm2_parse_hash;
9436 sort_by_digest = sort_by_digest_4_4;
9437 opti_type = OPTI_TYPE_ZERO_BYTE
9438 | OPTI_TYPE_PRECOMPUTE_INIT
9439 | OPTI_TYPE_NOT_ITERATED;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 9900: hash_type = HASH_TYPE_MD5;
9447 salt_type = SALT_TYPE_NONE;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9450 kern_type = KERN_TYPE_RADMIN2;
9451 dgst_size = DGST_SIZE_4_4;
9452 parse_func = radmin2_parse_hash;
9453 sort_by_digest = sort_by_digest_4_4;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_EARLY_SKIP
9457 | OPTI_TYPE_NOT_ITERATED
9458 | OPTI_TYPE_NOT_SALTED;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 3;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 1;
9463 break;
9464
9465 case 10000: hash_type = HASH_TYPE_SHA256;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9469 kern_type = KERN_TYPE_PBKDF2_SHA256;
9470 dgst_size = DGST_SIZE_4_32;
9471 parse_func = djangopbkdf2_parse_hash;
9472 sort_by_digest = sort_by_digest_4_32;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 10100: hash_type = HASH_TYPE_SIPHASH;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_SIPHASH;
9485 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9486 parse_func = siphash_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_NOT_ITERATED
9490 | OPTI_TYPE_RAW_HASH;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 10200: hash_type = HASH_TYPE_MD5;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE
9501 | OPTS_TYPE_ST_ADD80
9502 | OPTS_TYPE_ST_ADDBITS14;
9503 kern_type = KERN_TYPE_HMACMD5_PW;
9504 dgst_size = DGST_SIZE_4_4;
9505 parse_func = crammd5_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4;
9507 opti_type = OPTI_TYPE_ZERO_BYTE
9508 | OPTI_TYPE_NOT_ITERATED;
9509 dgst_pos0 = 0;
9510 dgst_pos1 = 3;
9511 dgst_pos2 = 2;
9512 dgst_pos3 = 1;
9513 break;
9514
9515 case 10300: hash_type = HASH_TYPE_SHA1;
9516 salt_type = SALT_TYPE_EMBEDDED;
9517 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9518 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9519 kern_type = KERN_TYPE_SAPH_SHA1;
9520 dgst_size = DGST_SIZE_4_5;
9521 parse_func = saph_sha1_parse_hash;
9522 sort_by_digest = sort_by_digest_4_5;
9523 opti_type = OPTI_TYPE_ZERO_BYTE;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 10400: hash_type = HASH_TYPE_PDFU16;
9531 salt_type = SALT_TYPE_EMBEDDED;
9532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9534 kern_type = KERN_TYPE_PDF11;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = pdf11_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_NOT_ITERATED;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 10410: hash_type = HASH_TYPE_PDFU16;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9550 kern_type = KERN_TYPE_PDF11CM1;
9551 dgst_size = DGST_SIZE_4_4;
9552 parse_func = pdf11cm1_parse_hash;
9553 sort_by_digest = sort_by_digest_4_4;
9554 opti_type = OPTI_TYPE_ZERO_BYTE
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 10420: hash_type = HASH_TYPE_PDFU16;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9566 kern_type = KERN_TYPE_PDF11CM2;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = pdf11cm2_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_NOT_ITERATED;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 10500: hash_type = HASH_TYPE_PDFU16;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9582 kern_type = KERN_TYPE_PDF14;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = pdf14_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_NOT_ITERATED;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 10600: hash_type = HASH_TYPE_SHA256;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_BE
9598 | OPTS_TYPE_ST_ADD80
9599 | OPTS_TYPE_ST_ADDBITS15
9600 | OPTS_TYPE_HASH_COPY;
9601 kern_type = KERN_TYPE_SHA256_PWSLT;
9602 dgst_size = DGST_SIZE_4_8;
9603 parse_func = pdf17l3_parse_hash;
9604 sort_by_digest = sort_by_digest_4_8;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_PRECOMPUTE_MERKLE
9608 | OPTI_TYPE_EARLY_SKIP
9609 | OPTI_TYPE_NOT_ITERATED
9610 | OPTI_TYPE_APPENDED_SALT
9611 | OPTI_TYPE_RAW_HASH;
9612 dgst_pos0 = 3;
9613 dgst_pos1 = 7;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 6;
9616 break;
9617
9618 case 10700: hash_type = HASH_TYPE_PDFU32;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE
9622 | OPTS_TYPE_HASH_COPY;
9623 kern_type = KERN_TYPE_PDF17L8;
9624 dgst_size = DGST_SIZE_4_8;
9625 parse_func = pdf17l8_parse_hash;
9626 sort_by_digest = sort_by_digest_4_8;
9627 opti_type = OPTI_TYPE_ZERO_BYTE
9628 | OPTI_TYPE_NOT_ITERATED;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 10800: hash_type = HASH_TYPE_SHA384;
9636 salt_type = SALT_TYPE_NONE;
9637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_BE
9639 | OPTS_TYPE_PT_ADD80
9640 | OPTS_TYPE_PT_ADDBITS15;
9641 kern_type = KERN_TYPE_SHA384;
9642 dgst_size = DGST_SIZE_8_8;
9643 parse_func = sha384_parse_hash;
9644 sort_by_digest = sort_by_digest_8_8;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_PRECOMPUTE_INIT
9647 | OPTI_TYPE_PRECOMPUTE_MERKLE
9648 | OPTI_TYPE_EARLY_SKIP
9649 | OPTI_TYPE_NOT_ITERATED
9650 | OPTI_TYPE_NOT_SALTED
9651 | OPTI_TYPE_USES_BITS_64
9652 | OPTI_TYPE_RAW_HASH;
9653 dgst_pos0 = 6;
9654 dgst_pos1 = 7;
9655 dgst_pos2 = 4;
9656 dgst_pos3 = 5;
9657 break;
9658
9659 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE
9663 | OPTS_TYPE_ST_BASE64
9664 | OPTS_TYPE_HASH_COPY;
9665 kern_type = KERN_TYPE_PBKDF2_SHA256;
9666 dgst_size = DGST_SIZE_4_32;
9667 parse_func = pbkdf2_sha256_parse_hash;
9668 sort_by_digest = sort_by_digest_4_32;
9669 opti_type = OPTI_TYPE_ZERO_BYTE;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 11000: hash_type = HASH_TYPE_MD5;
9677 salt_type = SALT_TYPE_INTERN;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE
9680 | OPTS_TYPE_PT_ADD80;
9681 kern_type = KERN_TYPE_PRESTASHOP;
9682 dgst_size = DGST_SIZE_4_4;
9683 parse_func = prestashop_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4;
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_PRECOMPUTE_INIT
9687 | OPTI_TYPE_NOT_ITERATED
9688 | OPTI_TYPE_PREPENDED_SALT;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 3;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 11100: hash_type = HASH_TYPE_MD5;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE
9699 | OPTS_TYPE_ST_ADD80;
9700 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = postgresql_auth_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_PRECOMPUTE_INIT
9706 | OPTI_TYPE_PRECOMPUTE_MERKLE
9707 | OPTI_TYPE_EARLY_SKIP;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 3;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 1;
9712 break;
9713
9714 case 11200: hash_type = HASH_TYPE_SHA1;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_BE
9718 | OPTS_TYPE_PT_ADD80
9719 | OPTS_TYPE_ST_HEX;
9720 kern_type = KERN_TYPE_MYSQL_AUTH;
9721 dgst_size = DGST_SIZE_4_5;
9722 parse_func = mysql_auth_parse_hash;
9723 sort_by_digest = sort_by_digest_4_5;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_EARLY_SKIP;
9726 dgst_pos0 = 3;
9727 dgst_pos1 = 4;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 1;
9730 break;
9731
9732 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE
9736 | OPTS_TYPE_ST_HEX
9737 | OPTS_TYPE_ST_ADD80;
9738 kern_type = KERN_TYPE_BITCOIN_WALLET;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = bitcoin_wallet_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 11400: hash_type = HASH_TYPE_MD5;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_HASH_COPY;
9755 kern_type = KERN_TYPE_SIP_AUTH;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = sip_auth_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 3;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 1;
9764 break;
9765
9766 case 11500: hash_type = HASH_TYPE_CRC32;
9767 salt_type = SALT_TYPE_INTERN;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_ST_GENERATE_LE
9771 | OPTS_TYPE_ST_HEX;
9772 kern_type = KERN_TYPE_CRC32;
9773 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9774 parse_func = crc32_parse_hash;
9775 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9776 opti_type = OPTI_TYPE_ZERO_BYTE;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 11600: hash_type = HASH_TYPE_AES;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE
9787 | OPTS_TYPE_PT_NEVERCRACK;
9788 kern_type = KERN_TYPE_SEVEN_ZIP;
9789 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9790 parse_func = seven_zip_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9792 opti_type = OPTI_TYPE_ZERO_BYTE;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9800 salt_type = SALT_TYPE_NONE;
9801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE
9803 | OPTS_TYPE_PT_ADD01;
9804 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9805 dgst_size = DGST_SIZE_4_8;
9806 parse_func = gost2012sbog_256_parse_hash;
9807 sort_by_digest = sort_by_digest_4_8;
9808 opti_type = OPTI_TYPE_ZERO_BYTE;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9816 salt_type = SALT_TYPE_NONE;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE
9819 | OPTS_TYPE_PT_ADD01;
9820 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9821 dgst_size = DGST_SIZE_4_16;
9822 parse_func = gost2012sbog_512_parse_hash;
9823 sort_by_digest = sort_by_digest_4_16;
9824 opti_type = OPTI_TYPE_ZERO_BYTE;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_LE
9835 | OPTS_TYPE_ST_BASE64
9836 | OPTS_TYPE_HASH_COPY;
9837 kern_type = KERN_TYPE_PBKDF2_MD5;
9838 dgst_size = DGST_SIZE_4_32;
9839 parse_func = pbkdf2_md5_parse_hash;
9840 sort_by_digest = sort_by_digest_4_32;
9841 opti_type = OPTI_TYPE_ZERO_BYTE;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 1;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 3;
9846 break;
9847
9848 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_BASE64
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PBKDF2_SHA1;
9855 dgst_size = DGST_SIZE_4_32;
9856 parse_func = pbkdf2_sha1_parse_hash;
9857 sort_by_digest = sort_by_digest_4_32;
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_ST_BASE64
9870 | OPTS_TYPE_HASH_COPY;
9871 kern_type = KERN_TYPE_PBKDF2_SHA512;
9872 dgst_size = DGST_SIZE_8_16;
9873 parse_func = pbkdf2_sha512_parse_hash;
9874 sort_by_digest = sort_by_digest_8_16;
9875 opti_type = OPTI_TYPE_ZERO_BYTE
9876 | OPTI_TYPE_USES_BITS_64;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9887 kern_type = KERN_TYPE_ECRYPTFS;
9888 dgst_size = DGST_SIZE_8_8;
9889 parse_func = ecryptfs_parse_hash;
9890 sort_by_digest = sort_by_digest_8_8;
9891 opti_type = OPTI_TYPE_ZERO_BYTE
9892 | OPTI_TYPE_USES_BITS_64;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 1;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 3;
9897 break;
9898
9899 case 12300: hash_type = HASH_TYPE_ORACLET;
9900 salt_type = SALT_TYPE_EMBEDDED;
9901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9903 kern_type = KERN_TYPE_ORACLET;
9904 dgst_size = DGST_SIZE_8_16;
9905 parse_func = oraclet_parse_hash;
9906 sort_by_digest = sort_by_digest_8_16;
9907 opti_type = OPTI_TYPE_ZERO_BYTE
9908 | OPTI_TYPE_USES_BITS_64;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 1;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 3;
9913 break;
9914
9915 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9919 kern_type = KERN_TYPE_BSDICRYPT;
9920 dgst_size = DGST_SIZE_4_4;
9921 parse_func = bsdicrypt_parse_hash;
9922 sort_by_digest = sort_by_digest_4_4;
9923 opti_type = OPTI_TYPE_ZERO_BYTE
9924 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 1;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 3;
9929 break;
9930
9931 case 12500: hash_type = HASH_TYPE_RAR3HP;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9935 kern_type = KERN_TYPE_RAR3;
9936 dgst_size = DGST_SIZE_4_4;
9937 parse_func = rar3hp_parse_hash;
9938 sort_by_digest = sort_by_digest_4_4;
9939 opti_type = OPTI_TYPE_ZERO_BYTE;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 12600: hash_type = HASH_TYPE_SHA256;
9947 salt_type = SALT_TYPE_INTERN;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_BE
9950 | OPTS_TYPE_PT_ADD80;
9951 kern_type = KERN_TYPE_CF10;
9952 dgst_size = DGST_SIZE_4_8;
9953 parse_func = cf10_parse_hash;
9954 sort_by_digest = sort_by_digest_4_8;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_PRECOMPUTE_INIT
9957 | OPTI_TYPE_EARLY_SKIP
9958 | OPTI_TYPE_NOT_ITERATED;
9959 dgst_pos0 = 3;
9960 dgst_pos1 = 7;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 6;
9963 break;
9964
9965 case 12700: hash_type = HASH_TYPE_AES;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE
9969 | OPTS_TYPE_HASH_COPY;
9970 kern_type = KERN_TYPE_MYWALLET;
9971 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9972 parse_func = mywallet_parse_hash;
9973 sort_by_digest = sort_by_digest_4_5;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9985 kern_type = KERN_TYPE_MS_DRSR;
9986 dgst_size = DGST_SIZE_4_8;
9987 parse_func = ms_drsr_parse_hash;
9988 sort_by_digest = sort_by_digest_4_8;
9989 opti_type = OPTI_TYPE_ZERO_BYTE;
9990 dgst_pos0 = 0;
9991 dgst_pos1 = 1;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 3;
9994 break;
9995
9996 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9997 salt_type = SALT_TYPE_EMBEDDED;
9998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10000 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10001 dgst_size = DGST_SIZE_4_8;
10002 parse_func = androidfde_samsung_parse_hash;
10003 sort_by_digest = sort_by_digest_4_8;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_RAR5;
10016 dgst_size = DGST_SIZE_4_4;
10017 parse_func = rar5_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 default: usage_mini_print (PROGNAME); return (-1);
10027 }
10028
10029 /**
10030 * transpose
10031 */
10032
10033 data.parse_func = parse_func;
10034
10035 /**
10036 * misc stuff
10037 */
10038
10039 if (hex_salt)
10040 {
10041 if (salt_type == SALT_TYPE_INTERN)
10042 {
10043 opts_type |= OPTS_TYPE_ST_HEX;
10044 }
10045 else
10046 {
10047 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10048
10049 return (-1);
10050 }
10051 }
10052
10053 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10054 | (salt_type == SALT_TYPE_EXTERN)
10055 | (salt_type == SALT_TYPE_EMBEDDED)
10056 | (salt_type == SALT_TYPE_VIRTUAL));
10057
10058 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10059
10060 data.hash_type = hash_type;
10061 data.attack_mode = attack_mode;
10062 data.attack_kern = attack_kern;
10063 data.attack_exec = attack_exec;
10064 data.kern_type = kern_type;
10065 data.opts_type = opts_type;
10066 data.dgst_size = dgst_size;
10067 data.salt_type = salt_type;
10068 data.isSalted = isSalted;
10069 data.sort_by_digest = sort_by_digest;
10070 data.dgst_pos0 = dgst_pos0;
10071 data.dgst_pos1 = dgst_pos1;
10072 data.dgst_pos2 = dgst_pos2;
10073 data.dgst_pos3 = dgst_pos3;
10074
10075 esalt_size = 0;
10076
10077 switch (hash_mode)
10078 {
10079 case 2500: esalt_size = sizeof (wpa_t); break;
10080 case 5300: esalt_size = sizeof (ikepsk_t); break;
10081 case 5400: esalt_size = sizeof (ikepsk_t); break;
10082 case 5500: esalt_size = sizeof (netntlm_t); break;
10083 case 5600: esalt_size = sizeof (netntlm_t); break;
10084 case 6211:
10085 case 6212:
10086 case 6213:
10087 case 6221:
10088 case 6222:
10089 case 6223:
10090 case 6231:
10091 case 6232:
10092 case 6233:
10093 case 6241:
10094 case 6242:
10095 case 6243: esalt_size = sizeof (tc_t); break;
10096 case 6600: esalt_size = sizeof (agilekey_t); break;
10097 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10098 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10099 case 7300: esalt_size = sizeof (rakp_t); break;
10100 case 7500: esalt_size = sizeof (krb5pa_t); break;
10101 case 8200: esalt_size = sizeof (cloudkey_t); break;
10102 case 8800: esalt_size = sizeof (androidfde_t); break;
10103 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10104 case 9400: esalt_size = sizeof (office2007_t); break;
10105 case 9500: esalt_size = sizeof (office2010_t); break;
10106 case 9600: esalt_size = sizeof (office2013_t); break;
10107 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10108 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10109 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10110 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10111 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10112 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10113 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10114 case 10200: esalt_size = sizeof (cram_md5_t); break;
10115 case 10400: esalt_size = sizeof (pdf_t); break;
10116 case 10410: esalt_size = sizeof (pdf_t); break;
10117 case 10420: esalt_size = sizeof (pdf_t); break;
10118 case 10500: esalt_size = sizeof (pdf_t); break;
10119 case 10600: esalt_size = sizeof (pdf_t); break;
10120 case 10700: esalt_size = sizeof (pdf_t); break;
10121 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10122 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10123 case 11400: esalt_size = sizeof (sip_t); break;
10124 case 11600: esalt_size = sizeof (seven_zip_t); break;
10125 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10126 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10127 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10128 case 13000: esalt_size = sizeof (rar5_t); break;
10129 }
10130
10131 data.esalt_size = esalt_size;
10132
10133 /**
10134 * choose dictionary parser
10135 */
10136
10137 if (hash_type == HASH_TYPE_LM)
10138 {
10139 get_next_word_func = get_next_word_lm;
10140 }
10141 else if (opts_type & OPTS_TYPE_PT_UPPER)
10142 {
10143 get_next_word_func = get_next_word_uc;
10144 }
10145 else
10146 {
10147 get_next_word_func = get_next_word_std;
10148 }
10149
10150 /**
10151 * dictstat
10152 */
10153
10154 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10155
10156 #ifdef _POSIX
10157 size_t dictstat_nmemb = 0;
10158 #endif
10159
10160 #ifdef _WIN
10161 uint dictstat_nmemb = 0;
10162 #endif
10163
10164 char dictstat[256] = { 0 };
10165
10166 FILE *dictstat_fp = NULL;
10167
10168 if (keyspace == 0)
10169 {
10170 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10171
10172 dictstat_fp = fopen (dictstat, "rb");
10173
10174 if (dictstat_fp)
10175 {
10176 #ifdef _POSIX
10177 struct stat tmpstat;
10178
10179 fstat (fileno (dictstat_fp), &tmpstat);
10180 #endif
10181
10182 #ifdef _WIN
10183 struct stat64 tmpstat;
10184
10185 _fstat64 (fileno (dictstat_fp), &tmpstat);
10186 #endif
10187
10188 if (tmpstat.st_mtime < COMPTIME)
10189 {
10190 /* with v0.15 the format changed so we have to ensure user is using a good version
10191 since there is no version-header in the dictstat file */
10192
10193 fclose (dictstat_fp);
10194
10195 unlink (dictstat);
10196 }
10197 else
10198 {
10199 while (!feof (dictstat_fp))
10200 {
10201 dictstat_t d;
10202
10203 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10204
10205 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10206
10207 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10208 {
10209 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10210
10211 return -1;
10212 }
10213 }
10214
10215 fclose (dictstat_fp);
10216 }
10217 }
10218 }
10219
10220 /**
10221 * potfile
10222 */
10223
10224 char potfile[256] = { 0 };
10225
10226 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10227
10228 data.pot_fp = NULL;
10229
10230 FILE *out_fp = NULL;
10231 FILE *pot_fp = NULL;
10232
10233 if (show == 1 || left == 1)
10234 {
10235 pot_fp = fopen (potfile, "rb");
10236
10237 if (pot_fp == NULL)
10238 {
10239 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10240
10241 return (-1);
10242 }
10243
10244 if (outfile != NULL)
10245 {
10246 if ((out_fp = fopen (outfile, "ab")) == NULL)
10247 {
10248 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10249
10250 fclose (pot_fp);
10251
10252 return (-1);
10253 }
10254 }
10255 else
10256 {
10257 out_fp = stdout;
10258 }
10259 }
10260 else
10261 {
10262 if (potfile_disable == 0)
10263 {
10264 pot_fp = fopen (potfile, "ab");
10265
10266 if (pot_fp == NULL)
10267 {
10268 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10269
10270 return (-1);
10271 }
10272
10273 data.pot_fp = pot_fp;
10274 }
10275 }
10276
10277 pot_t *pot = NULL;
10278
10279 uint pot_cnt = 0;
10280 uint pot_avail = 0;
10281
10282 if (show == 1 || left == 1)
10283 {
10284 SUPPRESS_OUTPUT = 1;
10285
10286 pot_avail = count_lines (pot_fp);
10287
10288 rewind (pot_fp);
10289
10290 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10291
10292 uint pot_hashes_avail = 0;
10293
10294 uint line_num = 0;
10295
10296 while (!feof (pot_fp))
10297 {
10298 line_num++;
10299
10300 char line_buf[BUFSIZ] = { 0 };
10301
10302 int line_len = fgetl (pot_fp, line_buf);
10303
10304 if (line_len == 0) continue;
10305
10306 char *plain_buf = line_buf + line_len;
10307
10308 pot_t *pot_ptr = &pot[pot_cnt];
10309
10310 hash_t *hashes_buf = &pot_ptr->hash;
10311
10312 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10313 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10314
10315 if (pot_cnt == pot_hashes_avail)
10316 {
10317 uint pos = 0;
10318
10319 for (pos = 0; pos < INCR_POT; pos++)
10320 {
10321 if ((pot_cnt + pos) >= pot_avail) break;
10322
10323 pot_t *tmp_pot = &pot[pot_cnt + pos];
10324
10325 hash_t *tmp_hash = &tmp_pot->hash;
10326
10327 tmp_hash->digest = mymalloc (dgst_size);
10328
10329 if (isSalted)
10330 {
10331 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10332 }
10333
10334 if (esalt_size)
10335 {
10336 tmp_hash->esalt = mymalloc (esalt_size);
10337 }
10338
10339 pot_hashes_avail++;
10340 }
10341 }
10342
10343 int plain_len = 0;
10344
10345 int parser_status;
10346
10347 int iter = MAX_CUT_TRIES;
10348
10349 do
10350 {
10351 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10352 {
10353 if (line_buf[i] == ':')
10354 {
10355 line_len--;
10356
10357 break;
10358 }
10359 }
10360
10361 if (data.hash_mode != 2500)
10362 {
10363 parser_status = parse_func (line_buf, line_len, hashes_buf);
10364 }
10365 else
10366 {
10367 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10368
10369 if (line_len > max_salt_size)
10370 {
10371 parser_status = PARSER_GLOBAL_LENGTH;
10372 }
10373 else
10374 {
10375 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10376
10377 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10378
10379 hashes_buf->salt->salt_len = line_len;
10380
10381 parser_status = PARSER_OK;
10382 }
10383 }
10384
10385 // if NOT parsed without error, we add the ":" to the plain
10386
10387 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10388 {
10389 plain_len++;
10390 plain_buf--;
10391 }
10392
10393 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10394
10395 if (parser_status < PARSER_GLOBAL_ZERO)
10396 {
10397 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10398
10399 continue;
10400 }
10401
10402 if (plain_len >= 255) continue;
10403
10404 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10405
10406 pot_ptr->plain_len = plain_len;
10407
10408 pot_cnt++;
10409 }
10410
10411 fclose (pot_fp);
10412
10413 SUPPRESS_OUTPUT = 0;
10414
10415 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10416 }
10417
10418 /**
10419 * kernel accel and loops auto adjustment
10420 */
10421
10422 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10423 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10424
10425 if (workload_profile == 1)
10426 {
10427 kernel_loops /= 8;
10428 kernel_accel /= 4;
10429
10430 if (kernel_loops == 0) kernel_loops = 8;
10431 if (kernel_accel == 0) kernel_accel = 2;
10432 }
10433 else if (workload_profile == 3)
10434 {
10435 kernel_loops *= 8;
10436 kernel_accel *= 4;
10437
10438 if (kernel_loops > 1024) kernel_loops = 1024;
10439 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10440 }
10441
10442 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10443
10444 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10445 {
10446 kernel_loops = 1024;
10447 }
10448
10449 if (hash_mode == 12500)
10450 {
10451 kernel_loops = ROUNDS_RAR3 / 16;
10452 }
10453
10454 data.kernel_accel = kernel_accel;
10455 data.kernel_loops = kernel_loops;
10456
10457 /**
10458 * word len
10459 */
10460
10461 uint pw_min = PW_MIN;
10462 uint pw_max = PW_MAX;
10463
10464 switch (hash_mode)
10465 {
10466 case 400: if (pw_max > 40) pw_max = 40;
10467 break;
10468 case 500: if (pw_max > 16) pw_max = 16;
10469 break;
10470 case 1500: if (pw_max > 8) pw_max = 8;
10471 break;
10472 case 1600: if (pw_max > 16) pw_max = 16;
10473 break;
10474 case 1800: if (pw_max > 16) pw_max = 16;
10475 break;
10476 case 2100: if (pw_max > 16) pw_max = 16;
10477 break;
10478 case 2500: if (pw_min < 8) pw_min = 8;
10479 break;
10480 case 3000: if (pw_max > 7) pw_max = 7;
10481 break;
10482 case 5200: if (pw_max > 24) pw_max = 24;
10483 break;
10484 case 5800: if (pw_max > 16) pw_max = 16;
10485 break;
10486 case 6300: if (pw_max > 16) pw_max = 16;
10487 break;
10488 case 7400: if (pw_max > 16) pw_max = 16;
10489 break;
10490 case 7900: if (pw_max > 48) pw_max = 48;
10491 break;
10492 case 8500: if (pw_max > 8) pw_max = 8;
10493 break;
10494 case 8600: if (pw_max > 16) pw_max = 16;
10495 break;
10496 case 9710: pw_min = 5;
10497 pw_max = 5;
10498 break;
10499 case 9810: pw_min = 5;
10500 pw_max = 5;
10501 break;
10502 case 10410: pw_min = 5;
10503 pw_max = 5;
10504 break;
10505 case 10300: if (pw_max < 3) pw_min = 3;
10506 if (pw_max > 40) pw_max = 40;
10507 break;
10508 case 10500: if (pw_max < 3) pw_min = 3;
10509 if (pw_max > 40) pw_max = 40;
10510 break;
10511 case 10700: if (pw_max > 16) pw_max = 16;
10512 break;
10513 case 11300: if (pw_max > 40) pw_max = 40;
10514 break;
10515 case 12500: if (pw_max > 20) pw_max = 20;
10516 break;
10517 case 12800: if (pw_max > 24) pw_max = 24;
10518 break;
10519 }
10520
10521 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10522 {
10523 switch (attack_kern)
10524 {
10525 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10526 break;
10527 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10528 break;
10529 }
10530 }
10531
10532 /**
10533 * charsets : keep them together for more easy maintainnce
10534 */
10535
10536 cs_t mp_sys[6] = { { { 0 }, 0 } };
10537 cs_t mp_usr[4] = { { { 0 }, 0 } };
10538
10539 mp_setup_sys (mp_sys);
10540
10541 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10542 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10543 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10544 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10545
10546 /**
10547 * load hashes, part I: find input mode, count hashes
10548 */
10549
10550 uint hashlist_mode = 0;
10551 uint hashlist_format = HLFMT_HASHCAT;
10552
10553 uint hashes_avail = 0;
10554
10555 if (benchmark == 0)
10556 {
10557 struct stat f;
10558
10559 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10560
10561 if ((hash_mode == 2500) ||
10562 (hash_mode == 5200) ||
10563 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10564 (hash_mode == 9000))
10565 {
10566 hashlist_mode = HL_MODE_ARG;
10567
10568 char *hashfile = myargv[optind];
10569
10570 data.hashfile = hashfile;
10571
10572 logfile_top_var_string ("target", hashfile);
10573 }
10574
10575 if (hashlist_mode == HL_MODE_ARG)
10576 {
10577 if (hash_mode == 2500)
10578 {
10579 struct stat st;
10580
10581 if (stat (data.hashfile, &st) == -1)
10582 {
10583 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10584
10585 return (-1);
10586 }
10587
10588 hashes_avail = st.st_size / sizeof (hccap_t);
10589 }
10590 else
10591 {
10592 hashes_avail = 1;
10593 }
10594 }
10595 else if (hashlist_mode == HL_MODE_FILE)
10596 {
10597 char *hashfile = myargv[optind];
10598
10599 data.hashfile = hashfile;
10600
10601 logfile_top_var_string ("target", hashfile);
10602
10603 FILE *fp = NULL;
10604
10605 if ((fp = fopen (hashfile, "rb")) == NULL)
10606 {
10607 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10608
10609 return (-1);
10610 }
10611
10612 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10613
10614 hashes_avail = count_lines (fp);
10615
10616 rewind (fp);
10617
10618 if (hashes_avail == 0)
10619 {
10620 log_error ("ERROR: hashfile is empty or corrupt");
10621
10622 fclose (fp);
10623
10624 return (-1);
10625 }
10626
10627 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10628
10629 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10630 {
10631 log_error ("ERROR: remove not supported in native hashfile-format mode");
10632
10633 fclose (fp);
10634
10635 return (-1);
10636 }
10637
10638 fclose (fp);
10639 }
10640 }
10641 else
10642 {
10643 hashlist_mode = HL_MODE_ARG;
10644
10645 hashes_avail = 1;
10646 }
10647
10648 if (hash_mode == 3000) hashes_avail *= 2;
10649
10650 data.hashlist_mode = hashlist_mode;
10651 data.hashlist_format = hashlist_format;
10652
10653 logfile_top_uint (hashlist_mode);
10654 logfile_top_uint (hashlist_format);
10655
10656 /**
10657 * load hashes, part II: allocate required memory, set pointers
10658 */
10659
10660 hash_t *hashes_buf = NULL;
10661 void *digests_buf = NULL;
10662 salt_t *salts_buf = NULL;
10663 void *esalts_buf = NULL;
10664
10665 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10666
10667 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10668
10669 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10670 {
10671 u32 hash_pos;
10672
10673 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10674 {
10675 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10676
10677 hashes_buf[hash_pos].hash_info = hash_info;
10678
10679 if (username && (remove || show || left))
10680 {
10681 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10682 }
10683
10684 if (benchmark)
10685 {
10686 hash_info->orighash = (char *) mymalloc (256);
10687 }
10688 }
10689 }
10690
10691 if (isSalted)
10692 {
10693 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10694
10695 if (esalt_size)
10696 {
10697 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10698 }
10699 }
10700 else
10701 {
10702 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10703 }
10704
10705 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10706 {
10707 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10708
10709 if (isSalted)
10710 {
10711 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10712
10713 if (esalt_size)
10714 {
10715 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10716 }
10717 }
10718 else
10719 {
10720 hashes_buf[hash_pos].salt = &salts_buf[0];
10721 }
10722 }
10723
10724 /**
10725 * load hashes, part III: parse hashes or generate them if benchmark
10726 */
10727
10728 uint hashes_cnt = 0;
10729
10730 if (benchmark == 0)
10731 {
10732 if (keyspace == 1)
10733 {
10734 // useless to read hash file for keyspace, cheat a little bit w/ optind
10735 }
10736 else if (hashes_avail == 0)
10737 {
10738 }
10739 else if (hashlist_mode == HL_MODE_ARG)
10740 {
10741 char *input_buf = myargv[optind];
10742
10743 uint input_len = strlen (input_buf);
10744
10745 logfile_top_var_string ("target", input_buf);
10746
10747 char *hash_buf = NULL;
10748 int hash_len = 0;
10749
10750 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10751
10752 if (hash_len)
10753 {
10754 if (opts_type & OPTS_TYPE_HASH_COPY)
10755 {
10756 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10757
10758 hash_info_tmp->orighash = mystrdup (hash_buf);
10759 }
10760
10761 if (isSalted)
10762 {
10763 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10764 }
10765
10766 int parser_status = PARSER_OK;
10767
10768 if (hash_mode == 2500)
10769 {
10770 if (hash_len == 0)
10771 {
10772 log_error ("ERROR: hccap file not specified");
10773
10774 return (-1);
10775 }
10776
10777 hashlist_mode = HL_MODE_FILE;
10778
10779 data.hashlist_mode = hashlist_mode;
10780
10781 FILE *fp = fopen (hash_buf, "rb");
10782
10783 if (fp == NULL)
10784 {
10785 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10786
10787 return (-1);
10788 }
10789
10790 if (hashes_avail < 1)
10791 {
10792 log_error ("ERROR: hccap file is empty or corrupt");
10793
10794 fclose (fp);
10795
10796 return (-1);
10797 }
10798
10799 uint hccap_size = sizeof (hccap_t);
10800
10801 char *in = (char *) mymalloc (hccap_size);
10802
10803 while (!feof (fp))
10804 {
10805 int n = fread (in, hccap_size, 1, fp);
10806
10807 if (n != 1)
10808 {
10809 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10810
10811 break;
10812 }
10813
10814 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10815
10816 if (parser_status != PARSER_OK)
10817 {
10818 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10819
10820 continue;
10821 }
10822
10823 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10824
10825 if ((show == 1) || (left == 1))
10826 {
10827 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10828
10829 char *salt_ptr = (char *) tmp_salt->salt_buf;
10830
10831 int cur_pos = tmp_salt->salt_len;
10832 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10833
10834 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10835
10836 u8 *pke_ptr = (u8 *) wpa->pke;
10837
10838 // do the appending task
10839
10840 snprintf (salt_ptr + cur_pos,
10841 rem_len,
10842 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10843 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10844 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10845
10846
10847 // memset () the remaining part of the salt
10848
10849 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10850 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10851
10852 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10853
10854 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10855 }
10856
10857 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);
10858 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);
10859
10860 hashes_cnt++;
10861 }
10862
10863 fclose (fp);
10864
10865 myfree (in);
10866 }
10867 else if (hash_mode == 3000)
10868 {
10869 if (hash_len == 32)
10870 {
10871 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10872
10873 hash_t *lm_hash_left = NULL;
10874
10875 if (parser_status == PARSER_OK)
10876 {
10877 lm_hash_left = &hashes_buf[hashes_cnt];
10878
10879 hashes_cnt++;
10880 }
10881 else
10882 {
10883 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10884 }
10885
10886 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10887
10888 hash_t *lm_hash_right = NULL;
10889
10890 if (parser_status == PARSER_OK)
10891 {
10892 lm_hash_right = &hashes_buf[hashes_cnt];
10893
10894 hashes_cnt++;
10895 }
10896 else
10897 {
10898 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10899 }
10900
10901 // show / left
10902
10903 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10904 {
10905 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);
10906 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);
10907 }
10908 }
10909 else
10910 {
10911 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10912
10913 if (parser_status == PARSER_OK)
10914 {
10915 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10916 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10917 }
10918
10919 if (parser_status == PARSER_OK)
10920 {
10921 hashes_cnt++;
10922 }
10923 else
10924 {
10925 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10926 }
10927 }
10928 }
10929 else
10930 {
10931 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10932
10933 if (parser_status == PARSER_OK)
10934 {
10935 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10936 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10937 }
10938
10939 if (parser_status == PARSER_OK)
10940 {
10941 hashes_cnt++;
10942 }
10943 else
10944 {
10945 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10946 }
10947 }
10948 }
10949 }
10950 else if (hashlist_mode == HL_MODE_FILE)
10951 {
10952 char *hashfile = data.hashfile;
10953
10954 FILE *fp;
10955
10956 if ((fp = fopen (hashfile, "rb")) == NULL)
10957 {
10958 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10959
10960 return (-1);
10961 }
10962
10963 uint line_num = 0;
10964
10965 while (!feof (fp))
10966 {
10967 line_num++;
10968
10969 char line_buf[BUFSIZ] = { 0 };
10970
10971 int line_len = fgetl (fp, line_buf);
10972
10973 if (line_len == 0) continue;
10974
10975 char *hash_buf = NULL;
10976 int hash_len = 0;
10977
10978 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10979
10980 if (username)
10981 {
10982 char *user_buf = NULL;
10983 int user_len = 0;
10984
10985 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10986
10987 if (remove || show)
10988 {
10989 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10990
10991 *user = (user_t *) mymalloc (sizeof (user_t));
10992
10993 user_t *user_ptr = *user;
10994
10995 if (user_buf != NULL)
10996 {
10997 user_ptr->user_name = mystrdup (user_buf);
10998 }
10999 else
11000 {
11001 user_ptr->user_name = mystrdup ("");
11002 }
11003
11004 user_ptr->user_len = user_len;
11005 }
11006 }
11007
11008 if (opts_type & OPTS_TYPE_HASH_COPY)
11009 {
11010 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11011
11012 hash_info_tmp->orighash = mystrdup (hash_buf);
11013 }
11014
11015 if (isSalted)
11016 {
11017 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11018 }
11019
11020 if (hash_mode == 3000)
11021 {
11022 if (hash_len == 32)
11023 {
11024 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11025
11026 if (parser_status < PARSER_GLOBAL_ZERO)
11027 {
11028 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11029
11030 continue;
11031 }
11032
11033 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11034
11035 hashes_cnt++;
11036
11037 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11038
11039 if (parser_status < PARSER_GLOBAL_ZERO)
11040 {
11041 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11042
11043 continue;
11044 }
11045
11046 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11047
11048 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);
11049
11050 hashes_cnt++;
11051
11052 // show / left
11053
11054 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);
11055 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);
11056 }
11057 else
11058 {
11059 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11060
11061 if (parser_status < PARSER_GLOBAL_ZERO)
11062 {
11063 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11064
11065 continue;
11066 }
11067
11068 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);
11069
11070 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11071 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11072
11073 hashes_cnt++;
11074 }
11075 }
11076 else
11077 {
11078 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11079
11080 if (parser_status < PARSER_GLOBAL_ZERO)
11081 {
11082 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11083
11084 continue;
11085 }
11086
11087 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);
11088
11089 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11090 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11091
11092 hashes_cnt++;
11093 }
11094 }
11095
11096 fclose (fp);
11097
11098 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11099
11100 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11101 }
11102 }
11103 else
11104 {
11105 if (isSalted)
11106 {
11107 hashes_buf[0].salt->salt_len = 8;
11108
11109 // special salt handling
11110
11111 switch (hash_mode)
11112 {
11113 case 1500: hashes_buf[0].salt->salt_len = 2;
11114 break;
11115 case 1731: hashes_buf[0].salt->salt_len = 4;
11116 break;
11117 case 2410: hashes_buf[0].salt->salt_len = 4;
11118 break;
11119 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11120 break;
11121 case 3100: hashes_buf[0].salt->salt_len = 1;
11122 break;
11123 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11124 break;
11125 case 5800: hashes_buf[0].salt->salt_len = 16;
11126 break;
11127 case 6800: hashes_buf[0].salt->salt_len = 32;
11128 break;
11129 case 8400: hashes_buf[0].salt->salt_len = 40;
11130 break;
11131 case 8800: hashes_buf[0].salt->salt_len = 16;
11132 break;
11133 case 8900: hashes_buf[0].salt->salt_len = 16;
11134 hashes_buf[0].salt->scrypt_N = 1024;
11135 hashes_buf[0].salt->scrypt_r = 1;
11136 hashes_buf[0].salt->scrypt_p = 1;
11137 break;
11138 case 9100: hashes_buf[0].salt->salt_len = 16;
11139 break;
11140 case 9300: hashes_buf[0].salt->salt_len = 14;
11141 hashes_buf[0].salt->scrypt_N = 16384;
11142 hashes_buf[0].salt->scrypt_r = 1;
11143 hashes_buf[0].salt->scrypt_p = 1;
11144 break;
11145 case 9400: hashes_buf[0].salt->salt_len = 16;
11146 break;
11147 case 9500: hashes_buf[0].salt->salt_len = 16;
11148 break;
11149 case 9600: hashes_buf[0].salt->salt_len = 16;
11150 break;
11151 case 9700: hashes_buf[0].salt->salt_len = 16;
11152 break;
11153 case 9710: hashes_buf[0].salt->salt_len = 16;
11154 break;
11155 case 9720: hashes_buf[0].salt->salt_len = 16;
11156 break;
11157 case 9800: hashes_buf[0].salt->salt_len = 16;
11158 break;
11159 case 9810: hashes_buf[0].salt->salt_len = 16;
11160 break;
11161 case 9820: hashes_buf[0].salt->salt_len = 16;
11162 break;
11163 case 10300: hashes_buf[0].salt->salt_len = 12;
11164 break;
11165 case 11500: hashes_buf[0].salt->salt_len = 4;
11166 break;
11167 case 11600: hashes_buf[0].salt->salt_len = 4;
11168 break;
11169 case 12400: hashes_buf[0].salt->salt_len = 4;
11170 break;
11171 case 12500: hashes_buf[0].salt->salt_len = 8;
11172 break;
11173 case 12600: hashes_buf[0].salt->salt_len = 64;
11174 break;
11175 }
11176
11177 // special esalt handling
11178
11179 switch (hash_mode)
11180 {
11181 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11182 break;
11183 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11184 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11185 break;
11186 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11187 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11188 break;
11189 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11190 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11191 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11192 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11193 break;
11194 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11195 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11196 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11197 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11198 break;
11199 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11200 break;
11201 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11202 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11203 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11204 break;
11205 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11206 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11207 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11208 break;
11209 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11210 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11211 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11212 break;
11213 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11214 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11215 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11216 break;
11217 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11218 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11219 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11220 break;
11221 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11222 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11223 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11224 break;
11225 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11226 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11227 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11228 break;
11229 }
11230 }
11231
11232 // set hashfile
11233
11234 switch (hash_mode)
11235 {
11236 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11237 break;
11238 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11239 break;
11240 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11241 break;
11242 case 6211:
11243 case 6212:
11244 case 6213:
11245 case 6221:
11246 case 6222:
11247 case 6223:
11248 case 6231:
11249 case 6232:
11250 case 6233:
11251 case 6241:
11252 case 6242:
11253 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11254 break;
11255 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11256 break;
11257 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11258 break;
11259 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11260 break;
11261 }
11262
11263 // set default iterations
11264
11265 switch (hash_mode)
11266 {
11267 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11268 break;
11269 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11270 break;
11271 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11272 break;
11273 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11274 break;
11275 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11276 break;
11277 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11278 break;
11279 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11280 break;
11281 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11282 break;
11283 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11284 break;
11285 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11286 break;
11287 case 6211:
11288 case 6212:
11289 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11290 break;
11291 case 6221:
11292 case 6222:
11293 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11294 break;
11295 case 6231:
11296 case 6232:
11297 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11298 break;
11299 case 6241:
11300 case 6242:
11301 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11302 break;
11303 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11304 break;
11305 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11306 break;
11307 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11308 break;
11309 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11310 break;
11311 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11312 break;
11313 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11314 break;
11315 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11316 break;
11317 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11318 break;
11319 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11320 break;
11321 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11322 break;
11323 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11324 break;
11325 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11326 break;
11327 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11328 break;
11329 case 8900: hashes_buf[0].salt->salt_iter = 1;
11330 break;
11331 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11332 break;
11333 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11334 break;
11335 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11336 break;
11337 case 9300: hashes_buf[0].salt->salt_iter = 1;
11338 break;
11339 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11340 break;
11341 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11342 break;
11343 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11344 break;
11345 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11346 break;
11347 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11348 break;
11349 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11350 break;
11351 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11352 break;
11353 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11354 break;
11355 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11356 break;
11357 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11358 break;
11359 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11360 break;
11361 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11362 break;
11363 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11364 break;
11365 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11366 break;
11367 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11368 break;
11369 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11370 break;
11371 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11372 break;
11373 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11374 break;
11375 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11376 break;
11377 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11378 break;
11379 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11380 break;
11381 }
11382
11383 // set special tuning for benchmark-mode 1
11384
11385 if (benchmark_mode == 1)
11386 {
11387 kernel_loops *= 8;
11388 kernel_accel *= 4;
11389
11390 switch (hash_mode)
11391 {
11392 case 400: kernel_loops = ROUNDS_PHPASS;
11393 kernel_accel = 32;
11394 break;
11395 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11396 kernel_accel = 32;
11397 break;
11398 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11399 kernel_accel = 32;
11400 break;
11401 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11402 kernel_accel = 32;
11403 break;
11404 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11405 kernel_accel = 16;
11406 break;
11407 case 2100: kernel_loops = ROUNDS_DCC2;
11408 kernel_accel = 16;
11409 break;
11410 case 2500: kernel_loops = ROUNDS_WPA2;
11411 kernel_accel = 32;
11412 break;
11413 case 3200: kernel_loops = ROUNDS_BCRYPT;
11414 kernel_accel = 8;
11415 break;
11416 case 5200: kernel_loops = ROUNDS_PSAFE3;
11417 kernel_accel = 16;
11418 break;
11419 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11420 kernel_accel = 16;
11421 break;
11422 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11423 #ifndef OSX
11424 kernel_accel = 64;
11425 #endif
11426 break;
11427 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11428 kernel_accel = 32;
11429 break;
11430 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11431 kernel_accel = 32;
11432 break;
11433 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11434 kernel_accel = 8;
11435 break;
11436 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11437 kernel_accel = 8;
11438 break;
11439 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11440 kernel_accel = 8;
11441 break;
11442 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11443 kernel_accel = 8;
11444 break;
11445 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11446 kernel_accel = 8;
11447 break;
11448 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11449 kernel_accel = 8;
11450 break;
11451 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11452 #ifndef OSX
11453 kernel_accel = 128;
11454 #endif
11455 break;
11456 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11457 kernel_accel = 64;
11458 break;
11459 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11460 kernel_accel = 64;
11461 break;
11462 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11463 kernel_accel = 32;
11464 break;
11465 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11466 kernel_accel = 128;
11467 break;
11468 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11469 kernel_accel = 128;
11470 break;
11471 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11472 kernel_accel = 32;
11473 break;
11474 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11475 kernel_accel = 64;
11476 break;
11477 case 6800: kernel_loops = ROUNDS_LASTPASS;
11478 kernel_accel = 64;
11479 break;
11480 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11481 kernel_accel = 8;
11482 break;
11483 case 7200: kernel_loops = ROUNDS_GRUB;
11484 #ifndef OSX
11485 kernel_accel = 16;
11486 #endif
11487 break;
11488 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11489 kernel_accel = 8;
11490 break;
11491 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11492 kernel_accel = 8;
11493 break;
11494 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11495 kernel_accel = 8;
11496 break;
11497 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11498 kernel_accel = 32;
11499 break;
11500 case 8900: kernel_loops = 1;
11501 kernel_accel = 64;
11502 break;
11503 case 9000: kernel_loops = ROUNDS_PSAFE2;
11504 kernel_accel = 16;
11505 break;
11506 case 9100: kernel_loops = ROUNDS_LOTUS8;
11507 kernel_accel = 64;
11508 break;
11509 case 9200: kernel_loops = ROUNDS_CISCO8;
11510 kernel_accel = 8;
11511 break;
11512 case 9300: kernel_loops = 1;
11513 kernel_accel = 4;
11514 break;
11515 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11516 kernel_accel = 32;
11517 break;
11518 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11519 kernel_accel = 32;
11520 break;
11521 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11522 kernel_accel = 8;
11523 break;
11524 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11525 kernel_accel = 8;
11526 break;
11527 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11528 kernel_accel = 16;
11529 break;
11530 case 10500: kernel_loops = ROUNDS_PDF14;
11531 kernel_accel = 256;
11532 break;
11533 case 10700: kernel_loops = ROUNDS_PDF17L8;
11534 kernel_accel = 8;
11535 break;
11536 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11537 kernel_accel = 8;
11538 break;
11539 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11540 kernel_accel = 8;
11541 break;
11542 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11543 kernel_accel = 8;
11544 break;
11545 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11546 kernel_accel = 8;
11547 break;
11548 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11549 kernel_accel = 8;
11550 break;
11551 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11552 kernel_accel = 8;
11553 break;
11554 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11555 kernel_accel = 8;
11556 break;
11557 case 12300: kernel_loops = ROUNDS_ORACLET;
11558 kernel_accel = 8;
11559 break;
11560 case 12500: kernel_loops = ROUNDS_RAR3;
11561 kernel_accel = 32;
11562 break;
11563 case 12700: kernel_loops = ROUNDS_MYWALLET;
11564 kernel_accel = 512;
11565 break;
11566 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11567 kernel_accel = 512;
11568 break;
11569 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11570 kernel_accel = 8;
11571 break;
11572 case 13000: kernel_loops = ROUNDS_RAR5;
11573 kernel_accel = 8;
11574 break;
11575 }
11576
11577 // some algorithm collide too fast, make that impossible
11578
11579 switch (hash_mode)
11580 {
11581 case 11500: ((uint *) digests_buf)[1] = 1;
11582 break;
11583 }
11584
11585 if (kernel_loops > 1024) kernel_loops = 1024;
11586 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11587 }
11588
11589 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11590 {
11591 kernel_loops = 1024;
11592 }
11593
11594 if (hash_mode == 12500)
11595 {
11596 kernel_loops = ROUNDS_RAR3 / 16;
11597 }
11598
11599 data.kernel_accel = kernel_accel;
11600 data.kernel_loops = kernel_loops;
11601
11602 hashes_cnt = 1;
11603 }
11604
11605 if (show == 1 || left == 1)
11606 {
11607 for (uint i = 0; i < pot_cnt; i++)
11608 {
11609 pot_t *pot_ptr = &pot[i];
11610
11611 hash_t *hashes_buf = &pot_ptr->hash;
11612
11613 local_free (hashes_buf->digest);
11614
11615 if (isSalted)
11616 {
11617 local_free (hashes_buf->salt);
11618 }
11619 }
11620
11621 local_free (pot);
11622
11623 if (data.quiet == 0) log_info_nn ("");
11624
11625 return (0);
11626 }
11627
11628 if (keyspace == 0)
11629 {
11630 if (hashes_cnt == 0)
11631 {
11632 log_error ("ERROR: No hashes loaded");
11633
11634 return (-1);
11635 }
11636 }
11637
11638 /**
11639 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11640 */
11641
11642 if (data.outfile != NULL)
11643 {
11644 if (data.hashfile != NULL)
11645 {
11646 #ifdef _POSIX
11647 struct stat tmpstat_outfile;
11648 struct stat tmpstat_hashfile;
11649 #endif
11650
11651 #ifdef _WIN
11652 struct stat64 tmpstat_outfile;
11653 struct stat64 tmpstat_hashfile;
11654 #endif
11655
11656 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11657
11658 if (tmp_outfile_fp)
11659 {
11660 #ifdef _POSIX
11661 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11662 #endif
11663
11664 #ifdef _WIN
11665 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11666 #endif
11667
11668 fclose (tmp_outfile_fp);
11669 }
11670
11671 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11672
11673 if (tmp_hashfile_fp)
11674 {
11675 #ifdef _POSIX
11676 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11677 #endif
11678
11679 #ifdef _WIN
11680 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11681 #endif
11682
11683 fclose (tmp_hashfile_fp);
11684 }
11685
11686 if (tmp_outfile_fp && tmp_outfile_fp)
11687 {
11688 tmpstat_outfile.st_mode = 0;
11689 tmpstat_outfile.st_nlink = 0;
11690 tmpstat_outfile.st_uid = 0;
11691 tmpstat_outfile.st_gid = 0;
11692 tmpstat_outfile.st_rdev = 0;
11693 tmpstat_outfile.st_atime = 0;
11694
11695 tmpstat_hashfile.st_mode = 0;
11696 tmpstat_hashfile.st_nlink = 0;
11697 tmpstat_hashfile.st_uid = 0;
11698 tmpstat_hashfile.st_gid = 0;
11699 tmpstat_hashfile.st_rdev = 0;
11700 tmpstat_hashfile.st_atime = 0;
11701
11702 #ifdef _POSIX
11703 tmpstat_outfile.st_blksize = 0;
11704 tmpstat_outfile.st_blocks = 0;
11705
11706 tmpstat_hashfile.st_blksize = 0;
11707 tmpstat_hashfile.st_blocks = 0;
11708 #endif
11709
11710 #ifdef _POSIX
11711 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11712 {
11713 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11714
11715 return (-1);
11716 }
11717 #endif
11718
11719 #ifdef _WIN
11720 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11721 {
11722 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11723
11724 return (-1);
11725 }
11726 #endif
11727 }
11728 }
11729 }
11730
11731 /**
11732 * Remove duplicates
11733 */
11734
11735 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11736
11737 if (isSalted)
11738 {
11739 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11740 }
11741 else
11742 {
11743 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11744 }
11745
11746 uint hashes_cnt_orig = hashes_cnt;
11747
11748 hashes_cnt = 1;
11749
11750 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11751 {
11752 if (isSalted)
11753 {
11754 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11755 {
11756 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11757 }
11758 }
11759 else
11760 {
11761 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11762 }
11763
11764 if (hashes_pos > hashes_cnt)
11765 {
11766 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11767 }
11768
11769 hashes_cnt++;
11770 }
11771
11772 /**
11773 * Potfile removes
11774 */
11775
11776 uint potfile_remove_cracks = 0;
11777
11778 if (potfile_disable == 0)
11779 {
11780 hash_t hash_buf;
11781
11782 hash_buf.digest = mymalloc (dgst_size);
11783 hash_buf.salt = NULL;
11784 hash_buf.esalt = NULL;
11785 hash_buf.hash_info = NULL;
11786 hash_buf.cracked = 0;
11787
11788 if (isSalted)
11789 {
11790 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11791 }
11792
11793 if (esalt_size)
11794 {
11795 hash_buf.esalt = mymalloc (esalt_size);
11796 }
11797
11798 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11799
11800 // no solution for these special hash types (for instane because they use hashfile in output etc)
11801 if ((hash_mode != 5200) &&
11802 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11803 (hash_mode != 9000))
11804 {
11805 FILE *fp = fopen (potfile, "rb");
11806
11807 if (fp != NULL)
11808 {
11809 while (!feof (fp))
11810 {
11811 char line_buf[BUFSIZ] = { 0 };
11812
11813 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11814
11815 if (ptr == NULL) break;
11816
11817 int line_len = strlen (line_buf);
11818
11819 if (line_len == 0) continue;
11820
11821 int iter = MAX_CUT_TRIES;
11822
11823 for (int i = line_len - 1; i && iter; i--, line_len--)
11824 {
11825 if (line_buf[i] != ':') continue;
11826
11827 if (isSalted)
11828 {
11829 memset (hash_buf.salt, 0, sizeof (salt_t));
11830 }
11831
11832 hash_t *found = NULL;
11833
11834 if (hash_mode == 6800)
11835 {
11836 if (i < 48) // 48 = 12 * uint in salt_buf[]
11837 {
11838 // manipulate salt_buf
11839 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11840
11841 hash_buf.salt->salt_len = i;
11842
11843 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11844 }
11845 }
11846 else if (hash_mode == 2500)
11847 {
11848 if (i < 48) // 48 = 12 * uint in salt_buf[]
11849 {
11850 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11851 // manipulate salt_buf
11852
11853 // to be safe work with a copy (because of line_len loop, i etc)
11854
11855 char line_buf_cpy[BUFSIZ] = { 0 };
11856
11857 memcpy (line_buf_cpy, line_buf, i);
11858
11859 char *mac2_pos = strrchr (line_buf_cpy, ':');
11860
11861 if (mac2_pos == NULL) continue;
11862
11863 mac2_pos[0] = 0;
11864 mac2_pos++;
11865
11866 if (strlen (mac2_pos) != 12) continue;
11867
11868 char *mac1_pos = strrchr (line_buf_cpy, ':');
11869
11870 if (mac1_pos == NULL) continue;
11871
11872 mac1_pos[0] = 0;
11873 mac1_pos++;
11874
11875 if (strlen (mac1_pos) != 12) continue;
11876
11877 uint essid_length = mac1_pos - line_buf_cpy - 1;
11878
11879 // here we need the ESSID
11880 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11881
11882 hash_buf.salt->salt_len = essid_length;
11883
11884 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11885
11886 if (found)
11887 {
11888 wpa_t *wpa = (wpa_t *) found->esalt;
11889
11890 uint pke[25] = { 0 };
11891
11892 char *pke_ptr = (char *) pke;
11893
11894 for (uint i = 0; i < 25; i++)
11895 {
11896 pke[i] = byte_swap_32 (wpa->pke[i]);
11897 }
11898
11899 u8 mac1[6] = { 0 };
11900 u8 mac2[6] = { 0 };
11901
11902 memcpy (mac1, pke_ptr + 23, 6);
11903 memcpy (mac2, pke_ptr + 29, 6);
11904
11905 // compare hex string(s) vs binary MAC address(es)
11906
11907 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11908 {
11909 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11910 {
11911 found = NULL;
11912 break;
11913 }
11914 }
11915
11916 // early skip ;)
11917 if (!found) continue;
11918
11919 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11920 {
11921 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11922 {
11923 found = NULL;
11924 break;
11925 }
11926 }
11927 }
11928 }
11929 }
11930 else
11931 {
11932 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11933
11934 if (parser_status == PARSER_OK)
11935 {
11936 if (isSalted)
11937 {
11938 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11939 }
11940 else
11941 {
11942 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11943 }
11944 }
11945 }
11946
11947 if (found == NULL) continue;
11948
11949 if (!found->cracked) potfile_remove_cracks++;
11950
11951 found->cracked = 1;
11952
11953 if (found) break;
11954
11955 iter--;
11956 }
11957 }
11958
11959 fclose (fp);
11960 }
11961 }
11962
11963 if (esalt_size)
11964 {
11965 local_free (hash_buf.esalt);
11966 }
11967
11968 if (isSalted)
11969 {
11970 local_free (hash_buf.salt);
11971 }
11972
11973 local_free (hash_buf.digest);
11974 }
11975
11976 /**
11977 * Now generate all the buffers required for later
11978 */
11979
11980 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11981
11982 salt_t *salts_buf_new = NULL;
11983 void *esalts_buf_new = NULL;
11984
11985 if (isSalted)
11986 {
11987 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11988
11989 if (esalt_size)
11990 {
11991 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11992 }
11993 }
11994 else
11995 {
11996 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11997 }
11998
11999 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12000
12001 uint digests_cnt = hashes_cnt;
12002 uint digests_done = 0;
12003
12004 uint size_digests = digests_cnt * dgst_size;
12005 uint size_shown = digests_cnt * sizeof (uint);
12006
12007 uint *digests_shown = (uint *) mymalloc (size_shown);
12008 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12009
12010 uint salts_cnt = 0;
12011 uint salts_done = 0;
12012
12013 hashinfo_t **hash_info = NULL;
12014
12015 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12016 {
12017 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12018
12019 if (username && (remove || show))
12020 {
12021 uint user_pos;
12022
12023 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12024 {
12025 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12026
12027 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12028 }
12029 }
12030 }
12031
12032 uint *salts_shown = (uint *) mymalloc (size_shown);
12033
12034 salt_t *salt_buf;
12035
12036 {
12037 // copied from inner loop
12038
12039 salt_buf = &salts_buf_new[salts_cnt];
12040
12041 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12042
12043 if (esalt_size)
12044 {
12045 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12046 }
12047
12048 salt_buf->digests_cnt = 0;
12049 salt_buf->digests_done = 0;
12050 salt_buf->digests_offset = 0;
12051
12052 salts_cnt++;
12053 }
12054
12055 if (hashes_buf[0].cracked == 1)
12056 {
12057 digests_shown[0] = 1;
12058
12059 digests_done++;
12060
12061 salt_buf->digests_done++;
12062 }
12063
12064 salt_buf->digests_cnt++;
12065
12066 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12067
12068 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12069 {
12070 hash_info[0] = hashes_buf[0].hash_info;
12071 }
12072
12073 // copy from inner loop
12074
12075 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12076 {
12077 if (isSalted)
12078 {
12079 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12080 {
12081 salt_buf = &salts_buf_new[salts_cnt];
12082
12083 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12084
12085 if (esalt_size)
12086 {
12087 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12088 }
12089
12090 salt_buf->digests_cnt = 0;
12091 salt_buf->digests_done = 0;
12092 salt_buf->digests_offset = hashes_pos;
12093
12094 salts_cnt++;
12095 }
12096 }
12097
12098 if (hashes_buf[hashes_pos].cracked == 1)
12099 {
12100 digests_shown[hashes_pos] = 1;
12101
12102 digests_done++;
12103
12104 salt_buf->digests_done++;
12105 }
12106
12107 salt_buf->digests_cnt++;
12108
12109 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12110
12111 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12112 {
12113 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12114 }
12115 }
12116
12117 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12118 {
12119 salt_t *salt_buf = &salts_buf_new[salt_pos];
12120
12121 if (salt_buf->digests_done == salt_buf->digests_cnt)
12122 {
12123 salts_shown[salt_pos] = 1;
12124
12125 salts_done++;
12126 }
12127
12128 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12129 }
12130
12131 local_free (digests_buf);
12132 local_free (salts_buf);
12133 local_free (esalts_buf);
12134
12135 digests_buf = digests_buf_new;
12136 salts_buf = salts_buf_new;
12137 esalts_buf = esalts_buf_new;
12138
12139 local_free (hashes_buf);
12140
12141 /**
12142 * special modification not set from parser
12143 */
12144
12145 switch (hash_mode)
12146 {
12147 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12148 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12149 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12150 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12151 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12152 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12153 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12154 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12155 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12156 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12157 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12158 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12159 }
12160
12161 if (truecrypt_keyfiles)
12162 {
12163 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12164
12165 char *keyfiles = strdup (truecrypt_keyfiles);
12166
12167 char *keyfile = strtok (keyfiles, ",");
12168
12169 do
12170 {
12171 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12172
12173 } while ((keyfile = strtok (NULL, ",")) != NULL);
12174
12175 free (keyfiles);
12176 }
12177
12178 data.digests_cnt = digests_cnt;
12179 data.digests_done = digests_done;
12180 data.digests_buf = digests_buf;
12181 data.digests_shown = digests_shown;
12182 data.digests_shown_tmp = digests_shown_tmp;
12183
12184 data.salts_cnt = salts_cnt;
12185 data.salts_done = salts_done;
12186 data.salts_buf = salts_buf;
12187 data.salts_shown = salts_shown;
12188
12189 data.esalts_buf = esalts_buf;
12190 data.hash_info = hash_info;
12191
12192 /**
12193 * Automatic Optimizers
12194 */
12195
12196 if (salts_cnt == 1)
12197 opti_type |= OPTI_TYPE_SINGLE_SALT;
12198
12199 if (digests_cnt == 1)
12200 opti_type |= OPTI_TYPE_SINGLE_HASH;
12201
12202 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12203 opti_type |= OPTI_TYPE_NOT_ITERATED;
12204
12205 if (attack_mode == ATTACK_MODE_BF)
12206 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12207
12208 data.opti_type = opti_type;
12209
12210 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12211 {
12212 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12213 {
12214 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12215 {
12216 if (opts_type & OPTS_TYPE_ST_ADD80)
12217 {
12218 opts_type &= ~OPTS_TYPE_ST_ADD80;
12219 opts_type |= OPTS_TYPE_PT_ADD80;
12220 }
12221
12222 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12223 {
12224 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12225 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12226 }
12227
12228 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12229 {
12230 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12231 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12232 }
12233 }
12234 }
12235 }
12236
12237 /**
12238 * Some algorithm, like descrypt, can benefit from JIT compilation
12239 */
12240
12241 int force_jit_compilation = -1;
12242
12243 if (hash_mode == 8900)
12244 {
12245 force_jit_compilation = 8900;
12246 }
12247 else if (hash_mode == 9300)
12248 {
12249 force_jit_compilation = 8900;
12250 }
12251 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12252 {
12253 force_jit_compilation = 1500;
12254 }
12255
12256 /**
12257 * generate bitmap tables
12258 */
12259
12260 const uint bitmap_shift1 = 5;
12261 const uint bitmap_shift2 = 13;
12262
12263 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12264
12265 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12266 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12267 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12268 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12269 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12270 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12271 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12272 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12273
12274 uint bitmap_bits;
12275 uint bitmap_nums;
12276 uint bitmap_mask;
12277 uint bitmap_size;
12278
12279 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12280 {
12281 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12282
12283 bitmap_nums = 1 << bitmap_bits;
12284
12285 bitmap_mask = bitmap_nums - 1;
12286
12287 bitmap_size = bitmap_nums * sizeof (uint);
12288
12289 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12290
12291 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;
12292 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;
12293
12294 break;
12295 }
12296
12297 bitmap_nums = 1 << bitmap_bits;
12298
12299 bitmap_mask = bitmap_nums - 1;
12300
12301 bitmap_size = bitmap_nums * sizeof (uint);
12302
12303 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);
12304 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);
12305
12306 /**
12307 * prepare quick rule
12308 */
12309
12310 data.rule_buf_l = rule_buf_l;
12311 data.rule_buf_r = rule_buf_r;
12312
12313 int rule_len_l = (int) strlen (rule_buf_l);
12314 int rule_len_r = (int) strlen (rule_buf_r);
12315
12316 data.rule_len_l = rule_len_l;
12317 data.rule_len_r = rule_len_r;
12318
12319 /**
12320 * load rules
12321 */
12322
12323 uint *all_kernel_rules_cnt = NULL;
12324
12325 kernel_rule_t **all_kernel_rules_buf = NULL;
12326
12327 if (rp_files_cnt)
12328 {
12329 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12330
12331 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12332 }
12333
12334 char rule_buf[BUFSIZ] = { 0 };
12335
12336 int rule_len = 0;
12337
12338 for (uint i = 0; i < rp_files_cnt; i++)
12339 {
12340 uint kernel_rules_avail = 0;
12341
12342 uint kernel_rules_cnt = 0;
12343
12344 kernel_rule_t *kernel_rules_buf = NULL;
12345
12346 char *rp_file = rp_files[i];
12347
12348 char in[BLOCK_SIZE] = { 0 };
12349 char out[BLOCK_SIZE] = { 0 };
12350
12351 FILE *fp = NULL;
12352
12353 uint rule_line = 0;
12354
12355 if ((fp = fopen (rp_file, "rb")) == NULL)
12356 {
12357 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12358
12359 return (-1);
12360 }
12361
12362 while (!feof (fp))
12363 {
12364 memset (rule_buf, 0, BUFSIZ);
12365
12366 rule_len = fgetl (fp, rule_buf);
12367
12368 rule_line++;
12369
12370 if (rule_len == 0) continue;
12371
12372 if (rule_buf[0] == '#') continue;
12373
12374 if (kernel_rules_avail == kernel_rules_cnt)
12375 {
12376 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12377
12378 kernel_rules_avail += INCR_RULES;
12379 }
12380
12381 memset (in, 0, BLOCK_SIZE);
12382 memset (out, 0, BLOCK_SIZE);
12383
12384 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12385
12386 if (result == -1)
12387 {
12388 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12389
12390 continue;
12391 }
12392
12393 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12394 {
12395 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12396
12397 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12398
12399 continue;
12400 }
12401
12402 /* its so slow
12403 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12404 {
12405 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12406
12407 continue;
12408 }
12409 */
12410
12411 kernel_rules_cnt++;
12412 }
12413
12414 fclose (fp);
12415
12416 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12417
12418 all_kernel_rules_buf[i] = kernel_rules_buf;
12419 }
12420
12421 /**
12422 * merge rules or automatic rule generator
12423 */
12424
12425 uint kernel_rules_cnt = 0;
12426
12427 kernel_rule_t *kernel_rules_buf = NULL;
12428
12429 if (attack_mode == ATTACK_MODE_STRAIGHT)
12430 {
12431 if (rp_files_cnt)
12432 {
12433 kernel_rules_cnt = 1;
12434
12435 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12436
12437 repeats[0] = kernel_rules_cnt;
12438
12439 for (uint i = 0; i < rp_files_cnt; i++)
12440 {
12441 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12442
12443 repeats[i + 1] = kernel_rules_cnt;
12444 }
12445
12446 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12447
12448 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12449
12450 for (uint i = 0; i < kernel_rules_cnt; i++)
12451 {
12452 uint out_pos = 0;
12453
12454 kernel_rule_t *out = &kernel_rules_buf[i];
12455
12456 for (uint j = 0; j < rp_files_cnt; j++)
12457 {
12458 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12459 uint in_pos;
12460
12461 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12462
12463 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12464 {
12465 if (out_pos == RULES_MAX - 1)
12466 {
12467 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12468
12469 break;
12470 }
12471
12472 out->cmds[out_pos] = in->cmds[in_pos];
12473 }
12474 }
12475 }
12476
12477 local_free (repeats);
12478 }
12479 else if (rp_gen)
12480 {
12481 uint kernel_rules_avail = 0;
12482
12483 while (kernel_rules_cnt < rp_gen)
12484 {
12485 if (kernel_rules_avail == kernel_rules_cnt)
12486 {
12487 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12488
12489 kernel_rules_avail += INCR_RULES;
12490 }
12491
12492 memset (rule_buf, 0, BLOCK_SIZE);
12493
12494 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12495
12496 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12497
12498 kernel_rules_cnt++;
12499 }
12500 }
12501 }
12502
12503 /**
12504 * generate NOP rules
12505 */
12506
12507 if (kernel_rules_cnt == 0)
12508 {
12509 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12510
12511 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12512
12513 kernel_rules_cnt++;
12514 }
12515
12516 data.kernel_rules_cnt = kernel_rules_cnt;
12517 data.kernel_rules_buf = kernel_rules_buf;
12518
12519 /**
12520 * OpenCL platforms: detect
12521 */
12522
12523 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12524
12525 cl_uint platforms_cnt = 0;
12526
12527 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12528
12529 cl_uint platform_devices_cnt;
12530
12531 if (keyspace == 0)
12532 {
12533 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12534
12535 if (platforms_cnt == 0)
12536 {
12537 log_error ("ERROR: No OpenCL compatible platform found");
12538
12539 return (-1);
12540 }
12541 }
12542
12543 /**
12544 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12545 */
12546
12547 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12548 {
12549 cl_platform_id platform = platforms[platform_id];
12550
12551 char platform_vendor[INFOSZ] = { 0 };
12552
12553 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12554
12555 #ifdef HAVE_HWMON
12556 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12557 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12558 {
12559 // make sure that we do not directly control the fan for NVidia
12560
12561 gpu_temp_retain = 0;
12562
12563 data.gpu_temp_retain = gpu_temp_retain;
12564 }
12565 #endif // HAVE_NVML || HAVE_NVAPI
12566 #endif
12567 }
12568
12569 /**
12570 * OpenCL devices: simply push all devices from all platforms into the same device array
12571 */
12572
12573 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12574
12575 data.devices_param = devices_param;
12576
12577 uint devices_cnt = 0;
12578
12579 uint devices_active = 0;
12580
12581 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12582 {
12583 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12584
12585 cl_platform_id platform = platforms[platform_id];
12586
12587 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12588
12589 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12590 {
12591 const uint device_id = devices_cnt;
12592
12593 hc_device_param_t *device_param = &data.devices_param[device_id];
12594
12595 device_param->device = platform_devices[platform_devices_id];
12596
12597 device_param->device_id = device_id;
12598
12599 device_param->platform_devices_id = platform_devices_id;
12600
12601 // device_type
12602
12603 cl_device_type device_type;
12604
12605 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12606
12607 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12608
12609 device_param->device_type = device_type;
12610
12611 // vendor_id
12612
12613 cl_uint vendor_id = 0;
12614
12615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12616
12617 device_param->vendor_id = vendor_id;
12618
12619 // device_name
12620
12621 char *device_name = (char *) mymalloc (INFOSZ);
12622
12623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12624
12625 device_param->device_name = device_name;
12626
12627 // device_version
12628
12629 char *device_version = (char *) mymalloc (INFOSZ);
12630
12631 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12632
12633 device_param->device_version = device_version;
12634
12635 if (strstr (device_version, "pocl"))
12636 {
12637 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12638 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12639
12640 cl_uint vendor_id = VENDOR_ID_GENERIC;
12641
12642 device_param->vendor_id = vendor_id;
12643 }
12644
12645 // max_compute_units
12646
12647 cl_uint vector_width;
12648
12649 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12650 {
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12652
12653 if ((vendor_id == VENDOR_ID_NV) && (strstr (device_name, " Ti") || strstr (device_name, " TI")))
12654 {
12655 // Yeah that's a super bad hack, but there's no other attribute we could use
12656
12657 if (vector_width < 2) vector_width *= 2;
12658 }
12659
12660 if (opti_type & OPTI_TYPE_USES_BITS_64)
12661 {
12662 if (vector_width > 1) vector_width /= 2;
12663 }
12664 }
12665 else
12666 {
12667 vector_width = opencl_vector_width;
12668 }
12669
12670 if (vector_width > 8) vector_width = 8;
12671
12672 device_param->vector_width = vector_width;
12673
12674 // max_compute_units
12675
12676 cl_uint device_processors;
12677
12678 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12679
12680 device_param->device_processors = device_processors;
12681
12682 // max_mem_alloc_size
12683
12684 cl_ulong device_maxmem_alloc;
12685
12686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12687
12688 device_param->device_maxmem_alloc = device_maxmem_alloc;
12689
12690 // max_mem_alloc_size
12691
12692 cl_ulong device_global_mem;
12693
12694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12695
12696 device_param->device_global_mem = device_global_mem;
12697
12698 // max_clock_frequency
12699
12700 cl_uint device_maxclock_frequency;
12701
12702 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12703
12704 device_param->device_maxclock_frequency = device_maxclock_frequency;
12705
12706 // skipped
12707
12708 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12709 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12710
12711 device_param->skipped = (skipped1 || skipped2);
12712
12713 // driver_version
12714
12715 char *driver_version = (char *) mymalloc (INFOSZ);
12716
12717 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12718
12719 device_param->driver_version = driver_version;
12720
12721 // device_name_chksum
12722
12723 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12724
12725 #if __x86_64__
12726 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);
12727 #else
12728 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);
12729 #endif
12730
12731 uint device_name_digest[4] = { 0 };
12732
12733 md5_64 ((uint *) device_name_chksum, device_name_digest);
12734
12735 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12736
12737 device_param->device_name_chksum = device_name_chksum;
12738
12739 // device_processor_cores
12740
12741 if (device_type & CL_DEVICE_TYPE_CPU)
12742 {
12743 cl_uint device_processor_cores = 1;
12744
12745 device_param->device_processor_cores = device_processor_cores;
12746 }
12747
12748 if (device_type & CL_DEVICE_TYPE_GPU)
12749 {
12750 if (vendor_id == VENDOR_ID_AMD)
12751 {
12752 cl_uint device_processor_cores = 0;
12753
12754 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12755
12756 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12757
12758 device_param->device_processor_cores = device_processor_cores;
12759 }
12760 else if (vendor_id == VENDOR_ID_NV)
12761 {
12762 cl_uint kernel_exec_timeout = 0;
12763
12764 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12765
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12767
12768 device_param->kernel_exec_timeout = kernel_exec_timeout;
12769
12770 cl_uint device_processor_cores = 0;
12771
12772 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12775
12776 device_param->device_processor_cores = device_processor_cores;
12777
12778 cl_uint sm_minor = 0;
12779 cl_uint sm_major = 0;
12780
12781 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12782 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12783
12784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12785 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12786
12787 device_param->sm_minor = sm_minor;
12788 device_param->sm_major = sm_major;
12789 }
12790 else
12791 {
12792 cl_uint device_processor_cores = 1;
12793
12794 device_param->device_processor_cores = device_processor_cores;
12795 }
12796 }
12797
12798 // display results
12799
12800 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12801 {
12802 if (device_param->skipped == 0)
12803 {
12804 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12805 device_id + 1,
12806 device_name,
12807 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12808 (unsigned int) (device_global_mem / 1024 / 1024),
12809 (unsigned int) (device_maxclock_frequency),
12810 (unsigned int) device_processors);
12811 }
12812 else
12813 {
12814 log_info ("Device #%u: %s, skipped",
12815 device_id + 1,
12816 device_name);
12817 }
12818 }
12819
12820 // common driver check
12821
12822 if (device_param->skipped == 0)
12823 {
12824 if (strstr (device_version, "pocl"))
12825 {
12826 if (force == 0)
12827 {
12828 log_info ("");
12829 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12830 log_info ("You are STRONGLY encouraged not to use it");
12831 log_info ("You can use --force to override this but do not post error reports if you do so");
12832 log_info ("");
12833
12834 return (-1);
12835 }
12836 }
12837
12838 if (device_type & CL_DEVICE_TYPE_GPU)
12839 {
12840 if (vendor_id == VENDOR_ID_NV)
12841 {
12842 if (device_param->kernel_exec_timeout != 0)
12843 {
12844 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);
12845 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12846 }
12847 }
12848 else if (vendor_id == VENDOR_ID_AMD)
12849 {
12850 int catalyst_check = (force == 1) ? 0 : 1;
12851
12852 int catalyst_warn = 0;
12853
12854 int catalyst_broken = 0;
12855
12856 if (catalyst_check == 1)
12857 {
12858 catalyst_warn = 1;
12859
12860 // v14.9 and higher
12861 if (atoi (device_param->driver_version) >= 1573)
12862 {
12863 catalyst_warn = 0;
12864 }
12865
12866 catalyst_check = 0;
12867 }
12868
12869 if (catalyst_broken == 1)
12870 {
12871 log_info ("");
12872 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12873 log_info ("It will pass over cracked hashes and does not report them as cracked");
12874 log_info ("You are STRONGLY encouraged not to use it");
12875 log_info ("You can use --force to override this but do not post error reports if you do so");
12876 log_info ("");
12877
12878 return (-1);
12879 }
12880
12881 if (catalyst_warn == 1)
12882 {
12883 log_info ("");
12884 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12885 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12886 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12887 #ifdef _WIN
12888 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12889 #endif
12890 log_info ("You can use --force to override this but do not post error reports if you do so");
12891 log_info ("");
12892
12893 return (-1);
12894 }
12895 }
12896 }
12897
12898 devices_active++;
12899 }
12900
12901 // next please
12902
12903 devices_cnt++;
12904 }
12905 }
12906
12907 if (keyspace == 0 && devices_active == 0)
12908 {
12909 log_error ("ERROR: No devices found/left");
12910
12911 return (-1);
12912 }
12913
12914 data.devices_cnt = devices_cnt;
12915
12916 data.devices_active = devices_active;
12917
12918 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12919 {
12920 log_info ("");
12921 }
12922
12923 /**
12924 * OpenCL devices: allocate buffer for device specific information
12925 */
12926
12927 #ifdef HAVE_HWMON
12928 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12929
12930 #ifdef HAVE_ADL
12931 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12932
12933 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12934 #endif // ADL
12935 #endif
12936
12937 /**
12938 * enable custom signal handler(s)
12939 */
12940
12941 if (benchmark == 0)
12942 {
12943 hc_signal (sigHandler_default);
12944 }
12945 else
12946 {
12947 hc_signal (sigHandler_benchmark);
12948 }
12949
12950 /**
12951 * User-defined GPU temp handling
12952 */
12953
12954 #ifdef HAVE_HWMON
12955 if (gpu_temp_disable == 1)
12956 {
12957 gpu_temp_abort = 0;
12958 gpu_temp_retain = 0;
12959 }
12960
12961 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12962 {
12963 if (gpu_temp_abort < gpu_temp_retain)
12964 {
12965 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12966
12967 return (-1);
12968 }
12969 }
12970
12971 data.gpu_temp_disable = gpu_temp_disable;
12972 data.gpu_temp_abort = gpu_temp_abort;
12973 data.gpu_temp_retain = gpu_temp_retain;
12974 #endif
12975
12976 /**
12977 * inform the user
12978 */
12979
12980 if (data.quiet == 0)
12981 {
12982 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12983
12984 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);
12985
12986 if (attack_mode == ATTACK_MODE_STRAIGHT)
12987 {
12988 log_info ("Rules: %u", kernel_rules_cnt);
12989 }
12990
12991 if (opti_type)
12992 {
12993 log_info ("Applicable Optimizers:");
12994
12995 for (uint i = 0; i < 32; i++)
12996 {
12997 const uint opti_bit = 1u << i;
12998
12999 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13000 }
13001 }
13002
13003 /**
13004 * Watchdog and Temperature balance
13005 */
13006
13007 #ifdef HAVE_HWMON
13008 if (gpu_temp_abort == 0)
13009 {
13010 log_info ("Watchdog: Temperature abort trigger disabled");
13011 }
13012 else
13013 {
13014 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13015 }
13016
13017 if (gpu_temp_retain == 0)
13018 {
13019 log_info ("Watchdog: Temperature retain trigger disabled");
13020 }
13021 else
13022 {
13023 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13024 }
13025 #endif
13026 }
13027
13028 if (data.quiet == 0) log_info ("");
13029
13030 /**
13031 * HM devices: init
13032 */
13033
13034 #ifdef HAVE_HWMON
13035 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13036 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13037 #endif
13038
13039 #ifdef HAVE_ADL
13040 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13041 #endif
13042
13043 if (gpu_temp_disable == 0)
13044 {
13045 #if defined(WIN) && defined(HAVE_NVAPI)
13046 if (NvAPI_Initialize () == NVAPI_OK)
13047 {
13048 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13049
13050 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13051
13052 int tmp_out = 0;
13053
13054 for (int i = 0; i < tmp_in; i++)
13055 {
13056 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13057 }
13058
13059 for (int i = 0; i < tmp_out; i++)
13060 {
13061 NvU32 speed;
13062
13063 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13064 }
13065 }
13066 #endif // WIN && HAVE_NVAPI
13067
13068 #if defined(LINUX) && defined(HAVE_NVML)
13069 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13070
13071 data.hm_dll_nv = hm_dll_nv;
13072
13073 if (hm_dll_nv)
13074 {
13075 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13076 {
13077 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13078
13079 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13080
13081 int tmp_out = 0;
13082
13083 for (int i = 0; i < tmp_in; i++)
13084 {
13085 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13086 }
13087
13088 for (int i = 0; i < tmp_out; i++)
13089 {
13090 unsigned int speed;
13091
13092 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13093 }
13094 }
13095 }
13096 #endif // LINUX && HAVE_NVML
13097
13098 #ifdef HAVE_ADL
13099 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13100
13101 data.hm_dll_amd = hm_dll_amd;
13102
13103 if (hm_dll_amd)
13104 {
13105 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13106 {
13107 // total number of adapters
13108
13109 int hm_adapters_num;
13110
13111 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13112
13113 // adapter info
13114
13115 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13116
13117 if (lpAdapterInfo == NULL) return (-1);
13118
13119 // get a list (of ids of) valid/usable adapters
13120
13121 int num_adl_adapters = 0;
13122
13123 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13124
13125 if (num_adl_adapters > 0)
13126 {
13127 hc_thread_mutex_lock (mux_adl);
13128
13129 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13130
13131 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13132
13133 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13134 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13135
13136 hc_thread_mutex_unlock (mux_adl);
13137 }
13138
13139 myfree (valid_adl_device_list);
13140 myfree (lpAdapterInfo);
13141 }
13142 }
13143 #endif // HAVE_ADL
13144 }
13145
13146 /**
13147 * HM devices: copy
13148 */
13149
13150 if (gpu_temp_disable == 0)
13151 {
13152 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13153 {
13154 hc_device_param_t *device_param = &data.devices_param[device_id];
13155
13156 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13157
13158 if (device_param->skipped) continue;
13159
13160 const uint platform_devices_id = device_param->platform_devices_id;
13161
13162 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13163 if (device_param->vendor_id == VENDOR_ID_NV)
13164 {
13165 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13166 }
13167 #endif
13168
13169 #ifdef HAVE_ADL
13170 if (device_param->vendor_id == VENDOR_ID_AMD)
13171 {
13172 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13173 }
13174 #endif
13175 }
13176 }
13177
13178 /*
13179 * Temporary fix:
13180 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13181 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13182 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13183 * Driver / ADL bug?
13184 */
13185
13186 #ifdef HAVE_ADL
13187 if (powertune_enable == 1)
13188 {
13189 hc_thread_mutex_lock (mux_adl);
13190
13191 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13192 {
13193 hc_device_param_t *device_param = &data.devices_param[device_id];
13194
13195 if (device_param->skipped) continue;
13196
13197 if (data.hm_device[device_id].od_version == 6)
13198 {
13199 // set powertune value only
13200
13201 int powertune_supported = 0;
13202
13203 int ADL_rc = 0;
13204
13205 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13206 {
13207 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13208
13209 return (-1);
13210 }
13211
13212 if (powertune_supported != 0)
13213 {
13214 // powertune set
13215 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13216
13217 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13218 {
13219 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13220
13221 return (-1);
13222 }
13223
13224 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13225 {
13226 log_error ("ERROR: Failed to set new ADL PowerControl values");
13227
13228 return (-1);
13229 }
13230 }
13231 }
13232 }
13233
13234 hc_thread_mutex_unlock (mux_adl);
13235 }
13236 #endif // HAVE_ADK
13237 #endif // HAVE_HWMON
13238
13239 #ifdef OSX
13240 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13241 {
13242 if (force == 0)
13243 {
13244 log_info ("");
13245 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13246 log_info ("You can use --force to override this but do not post error reports if you do so");
13247 log_info ("");
13248
13249 continue;
13250 }
13251 }
13252 #endif
13253
13254 #ifdef DEBUG
13255 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13256 #endif
13257
13258 uint kernel_blocks_all = 0;
13259
13260 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13261 {
13262 /**
13263 * host buffer
13264 */
13265
13266 hc_device_param_t *device_param = &data.devices_param[device_id];
13267
13268 if (device_param->skipped) continue;
13269
13270 /**
13271 * device properties
13272 */
13273
13274 char *device_name_chksum = device_param->device_name_chksum;
13275
13276 uint device_processors = device_param->device_processors;
13277
13278 uint device_processor_cores = device_param->device_processor_cores;
13279
13280 cl_device_type device_type = device_param->device_type;
13281
13282 /**
13283 * create context for each device
13284 */
13285
13286 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13287
13288 /**
13289 * create command-queue
13290 */
13291
13292 // not supported with NV
13293 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13294
13295 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13296
13297 /**
13298 * create input buffers on device
13299 */
13300
13301 uint kernel_threads = KERNEL_THREADS;
13302
13303 // bcrypt
13304 if (hash_mode == 3200) kernel_threads = 8;
13305 if (hash_mode == 9000) kernel_threads = 8;
13306
13307 if (device_type & CL_DEVICE_TYPE_CPU)
13308 {
13309 if (benchmark_mode == 0)
13310 {
13311 if (kernel_accel > 16)
13312 {
13313 kernel_accel = 16;
13314 }
13315 }
13316 else
13317 {
13318 if (kernel_accel > 64)
13319 {
13320 kernel_accel = 64;
13321 }
13322 }
13323 }
13324
13325 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13326 uint kernel_blocks = kernel_power;
13327
13328 device_param->kernel_threads = kernel_threads;
13329 device_param->kernel_power_user = kernel_power;
13330 device_param->kernel_blocks_user = kernel_blocks;
13331
13332 kernel_blocks_all += kernel_blocks;
13333
13334 uint size_pws = kernel_power * sizeof (pw_t);
13335
13336 uint size_tmps = 4;
13337
13338 switch (hash_mode)
13339 {
13340 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13341 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13342 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13343 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13344 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13345 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13346 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13347 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13348 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13349 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13350 case 6211:
13351 case 6212:
13352 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13353 case 6221:
13354 case 6222:
13355 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13356 case 6231:
13357 case 6232:
13358 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13359 case 6241:
13360 case 6242:
13361 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13362 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13363 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13364 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13365 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13366 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13367 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13368 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13369 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13370 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13371 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13372 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13373 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13374 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13375 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13376 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13377 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13378 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13379 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13380 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13381 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13382 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13383 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13384 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13385 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13386 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13387 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13388 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13389 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13390 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13391 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13392 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13393 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13394 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13395 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13396 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13397 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13398 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13399 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13400 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13401 };
13402
13403 uint size_hooks = 4;
13404
13405 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13406 {
13407 // insert correct hook size
13408 }
13409
13410 // we can optimize some stuff here...
13411
13412 device_param->size_pws = size_pws;
13413 device_param->size_tmps = size_tmps;
13414 device_param->size_hooks = size_hooks;
13415
13416 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13417 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13418
13419 device_param->size_root_css = size_root_css;
13420 device_param->size_markov_css = size_markov_css;
13421
13422 uint size_results = KERNEL_THREADS * sizeof (uint);
13423
13424 device_param->size_results = size_results;
13425
13426 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13427 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13428
13429 uint size_plains = digests_cnt * sizeof (plain_t);
13430 uint size_salts = salts_cnt * sizeof (salt_t);
13431 uint size_esalts = salts_cnt * esalt_size;
13432
13433 device_param->size_plains = size_plains;
13434 device_param->size_digests = size_digests;
13435 device_param->size_shown = size_shown;
13436 device_param->size_salts = size_salts;
13437
13438 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13439 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13440 uint size_tm = 32 * sizeof (bs_word_t);
13441
13442 u64 size_scryptV = 1;
13443
13444 if ((hash_mode == 8900) || (hash_mode == 9300))
13445 {
13446 uint tmto_start = 0;
13447 uint tmto_stop = 10;
13448
13449 if (scrypt_tmto)
13450 {
13451 tmto_start = scrypt_tmto;
13452 }
13453 else
13454 {
13455 // in case the user did not specify the tmto manually
13456 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13457 // but set the lower end only in case the user has a device with too less memory
13458
13459 if (hash_mode == 8900)
13460 {
13461 if (device_param->vendor_id == VENDOR_ID_AMD)
13462 {
13463 tmto_start = 1;
13464 }
13465 else if (device_param->vendor_id == VENDOR_ID_NV)
13466 {
13467 tmto_start = 3;
13468 }
13469 }
13470 else if (hash_mode == 9300)
13471 {
13472 if (device_param->vendor_id == VENDOR_ID_AMD)
13473 {
13474 tmto_start = 3;
13475 }
13476 else if (device_param->vendor_id == VENDOR_ID_NV)
13477 {
13478 tmto_start = 5;
13479 }
13480 }
13481 }
13482
13483 if (quiet == 0) log_info ("");
13484
13485 uint shader_per_mp = 1;
13486
13487 if (device_param->vendor_id == VENDOR_ID_AMD)
13488 {
13489 shader_per_mp = 8;
13490 }
13491 else if (device_param->vendor_id == VENDOR_ID_NV)
13492 {
13493 shader_per_mp = 32;
13494 }
13495
13496 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13497 {
13498 // TODO: in theory the following calculation needs to be done per salt, not global
13499 // we assume all hashes have the same scrypt settings
13500
13501 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13502
13503 size_scryptV /= 1 << tmto;
13504
13505 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13506
13507 if (size_scryptV > device_param->device_maxmem_alloc)
13508 {
13509 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13510
13511 continue;
13512 }
13513
13514 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13515 {
13516 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13517 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13518 }
13519
13520 break;
13521 }
13522
13523 if (data.salts_buf[0].scrypt_phy == 0)
13524 {
13525 log_error ("ERROR: can't allocate enough device memory");
13526
13527 return -1;
13528 }
13529
13530 if (quiet == 0) log_info ("");
13531 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13532 }
13533
13534 /**
13535 * default building options
13536 */
13537
13538 char build_opts[1024] = { 0 };
13539
13540 // we don't have sm_* on vendors not NV but it doesn't matter
13541
13542 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%d -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);
13543
13544 /**
13545 * main kernel
13546 */
13547
13548 {
13549 /**
13550 * kernel source filename
13551 */
13552
13553 char source_file[256] = { 0 };
13554
13555 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13556
13557 struct stat sst;
13558
13559 if (stat (source_file, &sst) == -1)
13560 {
13561 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13562
13563 return -1;
13564 }
13565
13566 /**
13567 * kernel cached filename
13568 */
13569
13570 char cached_file[256] = { 0 };
13571
13572 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13573
13574 int cached = 1;
13575
13576 struct stat cst;
13577
13578 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13579 {
13580 cached = 0;
13581 }
13582
13583 /**
13584 * kernel compile or load
13585 */
13586
13587 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13588
13589 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13590
13591 if (force_jit_compilation == -1)
13592 {
13593 if (cached == 0)
13594 {
13595 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13596
13597 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13598
13599 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13600
13601 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13602
13603 size_t binary_size;
13604
13605 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13606
13607 u8 *binary = (u8 *) mymalloc (binary_size);
13608
13609 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13610
13611 writeProgramBin (cached_file, binary, binary_size);
13612
13613 local_free (binary);
13614 }
13615 else
13616 {
13617 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13618
13619 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13620
13621 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13622
13623 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13624 }
13625 }
13626 else
13627 {
13628 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13629
13630 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13631
13632 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13633
13634 char build_opts_update[1024] = { 0 };
13635
13636 if (force_jit_compilation == 1500)
13637 {
13638 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13639 }
13640 else if (force_jit_compilation == 8900)
13641 {
13642 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);
13643 }
13644
13645 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
13646 }
13647
13648 local_free (kernel_lengths);
13649 local_free (kernel_sources[0]);
13650 local_free (kernel_sources);
13651 }
13652
13653 /**
13654 * word generator kernel
13655 */
13656
13657 if (attack_mode != ATTACK_MODE_STRAIGHT)
13658 {
13659 /**
13660 * kernel mp source filename
13661 */
13662
13663 char source_file[256] = { 0 };
13664
13665 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13666
13667 struct stat sst;
13668
13669 if (stat (source_file, &sst) == -1)
13670 {
13671 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13672
13673 return -1;
13674 }
13675
13676 /**
13677 * kernel mp cached filename
13678 */
13679
13680 char cached_file[256] = { 0 };
13681
13682 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13683
13684 int cached = 1;
13685
13686 struct stat cst;
13687
13688 if (stat (cached_file, &cst) == -1)
13689 {
13690 cached = 0;
13691 }
13692
13693 /**
13694 * kernel compile or load
13695 */
13696
13697 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13698
13699 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13700
13701 if (cached == 0)
13702 {
13703 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13704
13705 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13706
13707 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13708
13709 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13710
13711 size_t binary_size;
13712
13713 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13714
13715 u8 *binary = (u8 *) mymalloc (binary_size);
13716
13717 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13718
13719 writeProgramBin (cached_file, binary, binary_size);
13720
13721 local_free (binary);
13722 }
13723 else
13724 {
13725 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13726
13727 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13728
13729 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13730
13731 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13732 }
13733
13734 local_free (kernel_lengths);
13735 local_free (kernel_sources[0]);
13736 local_free (kernel_sources);
13737 }
13738
13739 /**
13740 * amplifier kernel
13741 */
13742
13743 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13744 {
13745
13746 }
13747 else
13748 {
13749 /**
13750 * kernel amp source filename
13751 */
13752
13753 char source_file[256] = { 0 };
13754
13755 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13756
13757 struct stat sst;
13758
13759 if (stat (source_file, &sst) == -1)
13760 {
13761 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13762
13763 return -1;
13764 }
13765
13766 /**
13767 * kernel amp cached filename
13768 */
13769
13770 char cached_file[256] = { 0 };
13771
13772 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13773
13774 int cached = 1;
13775
13776 struct stat cst;
13777
13778 if (stat (cached_file, &cst) == -1)
13779 {
13780 cached = 0;
13781 }
13782
13783 /**
13784 * kernel compile or load
13785 */
13786
13787 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13788
13789 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13790
13791 if (cached == 0)
13792 {
13793 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13794
13795 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13796
13797 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13798
13799 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13800
13801 size_t binary_size;
13802
13803 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13804
13805 u8 *binary = (u8 *) mymalloc (binary_size);
13806
13807 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13808
13809 writeProgramBin (cached_file, binary, binary_size);
13810
13811 local_free (binary);
13812 }
13813 else
13814 {
13815 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13816
13817 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13818
13819 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13820
13821 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13822 }
13823
13824 local_free (kernel_lengths);
13825 local_free (kernel_sources[0]);
13826 local_free (kernel_sources);
13827 }
13828
13829 /**
13830 * global buffers
13831 */
13832
13833 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13834 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13835 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13836 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13837 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13838 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13839 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13840 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13841 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13842 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13843 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13844 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13845 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13846 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13847 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13848 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13849 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13850 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13851
13852 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);
13853 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);
13854 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);
13855 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);
13856 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);
13857 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);
13858 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);
13859 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);
13860 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13861 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13862 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13863
13864 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13865 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13866 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13867 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13868 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13869 run_kernel_bzero (device_param, device_param->d_result, size_results);
13870
13871 /**
13872 * special buffers
13873 */
13874
13875 if (attack_kern == ATTACK_KERN_STRAIGHT)
13876 {
13877 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13878 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13879
13880 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13881
13882 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13883 }
13884 else if (attack_kern == ATTACK_KERN_COMBI)
13885 {
13886 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13887 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13888 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13889 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13890
13891 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13892 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13893 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13894 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13895 }
13896 else if (attack_kern == ATTACK_KERN_BF)
13897 {
13898 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13899 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13900 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13901 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13902 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13903
13904 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13905 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13906 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13907 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13908 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13909 }
13910
13911 if (size_esalts)
13912 {
13913 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13914
13915 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13916 }
13917
13918 /**
13919 * main host data
13920 */
13921
13922 uint *result = (uint *) mymalloc (size_results);
13923
13924 device_param->result = result;
13925
13926 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13927
13928 device_param->pws_buf = pws_buf;
13929
13930 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13931
13932 for (int i = 0; i < 64; i++)
13933 {
13934 pw_caches[i].pw_buf.pw_len = i;
13935 pw_caches[i].cnt = 0;
13936 }
13937
13938 device_param->pw_caches = pw_caches;
13939
13940 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13941
13942 device_param->combs_buf = combs_buf;
13943
13944 void *hooks_buf = mymalloc (size_hooks);
13945
13946 device_param->hooks_buf = hooks_buf;
13947
13948 device_param->pw_transpose = pw_transpose_to_hi1;
13949 device_param->pw_add = pw_add_to_hc1;
13950
13951 /**
13952 * kernel args
13953 */
13954
13955 device_param->kernel_params_buf32[21] = bitmap_mask;
13956 device_param->kernel_params_buf32[22] = bitmap_shift1;
13957 device_param->kernel_params_buf32[23] = bitmap_shift2;
13958 device_param->kernel_params_buf32[24] = 0; // salt_pos
13959 device_param->kernel_params_buf32[25] = 0; // loop_pos
13960 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13961 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13962 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13963 device_param->kernel_params_buf32[29] = 0; // digests_offset
13964 device_param->kernel_params_buf32[30] = 0; // combs_mode
13965 device_param->kernel_params_buf32[31] = 0; // gid_max
13966
13967 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13968 ? &device_param->d_pws_buf
13969 : &device_param->d_pws_amp_buf;
13970 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13971 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13972 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13973 device_param->kernel_params[ 4] = &device_param->d_tmps;
13974 device_param->kernel_params[ 5] = &device_param->d_hooks;
13975 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13976 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13977 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13978 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13979 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13980 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13981 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13982 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13983 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13984 device_param->kernel_params[15] = &device_param->d_digests_buf;
13985 device_param->kernel_params[16] = &device_param->d_digests_shown;
13986 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13987 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13988 device_param->kernel_params[19] = &device_param->d_result;
13989 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13990 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13991 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13992 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13993 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13994 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13995 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13996 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13997 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13998 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13999 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14000 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14001
14002 device_param->kernel_params_mp_buf64[3] = 0;
14003 device_param->kernel_params_mp_buf32[4] = 0;
14004 device_param->kernel_params_mp_buf32[5] = 0;
14005 device_param->kernel_params_mp_buf32[6] = 0;
14006 device_param->kernel_params_mp_buf32[7] = 0;
14007 device_param->kernel_params_mp_buf32[8] = 0;
14008
14009 device_param->kernel_params_mp[0] = NULL;
14010 device_param->kernel_params_mp[1] = NULL;
14011 device_param->kernel_params_mp[2] = NULL;
14012 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14013 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14014 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14015 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14016 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14017 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14018
14019 device_param->kernel_params_mp_l_buf64[3] = 0;
14020 device_param->kernel_params_mp_l_buf32[4] = 0;
14021 device_param->kernel_params_mp_l_buf32[5] = 0;
14022 device_param->kernel_params_mp_l_buf32[6] = 0;
14023 device_param->kernel_params_mp_l_buf32[7] = 0;
14024 device_param->kernel_params_mp_l_buf32[8] = 0;
14025 device_param->kernel_params_mp_l_buf32[9] = 0;
14026
14027 device_param->kernel_params_mp_l[0] = NULL;
14028 device_param->kernel_params_mp_l[1] = NULL;
14029 device_param->kernel_params_mp_l[2] = NULL;
14030 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14031 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14032 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14033 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14034 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14035 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14036 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14037
14038 device_param->kernel_params_mp_r_buf64[3] = 0;
14039 device_param->kernel_params_mp_r_buf32[4] = 0;
14040 device_param->kernel_params_mp_r_buf32[5] = 0;
14041 device_param->kernel_params_mp_r_buf32[6] = 0;
14042 device_param->kernel_params_mp_r_buf32[7] = 0;
14043 device_param->kernel_params_mp_r_buf32[8] = 0;
14044
14045 device_param->kernel_params_mp_r[0] = NULL;
14046 device_param->kernel_params_mp_r[1] = NULL;
14047 device_param->kernel_params_mp_r[2] = NULL;
14048 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14049 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14050 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14051 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14052 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14053 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14054
14055 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14056 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14057
14058 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14059 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14060 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14061 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14062 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14063 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14064 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14065
14066 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14067
14068 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14069 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14070
14071 /**
14072 * kernel name
14073 */
14074
14075 char kernel_name[64] = { 0 };
14076
14077 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14078 {
14079 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14080 {
14081 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14082
14083 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14084
14085 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14086
14087 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14088
14089 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14090
14091 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14092 }
14093 else
14094 {
14095 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14096
14097 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14098
14099 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14100
14101 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14102
14103 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14104
14105 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14106 }
14107
14108 if (data.attack_mode == ATTACK_MODE_BF)
14109 {
14110 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14111 {
14112 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14113
14114 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14115
14116 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14117
14118 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14119 }
14120 }
14121 }
14122 else
14123 {
14124 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14125
14126 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14127
14128 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14129
14130 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14131
14132 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14133
14134 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14135
14136 if (opts_type & OPTS_TYPE_HOOK12)
14137 {
14138 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14139
14140 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14141 }
14142
14143 if (opts_type & OPTS_TYPE_HOOK23)
14144 {
14145 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14146
14147 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14148 }
14149 }
14150
14151 for (uint i = 0; i <= 20; i++)
14152 {
14153 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14154 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14155 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14156
14157 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14158 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14159 }
14160
14161 for (uint i = 21; i <= 31; i++)
14162 {
14163 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14164 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14165 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14166
14167 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14168 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14169 }
14170
14171 if (attack_mode == ATTACK_MODE_BF)
14172 {
14173 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14174 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14175
14176 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14177 {
14178 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14179
14180 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14181 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14182 }
14183 }
14184 else if (attack_mode == ATTACK_MODE_HYBRID1)
14185 {
14186 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14187 }
14188 else if (attack_mode == ATTACK_MODE_HYBRID2)
14189 {
14190 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14191 }
14192
14193 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14194 {
14195 // nothing to do
14196 }
14197 else
14198 {
14199 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14200 }
14201
14202 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14203 {
14204 // nothing to do
14205 }
14206 else
14207 {
14208 for (uint i = 0; i < 5; i++)
14209 {
14210 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14211 }
14212
14213 for (uint i = 5; i < 7; i++)
14214 {
14215 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14216 }
14217 }
14218
14219 /**
14220 * Store initial fanspeed if gpu_temp_retain is enabled
14221 */
14222
14223 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14224 int gpu_temp_retain_set = 0;
14225
14226 if (gpu_temp_disable == 0)
14227 {
14228 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14229 {
14230 hc_thread_mutex_lock (mux_adl);
14231
14232 if (data.hm_device[device_id].fan_supported == 1)
14233 {
14234 if (gpu_temp_retain_chgd == 0)
14235 {
14236 uint cur_temp = 0;
14237 uint default_temp = 0;
14238
14239 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14240
14241 if (ADL_rc == ADL_OK)
14242 {
14243 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14244
14245 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14246
14247 // special case with multi gpu setups: always use minimum retain
14248
14249 if (gpu_temp_retain_set == 0)
14250 {
14251 gpu_temp_retain = gpu_temp_retain_target;
14252 gpu_temp_retain_set = 1;
14253 }
14254 else
14255 {
14256 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14257 }
14258
14259 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14260 }
14261 }
14262
14263 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14264
14265 temp_retain_fanspeed_value[device_id] = fan_speed;
14266
14267 if (fan_speed == -1)
14268 {
14269 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14270
14271 temp_retain_fanspeed_value[device_id] = 0;
14272 }
14273 }
14274
14275 hc_thread_mutex_unlock (mux_adl);
14276 }
14277 }
14278
14279 /**
14280 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14281 */
14282
14283 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14284 {
14285 hc_thread_mutex_lock (mux_adl);
14286
14287 if (data.hm_device[device_id].od_version == 6)
14288 {
14289 int ADL_rc;
14290
14291 // check powertune capabilities first, if not available then skip device
14292
14293 int powertune_supported = 0;
14294
14295 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14296 {
14297 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14298
14299 return (-1);
14300 }
14301
14302 if (powertune_supported != 0)
14303 {
14304 // powercontrol settings
14305
14306 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14307
14308 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14309 {
14310 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14311 }
14312
14313 if (ADL_rc != ADL_OK)
14314 {
14315 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14316
14317 return (-1);
14318 }
14319
14320 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14321 {
14322 log_error ("ERROR: Failed to set new ADL PowerControl values");
14323
14324 return (-1);
14325 }
14326
14327 // clocks
14328
14329 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14330
14331 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14332
14333 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14334 {
14335 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14336
14337 return (-1);
14338 }
14339
14340 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14341
14342 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14343
14344 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14345 {
14346 log_error ("ERROR: Failed to get ADL device capabilities");
14347
14348 return (-1);
14349 }
14350
14351 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14352 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14353
14354 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14355 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14356
14357 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14358 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14359
14360 // warning if profile has too low max values
14361
14362 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14363 {
14364 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14365 }
14366
14367 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14368 {
14369 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14370 }
14371
14372 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14373
14374 performance_state->iNumberOfPerformanceLevels = 2;
14375
14376 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14377 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14378 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14379 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14380
14381 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14382 {
14383 log_info ("ERROR: Failed to set ADL performance state");
14384
14385 return (-1);
14386 }
14387
14388 local_free (performance_state);
14389 }
14390 }
14391
14392 hc_thread_mutex_unlock (mux_adl);
14393 }
14394 #endif // HAVE_HWMON && HAVE_ADL
14395 }
14396
14397 data.kernel_blocks_all = kernel_blocks_all;
14398
14399 if (data.quiet == 0) log_info ("");
14400
14401 /**
14402 * Inform user which algorithm is checked and at which workload setting
14403 */
14404
14405 if (benchmark == 1)
14406 {
14407 quiet = 0;
14408
14409 data.quiet = quiet;
14410
14411 char *hash_type = strhashtype (data.hash_mode); // not a bug
14412
14413 log_info ("Hashtype: %s", hash_type);
14414 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14415 log_info ("");
14416 }
14417
14418 /**
14419 * keep track of the progress
14420 */
14421
14422 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14423 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14424 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14425
14426 /**
14427 * open filehandles
14428 */
14429
14430 #if _WIN
14431 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14432 {
14433 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14434
14435 return (-1);
14436 }
14437
14438 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14439 {
14440 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14441
14442 return (-1);
14443 }
14444
14445 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14446 {
14447 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14448
14449 return (-1);
14450 }
14451 #endif
14452
14453 /**
14454 * dictionary pad
14455 */
14456
14457 segment_size *= (1024 * 1024);
14458
14459 data.segment_size = segment_size;
14460
14461 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14462
14463 wl_data->buf = (char *) mymalloc (segment_size);
14464 wl_data->avail = segment_size;
14465 wl_data->incr = segment_size;
14466 wl_data->cnt = 0;
14467 wl_data->pos = 0;
14468
14469 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14470
14471 data.wordlist_mode = wordlist_mode;
14472
14473 cs_t *css_buf = NULL;
14474 uint css_cnt = 0;
14475 uint dictcnt = 0;
14476 uint maskcnt = 1;
14477 char **masks = NULL;
14478 char **dictfiles = NULL;
14479
14480 uint mask_from_file = 0;
14481
14482 if (attack_mode == ATTACK_MODE_STRAIGHT)
14483 {
14484 if (wordlist_mode == WL_MODE_FILE)
14485 {
14486 int wls_left = myargc - (optind + 1);
14487
14488 for (int i = 0; i < wls_left; i++)
14489 {
14490 char *l0_filename = myargv[optind + 1 + i];
14491
14492 struct stat l0_stat;
14493
14494 if (stat (l0_filename, &l0_stat) == -1)
14495 {
14496 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14497
14498 return (-1);
14499 }
14500
14501 uint is_dir = S_ISDIR (l0_stat.st_mode);
14502
14503 if (is_dir == 0)
14504 {
14505 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14506
14507 dictcnt++;
14508
14509 dictfiles[dictcnt - 1] = l0_filename;
14510 }
14511 else
14512 {
14513 // do not allow --keyspace w/ a directory
14514
14515 if (keyspace == 1)
14516 {
14517 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14518
14519 return (-1);
14520 }
14521
14522 char **dictionary_files = NULL;
14523
14524 dictionary_files = scan_directory (l0_filename);
14525
14526 if (dictionary_files != NULL)
14527 {
14528 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14529
14530 for (int d = 0; dictionary_files[d] != NULL; d++)
14531 {
14532 char *l1_filename = dictionary_files[d];
14533
14534 struct stat l1_stat;
14535
14536 if (stat (l1_filename, &l1_stat) == -1)
14537 {
14538 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14539
14540 return (-1);
14541 }
14542
14543 if (S_ISREG (l1_stat.st_mode))
14544 {
14545 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14546
14547 dictcnt++;
14548
14549 dictfiles[dictcnt - 1] = strdup (l1_filename);
14550 }
14551 }
14552 }
14553
14554 local_free (dictionary_files);
14555 }
14556 }
14557
14558 if (dictcnt < 1)
14559 {
14560 log_error ("ERROR: No usable dictionary file found.");
14561
14562 return (-1);
14563 }
14564 }
14565 else if (wordlist_mode == WL_MODE_STDIN)
14566 {
14567 dictcnt = 1;
14568 }
14569 }
14570 else if (attack_mode == ATTACK_MODE_COMBI)
14571 {
14572 // display
14573
14574 char *dictfile1 = myargv[optind + 1 + 0];
14575 char *dictfile2 = myargv[optind + 1 + 1];
14576
14577 // find the bigger dictionary and use as base
14578
14579 FILE *fp1 = NULL;
14580 FILE *fp2 = NULL;
14581
14582 struct stat tmp_stat;
14583
14584 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14585 {
14586 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14587
14588 return (-1);
14589 }
14590
14591 if (stat (dictfile1, &tmp_stat) == -1)
14592 {
14593 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14594
14595 fclose (fp1);
14596
14597 return (-1);
14598 }
14599
14600 if (S_ISDIR (tmp_stat.st_mode))
14601 {
14602 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14603
14604 fclose (fp1);
14605
14606 return (-1);
14607 }
14608
14609 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14610 {
14611 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14612
14613 fclose (fp1);
14614
14615 return (-1);
14616 }
14617
14618 if (stat (dictfile2, &tmp_stat) == -1)
14619 {
14620 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14621
14622 fclose (fp1);
14623 fclose (fp2);
14624
14625 return (-1);
14626 }
14627
14628 if (S_ISDIR (tmp_stat.st_mode))
14629 {
14630 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14631
14632 fclose (fp1);
14633 fclose (fp2);
14634
14635 return (-1);
14636 }
14637
14638 data.combs_cnt = 1;
14639
14640 data.quiet = 1;
14641
14642 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14643
14644 data.quiet = quiet;
14645
14646 if (words1_cnt == 0)
14647 {
14648 log_error ("ERROR: %s: empty file", dictfile1);
14649
14650 fclose (fp1);
14651 fclose (fp2);
14652
14653 return (-1);
14654 }
14655
14656 data.combs_cnt = 1;
14657
14658 data.quiet = 1;
14659
14660 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14661
14662 data.quiet = quiet;
14663
14664 if (words2_cnt == 0)
14665 {
14666 log_error ("ERROR: %s: empty file", dictfile2);
14667
14668 fclose (fp1);
14669 fclose (fp2);
14670
14671 return (-1);
14672 }
14673
14674 fclose (fp1);
14675 fclose (fp2);
14676
14677 data.dictfile = dictfile1;
14678 data.dictfile2 = dictfile2;
14679
14680 if (words1_cnt >= words2_cnt)
14681 {
14682 data.combs_cnt = words2_cnt;
14683 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14684
14685 dictfiles = &data.dictfile;
14686
14687 dictcnt = 1;
14688 }
14689 else
14690 {
14691 data.combs_cnt = words1_cnt;
14692 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14693
14694 dictfiles = &data.dictfile2;
14695
14696 dictcnt = 1;
14697
14698 // we also have to switch wordlist related rules!
14699
14700 char *tmpc = data.rule_buf_l;
14701
14702 data.rule_buf_l = data.rule_buf_r;
14703 data.rule_buf_r = tmpc;
14704
14705 int tmpi = data.rule_len_l;
14706
14707 data.rule_len_l = data.rule_len_r;
14708 data.rule_len_r = tmpi;
14709 }
14710 }
14711 else if (attack_mode == ATTACK_MODE_BF)
14712 {
14713 char *mask = NULL;
14714
14715 maskcnt = 0;
14716
14717 if (benchmark == 0)
14718 {
14719 mask = myargv[optind + 1];
14720
14721 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14722
14723 if ((optind + 2) <= myargc)
14724 {
14725 struct stat file_stat;
14726
14727 if (stat (mask, &file_stat) == -1)
14728 {
14729 maskcnt = 1;
14730
14731 masks[maskcnt - 1] = mystrdup (mask);
14732 }
14733 else
14734 {
14735 int wls_left = myargc - (optind + 1);
14736
14737 uint masks_avail = INCR_MASKS;
14738
14739 for (int i = 0; i < wls_left; i++)
14740 {
14741 if (i != 0)
14742 {
14743 mask = myargv[optind + 1 + i];
14744
14745 if (stat (mask, &file_stat) == -1)
14746 {
14747 log_error ("ERROR: %s: %s", mask, strerror (errno));
14748
14749 return (-1);
14750 }
14751 }
14752
14753 uint is_file = S_ISREG (file_stat.st_mode);
14754
14755 if (is_file == 1)
14756 {
14757 FILE *mask_fp;
14758
14759 if ((mask_fp = fopen (mask, "r")) == NULL)
14760 {
14761 log_error ("ERROR: %s: %s", mask, strerror (errno));
14762
14763 return (-1);
14764 }
14765
14766 char line_buf[BUFSIZ] = { 0 };
14767
14768 while (!feof (mask_fp))
14769 {
14770 memset (line_buf, 0, BUFSIZ);
14771
14772 int line_len = fgetl (mask_fp, line_buf);
14773
14774 if (line_len == 0) continue;
14775
14776 if (line_buf[0] == '#') continue;
14777
14778 if (masks_avail == maskcnt)
14779 {
14780 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14781
14782 masks_avail += INCR_MASKS;
14783 }
14784
14785 masks[maskcnt] = mystrdup (line_buf);
14786
14787 maskcnt++;
14788 }
14789
14790 fclose (mask_fp);
14791 }
14792 else
14793 {
14794 log_error ("ERROR: %s: unsupported file-type", mask);
14795
14796 return (-1);
14797 }
14798 }
14799
14800 mask_from_file = 1;
14801 }
14802 }
14803 else
14804 {
14805 custom_charset_1 = (char *) "?l?d?u";
14806 custom_charset_2 = (char *) "?l?d";
14807 custom_charset_3 = (char *) "?l?d*!$@_";
14808
14809 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14810 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14811 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14812
14813 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14814
14815 wordlist_mode = WL_MODE_MASK;
14816
14817 data.wordlist_mode = wordlist_mode;
14818
14819 increment = 1;
14820
14821 maskcnt = 1;
14822 }
14823 }
14824 else
14825 {
14826 /**
14827 * generate full masks and charsets
14828 */
14829
14830 masks = (char **) mymalloc (sizeof (char *));
14831
14832 switch (hash_mode)
14833 {
14834 case 1731: pw_min = 5;
14835 pw_max = 5;
14836 mask = mystrdup ("?b?b?b?b?b");
14837 break;
14838 case 12500: pw_min = 5;
14839 pw_max = 5;
14840 mask = mystrdup ("?b?b?b?b?b");
14841 break;
14842 default: pw_min = 7;
14843 pw_max = 7;
14844 mask = mystrdup ("?b?b?b?b?b?b?b");
14845 break;
14846 }
14847
14848 maskcnt = 1;
14849
14850 masks[maskcnt - 1] = mystrdup (mask);
14851
14852 wordlist_mode = WL_MODE_MASK;
14853
14854 data.wordlist_mode = wordlist_mode;
14855
14856 increment = 1;
14857 }
14858
14859 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14860
14861 if (increment)
14862 {
14863 if (increment_min > pw_min) pw_min = increment_min;
14864
14865 if (increment_max < pw_max) pw_max = increment_max;
14866 }
14867 }
14868 else if (attack_mode == ATTACK_MODE_HYBRID1)
14869 {
14870 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14871
14872 // display
14873
14874 char *mask = myargv[myargc - 1];
14875
14876 maskcnt = 0;
14877
14878 masks = (char **) mymalloc (1 * sizeof (char *));
14879
14880 // mod
14881
14882 struct stat file_stat;
14883
14884 if (stat (mask, &file_stat) == -1)
14885 {
14886 maskcnt = 1;
14887
14888 masks[maskcnt - 1] = mystrdup (mask);
14889 }
14890 else
14891 {
14892 uint is_file = S_ISREG (file_stat.st_mode);
14893
14894 if (is_file == 1)
14895 {
14896 FILE *mask_fp;
14897
14898 if ((mask_fp = fopen (mask, "r")) == NULL)
14899 {
14900 log_error ("ERROR: %s: %s", mask, strerror (errno));
14901
14902 return (-1);
14903 }
14904
14905 char line_buf[BUFSIZ] = { 0 };
14906
14907 uint masks_avail = 1;
14908
14909 while (!feof (mask_fp))
14910 {
14911 memset (line_buf, 0, BUFSIZ);
14912
14913 int line_len = fgetl (mask_fp, line_buf);
14914
14915 if (line_len == 0) continue;
14916
14917 if (line_buf[0] == '#') continue;
14918
14919 if (masks_avail == maskcnt)
14920 {
14921 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14922
14923 masks_avail += INCR_MASKS;
14924 }
14925
14926 masks[maskcnt] = mystrdup (line_buf);
14927
14928 maskcnt++;
14929 }
14930
14931 fclose (mask_fp);
14932
14933 mask_from_file = 1;
14934 }
14935 else
14936 {
14937 maskcnt = 1;
14938
14939 masks[maskcnt - 1] = mystrdup (mask);
14940 }
14941 }
14942
14943 // base
14944
14945 int wls_left = myargc - (optind + 2);
14946
14947 for (int i = 0; i < wls_left; i++)
14948 {
14949 char *filename = myargv[optind + 1 + i];
14950
14951 struct stat file_stat;
14952
14953 if (stat (filename, &file_stat) == -1)
14954 {
14955 log_error ("ERROR: %s: %s", filename, strerror (errno));
14956
14957 return (-1);
14958 }
14959
14960 uint is_dir = S_ISDIR (file_stat.st_mode);
14961
14962 if (is_dir == 0)
14963 {
14964 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14965
14966 dictcnt++;
14967
14968 dictfiles[dictcnt - 1] = filename;
14969 }
14970 else
14971 {
14972 // do not allow --keyspace w/ a directory
14973
14974 if (keyspace == 1)
14975 {
14976 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14977
14978 return (-1);
14979 }
14980
14981 char **dictionary_files = NULL;
14982
14983 dictionary_files = scan_directory (filename);
14984
14985 if (dictionary_files != NULL)
14986 {
14987 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14988
14989 for (int d = 0; dictionary_files[d] != NULL; d++)
14990 {
14991 char *l1_filename = dictionary_files[d];
14992
14993 struct stat l1_stat;
14994
14995 if (stat (l1_filename, &l1_stat) == -1)
14996 {
14997 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14998
14999 return (-1);
15000 }
15001
15002 if (S_ISREG (l1_stat.st_mode))
15003 {
15004 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15005
15006 dictcnt++;
15007
15008 dictfiles[dictcnt - 1] = strdup (l1_filename);
15009 }
15010 }
15011 }
15012
15013 local_free (dictionary_files);
15014 }
15015 }
15016
15017 if (dictcnt < 1)
15018 {
15019 log_error ("ERROR: No usable dictionary file found.");
15020
15021 return (-1);
15022 }
15023
15024 if (increment)
15025 {
15026 maskcnt = 0;
15027
15028 uint mask_min = increment_min; // we can't reject smaller masks here
15029 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15030
15031 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15032 {
15033 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15034
15035 if (cur_mask == NULL) break;
15036
15037 masks[maskcnt] = cur_mask;
15038
15039 maskcnt++;
15040
15041 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15042 }
15043 }
15044 }
15045 else if (attack_mode == ATTACK_MODE_HYBRID2)
15046 {
15047 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15048
15049 // display
15050
15051 char *mask = myargv[optind + 1 + 0];
15052
15053 maskcnt = 0;
15054
15055 masks = (char **) mymalloc (1 * sizeof (char *));
15056
15057 // mod
15058
15059 struct stat file_stat;
15060
15061 if (stat (mask, &file_stat) == -1)
15062 {
15063 maskcnt = 1;
15064
15065 masks[maskcnt - 1] = mystrdup (mask);
15066 }
15067 else
15068 {
15069 uint is_file = S_ISREG (file_stat.st_mode);
15070
15071 if (is_file == 1)
15072 {
15073 FILE *mask_fp;
15074
15075 if ((mask_fp = fopen (mask, "r")) == NULL)
15076 {
15077 log_error ("ERROR: %s: %s", mask, strerror (errno));
15078
15079 return (-1);
15080 }
15081
15082 char line_buf[BUFSIZ] = { 0 };
15083
15084 uint masks_avail = 1;
15085
15086 while (!feof (mask_fp))
15087 {
15088 memset (line_buf, 0, BUFSIZ);
15089
15090 int line_len = fgetl (mask_fp, line_buf);
15091
15092 if (line_len == 0) continue;
15093
15094 if (line_buf[0] == '#') continue;
15095
15096 if (masks_avail == maskcnt)
15097 {
15098 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15099
15100 masks_avail += INCR_MASKS;
15101 }
15102
15103 masks[maskcnt] = mystrdup (line_buf);
15104
15105 maskcnt++;
15106 }
15107
15108 fclose (mask_fp);
15109
15110 mask_from_file = 1;
15111 }
15112 else
15113 {
15114 maskcnt = 1;
15115
15116 masks[maskcnt - 1] = mystrdup (mask);
15117 }
15118 }
15119
15120 // base
15121
15122 int wls_left = myargc - (optind + 2);
15123
15124 for (int i = 0; i < wls_left; i++)
15125 {
15126 char *filename = myargv[optind + 2 + i];
15127
15128 struct stat file_stat;
15129
15130 if (stat (filename, &file_stat) == -1)
15131 {
15132 log_error ("ERROR: %s: %s", filename, strerror (errno));
15133
15134 return (-1);
15135 }
15136
15137 uint is_dir = S_ISDIR (file_stat.st_mode);
15138
15139 if (is_dir == 0)
15140 {
15141 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15142
15143 dictcnt++;
15144
15145 dictfiles[dictcnt - 1] = filename;
15146 }
15147 else
15148 {
15149 // do not allow --keyspace w/ a directory
15150
15151 if (keyspace == 1)
15152 {
15153 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15154
15155 return (-1);
15156 }
15157
15158 char **dictionary_files = NULL;
15159
15160 dictionary_files = scan_directory (filename);
15161
15162 if (dictionary_files != NULL)
15163 {
15164 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15165
15166 for (int d = 0; dictionary_files[d] != NULL; d++)
15167 {
15168 char *l1_filename = dictionary_files[d];
15169
15170 struct stat l1_stat;
15171
15172 if (stat (l1_filename, &l1_stat) == -1)
15173 {
15174 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15175
15176 return (-1);
15177 }
15178
15179 if (S_ISREG (l1_stat.st_mode))
15180 {
15181 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15182
15183 dictcnt++;
15184
15185 dictfiles[dictcnt - 1] = strdup (l1_filename);
15186 }
15187 }
15188 }
15189
15190 local_free (dictionary_files);
15191 }
15192 }
15193
15194 if (dictcnt < 1)
15195 {
15196 log_error ("ERROR: No usable dictionary file found.");
15197
15198 return (-1);
15199 }
15200
15201 if (increment)
15202 {
15203 maskcnt = 0;
15204
15205 uint mask_min = increment_min; // we can't reject smaller masks here
15206 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15207
15208 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15209 {
15210 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15211
15212 if (cur_mask == NULL) break;
15213
15214 masks[maskcnt] = cur_mask;
15215
15216 maskcnt++;
15217
15218 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15219 }
15220 }
15221 }
15222
15223 data.pw_min = pw_min;
15224 data.pw_max = pw_max;
15225
15226 /**
15227 * weak hash check
15228 */
15229
15230 if (weak_hash_threshold >= salts_cnt)
15231 {
15232 uint first_device_id = 0;
15233
15234 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15235 {
15236 hc_device_param_t *device_param = &data.devices_param[device_id];
15237
15238 if (device_param->skipped) continue;
15239
15240 first_device_id = device_id;
15241
15242 break;
15243 }
15244
15245 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15246
15247 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15248 {
15249 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15250 }
15251 }
15252
15253 // Display hack, guarantee that there is at least one \r before real start
15254
15255 if (data.quiet == 0) log_info_nn ("");
15256
15257 /**
15258 * status and monitor threads
15259 */
15260
15261 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15262
15263 hc_thread_t i_thread = 0;
15264
15265 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15266 {
15267 hc_thread_create (i_thread, thread_keypress, &benchmark);
15268 }
15269
15270 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15271
15272 uint ni_threads_cnt = 0;
15273
15274 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15275
15276 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15277
15278 ni_threads_cnt++;
15279
15280 /**
15281 * Outfile remove
15282 */
15283
15284 if (keyspace == 0)
15285 {
15286 if (outfile_check_timer != 0)
15287 {
15288 if (data.outfile_check_directory != NULL)
15289 {
15290 if ((hash_mode != 5200) &&
15291 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15292 (hash_mode != 9000))
15293 {
15294 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15295
15296 ni_threads_cnt++;
15297 }
15298 else
15299 {
15300 outfile_check_timer = 0;
15301 }
15302 }
15303 else
15304 {
15305 outfile_check_timer = 0;
15306 }
15307 }
15308 }
15309
15310 /**
15311 * Inform the user if we got some hashes remove because of the pot file remove feature
15312 */
15313
15314 if (data.quiet == 0)
15315 {
15316 if (potfile_remove_cracks > 0)
15317 {
15318 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15319 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15320 }
15321 }
15322
15323 data.outfile_check_timer = outfile_check_timer;
15324
15325 /**
15326 * main loop
15327 */
15328
15329 char **induction_dictionaries = NULL;
15330
15331 int induction_dictionaries_cnt = 0;
15332
15333 hcstat_table_t *root_table_buf = NULL;
15334 hcstat_table_t *markov_table_buf = NULL;
15335
15336 uint initial_restore_done = 0;
15337
15338 data.maskcnt = maskcnt;
15339
15340 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15341 {
15342 if (data.devices_status == STATUS_CRACKED) break;
15343
15344 data.devices_status = STATUS_INIT;
15345
15346 if (maskpos > rd->maskpos)
15347 {
15348 rd->dictpos = 0;
15349 }
15350
15351 rd->maskpos = maskpos;
15352 data.maskpos = maskpos;
15353
15354 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15355 {
15356 char *mask = masks[maskpos];
15357
15358 if (mask_from_file == 1)
15359 {
15360 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15361
15362 char *str_ptr;
15363 uint str_pos;
15364
15365 uint mask_offset = 0;
15366
15367 uint separator_cnt;
15368
15369 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15370 {
15371 str_ptr = strstr (mask + mask_offset, ",");
15372
15373 if (str_ptr == NULL) break;
15374
15375 str_pos = str_ptr - mask;
15376
15377 // escaped separator, i.e. "\,"
15378
15379 if (str_pos > 0)
15380 {
15381 if (mask[str_pos - 1] == '\\')
15382 {
15383 separator_cnt --;
15384
15385 mask_offset = str_pos + 1;
15386
15387 continue;
15388 }
15389 }
15390
15391 // reset the offset
15392
15393 mask_offset = 0;
15394
15395 mask[str_pos] = '\0';
15396
15397 switch (separator_cnt)
15398 {
15399 case 0:
15400 mp_reset_usr (mp_usr, 0);
15401
15402 custom_charset_1 = mask;
15403 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15404 break;
15405
15406 case 1:
15407 mp_reset_usr (mp_usr, 1);
15408
15409 custom_charset_2 = mask;
15410 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15411 break;
15412
15413 case 2:
15414 mp_reset_usr (mp_usr, 2);
15415
15416 custom_charset_3 = mask;
15417 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15418 break;
15419
15420 case 3:
15421 mp_reset_usr (mp_usr, 3);
15422
15423 custom_charset_4 = mask;
15424 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15425 break;
15426 }
15427
15428 mask = mask + str_pos + 1;
15429 }
15430 }
15431
15432 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15433 {
15434 if (maskpos > 0)
15435 {
15436 local_free (css_buf);
15437 local_free (data.root_css_buf);
15438 local_free (data.markov_css_buf);
15439
15440 local_free (masks[maskpos - 1]);
15441 }
15442
15443 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15444
15445 data.mask = mask;
15446 data.css_cnt = css_cnt;
15447 data.css_buf = css_buf;
15448
15449 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15450
15451 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15452
15453 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15454 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15455
15456 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15457
15458 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15459
15460 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15461 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15462
15463 data.root_css_buf = root_css_buf;
15464 data.markov_css_buf = markov_css_buf;
15465
15466 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15467
15468 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15469
15470 local_free (root_table_buf);
15471 local_free (markov_table_buf);
15472
15473 // args
15474
15475 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15476 {
15477 hc_device_param_t *device_param = &data.devices_param[device_id];
15478
15479 if (device_param->skipped) continue;
15480
15481 device_param->kernel_params_mp[0] = &device_param->d_combs;
15482 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15483 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15484
15485 device_param->kernel_params_mp_buf64[3] = 0;
15486 device_param->kernel_params_mp_buf32[4] = css_cnt;
15487 device_param->kernel_params_mp_buf32[5] = 0;
15488 device_param->kernel_params_mp_buf32[6] = 0;
15489 device_param->kernel_params_mp_buf32[7] = 0;
15490
15491 if (attack_mode == ATTACK_MODE_HYBRID1)
15492 {
15493 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15494 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15495 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15496 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15497 }
15498 else if (attack_mode == ATTACK_MODE_HYBRID2)
15499 {
15500 device_param->kernel_params_mp_buf32[5] = 0;
15501 device_param->kernel_params_mp_buf32[6] = 0;
15502 device_param->kernel_params_mp_buf32[7] = 0;
15503 }
15504
15505 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]);
15506 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]);
15507 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]);
15508
15509 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);
15510 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);
15511 }
15512 }
15513 else if (attack_mode == ATTACK_MODE_BF)
15514 {
15515 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15516
15517 if (increment)
15518 {
15519 for (uint i = 0; i < dictcnt; i++)
15520 {
15521 local_free (dictfiles[i]);
15522 }
15523
15524 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15525 {
15526 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15527
15528 if (l1_filename == NULL) break;
15529
15530 dictcnt++;
15531
15532 dictfiles[dictcnt - 1] = l1_filename;
15533 }
15534 }
15535 else
15536 {
15537 dictcnt++;
15538
15539 dictfiles[dictcnt - 1] = mask;
15540 }
15541
15542 if (dictcnt == 0)
15543 {
15544 log_error ("ERROR: Mask is too small");
15545
15546 return (-1);
15547 }
15548 }
15549 }
15550
15551 free (induction_dictionaries);
15552
15553 // induction_dictionaries_cnt = 0; // implied
15554
15555 if (attack_mode != ATTACK_MODE_BF)
15556 {
15557 if (keyspace == 0)
15558 {
15559 induction_dictionaries = scan_directory (induction_directory);
15560
15561 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15562 }
15563 }
15564
15565 if (induction_dictionaries_cnt)
15566 {
15567 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15568 }
15569
15570 /**
15571 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15572 */
15573 if (keyspace == 1)
15574 {
15575 if ((maskcnt > 1) || (dictcnt > 1))
15576 {
15577 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15578
15579 return (-1);
15580 }
15581 }
15582
15583 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15584 {
15585 char *subid = logfile_generate_subid ();
15586
15587 data.subid = subid;
15588
15589 logfile_sub_msg ("START");
15590
15591 data.devices_status = STATUS_INIT;
15592
15593 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15594 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15595 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15596
15597 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15598
15599 data.cpt_pos = 0;
15600
15601 data.cpt_start = time (NULL);
15602
15603 data.cpt_total = 0;
15604
15605 if (data.restore == 0)
15606 {
15607 rd->words_cur = skip;
15608
15609 skip = 0;
15610
15611 data.skip = 0;
15612 }
15613
15614 data.ms_paused = 0;
15615
15616 data.words_cur = rd->words_cur;
15617
15618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15619 {
15620 hc_device_param_t *device_param = &data.devices_param[device_id];
15621
15622 if (device_param->skipped) continue;
15623
15624 device_param->speed_pos = 0;
15625
15626 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15627 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15628 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15629
15630 device_param->kernel_power = device_param->kernel_power_user;
15631 device_param->kernel_blocks = device_param->kernel_blocks_user;
15632
15633 device_param->outerloop_pos = 0;
15634 device_param->outerloop_left = 0;
15635 device_param->innerloop_pos = 0;
15636 device_param->innerloop_left = 0;
15637
15638 // some more resets:
15639
15640 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15641
15642 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15643
15644 device_param->pw_cnt = 0;
15645 device_param->pws_cnt = 0;
15646
15647 device_param->words_off = 0;
15648 device_param->words_done = 0;
15649 }
15650
15651 data.kernel_blocks_div = 0;
15652
15653 // figure out some workload
15654
15655 if (attack_mode == ATTACK_MODE_STRAIGHT)
15656 {
15657 if (data.wordlist_mode == WL_MODE_FILE)
15658 {
15659 char *dictfile = NULL;
15660
15661 if (induction_dictionaries_cnt)
15662 {
15663 dictfile = induction_dictionaries[0];
15664 }
15665 else
15666 {
15667 dictfile = dictfiles[dictpos];
15668 }
15669
15670 data.dictfile = dictfile;
15671
15672 logfile_sub_string (dictfile);
15673
15674 for (uint i = 0; i < rp_files_cnt; i++)
15675 {
15676 logfile_sub_var_string ("rulefile", rp_files[i]);
15677 }
15678
15679 FILE *fd2 = fopen (dictfile, "rb");
15680
15681 if (fd2 == NULL)
15682 {
15683 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15684
15685 return (-1);
15686 }
15687
15688 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15689
15690 fclose (fd2);
15691
15692 if (data.words_cnt == 0)
15693 {
15694 if (data.devices_status == STATUS_CRACKED) break;
15695 if (data.devices_status == STATUS_ABORTED) break;
15696
15697 dictpos++;
15698
15699 continue;
15700 }
15701 }
15702 }
15703 else if (attack_mode == ATTACK_MODE_COMBI)
15704 {
15705 char *dictfile = data.dictfile;
15706 char *dictfile2 = data.dictfile2;
15707
15708 logfile_sub_string (dictfile);
15709 logfile_sub_string (dictfile2);
15710
15711 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15712 {
15713 FILE *fd2 = fopen (dictfile, "rb");
15714
15715 if (fd2 == NULL)
15716 {
15717 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15718
15719 return (-1);
15720 }
15721
15722 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15723
15724 fclose (fd2);
15725 }
15726 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15727 {
15728 FILE *fd2 = fopen (dictfile2, "rb");
15729
15730 if (fd2 == NULL)
15731 {
15732 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15733
15734 return (-1);
15735 }
15736
15737 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15738
15739 fclose (fd2);
15740 }
15741
15742 if (data.words_cnt == 0)
15743 {
15744 if (data.devices_status == STATUS_CRACKED) break;
15745 if (data.devices_status == STATUS_ABORTED) break;
15746
15747 dictpos++;
15748
15749 continue;
15750 }
15751 }
15752 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15753 {
15754 char *dictfile = NULL;
15755
15756 if (induction_dictionaries_cnt)
15757 {
15758 dictfile = induction_dictionaries[0];
15759 }
15760 else
15761 {
15762 dictfile = dictfiles[dictpos];
15763 }
15764
15765 data.dictfile = dictfile;
15766
15767 char *mask = data.mask;
15768
15769 logfile_sub_string (dictfile);
15770 logfile_sub_string (mask);
15771
15772 FILE *fd2 = fopen (dictfile, "rb");
15773
15774 if (fd2 == NULL)
15775 {
15776 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15777
15778 return (-1);
15779 }
15780
15781 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15782
15783 fclose (fd2);
15784
15785 if (data.words_cnt == 0)
15786 {
15787 if (data.devices_status == STATUS_CRACKED) break;
15788 if (data.devices_status == STATUS_ABORTED) break;
15789
15790 dictpos++;
15791
15792 continue;
15793 }
15794 }
15795 else if (attack_mode == ATTACK_MODE_BF)
15796 {
15797 local_free (css_buf);
15798 local_free (data.root_css_buf);
15799 local_free (data.markov_css_buf);
15800
15801 char *mask = dictfiles[dictpos];
15802
15803 logfile_sub_string (mask);
15804
15805 // base
15806
15807 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15808
15809 if (opts_type & OPTS_TYPE_PT_UNICODE)
15810 {
15811 uint css_cnt_unicode = css_cnt * 2;
15812
15813 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15814
15815 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15816 {
15817 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15818
15819 css_buf_unicode[j + 1].cs_buf[0] = 0;
15820 css_buf_unicode[j + 1].cs_len = 1;
15821 }
15822
15823 free (css_buf);
15824
15825 css_buf = css_buf_unicode;
15826 css_cnt = css_cnt_unicode;
15827 }
15828
15829 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15830
15831 uint mask_min = pw_min;
15832 uint mask_max = pw_max;
15833
15834 if (opts_type & OPTS_TYPE_PT_UNICODE)
15835 {
15836 mask_min *= 2;
15837 mask_max *= 2;
15838 }
15839
15840 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15841 {
15842 if (css_cnt < mask_min)
15843 {
15844 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15845 }
15846
15847 if (css_cnt > mask_max)
15848 {
15849 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15850 }
15851
15852 // skip to next mask
15853
15854 dictpos++;
15855
15856 rd->dictpos = dictpos;
15857
15858 logfile_sub_msg ("STOP");
15859
15860 continue;
15861 }
15862
15863 uint save_css_cnt = css_cnt;
15864
15865 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15866 {
15867 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15868 {
15869 uint salt_len = (uint) data.salts_buf[0].salt_len;
15870 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15871
15872 uint css_cnt_salt = css_cnt + salt_len;
15873
15874 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15875
15876 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15877
15878 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15879 {
15880 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15881 css_buf_salt[j].cs_len = 1;
15882 }
15883
15884 free (css_buf);
15885
15886 css_buf = css_buf_salt;
15887 css_cnt = css_cnt_salt;
15888 }
15889 }
15890
15891 data.mask = mask;
15892 data.css_cnt = css_cnt;
15893 data.css_buf = css_buf;
15894
15895 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15896
15897 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15898
15899 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15900
15901 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15902 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15903
15904 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15905
15906 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15907
15908 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15909 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15910
15911 data.root_css_buf = root_css_buf;
15912 data.markov_css_buf = markov_css_buf;
15913
15914 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15915
15916 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15917
15918 local_free (root_table_buf);
15919 local_free (markov_table_buf);
15920
15921 // copy + args
15922
15923 uint css_cnt_l = css_cnt;
15924 uint css_cnt_r;
15925
15926 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15927 {
15928 if (save_css_cnt < 6)
15929 {
15930 css_cnt_r = 1;
15931 }
15932 else if (save_css_cnt == 6)
15933 {
15934 css_cnt_r = 2;
15935 }
15936 else
15937 {
15938 if (opts_type & OPTS_TYPE_PT_UNICODE)
15939 {
15940 if (save_css_cnt == 8 || save_css_cnt == 10)
15941 {
15942 css_cnt_r = 2;
15943 }
15944 else
15945 {
15946 css_cnt_r = 4;
15947 }
15948 }
15949 else
15950 {
15951 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15952 {
15953 css_cnt_r = 3;
15954 }
15955 else
15956 {
15957 css_cnt_r = 4;
15958 }
15959 }
15960 }
15961 }
15962 else
15963 {
15964 css_cnt_r = 1;
15965
15966 /* unfinished code?
15967 int sum = css_buf[css_cnt_r - 1].cs_len;
15968
15969 for (uint i = 1; i < 4 && i < css_cnt; i++)
15970 {
15971 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15972
15973 css_cnt_r++;
15974
15975 sum *= css_buf[css_cnt_r - 1].cs_len;
15976 }
15977 */
15978 }
15979
15980 css_cnt_l -= css_cnt_r;
15981
15982 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15983
15984 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15985 {
15986 hc_device_param_t *device_param = &data.devices_param[device_id];
15987
15988 if (device_param->skipped) continue;
15989
15990 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15991 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15992 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15993
15994 device_param->kernel_params_mp_l_buf64[3] = 0;
15995 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15996 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15997 device_param->kernel_params_mp_l_buf32[6] = 0;
15998 device_param->kernel_params_mp_l_buf32[7] = 0;
15999 device_param->kernel_params_mp_l_buf32[8] = 0;
16000
16001 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16002 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16003 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16004 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16005
16006 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16007 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16008 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16009
16010 device_param->kernel_params_mp_r_buf64[3] = 0;
16011 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16012 device_param->kernel_params_mp_r_buf32[5] = 0;
16013 device_param->kernel_params_mp_r_buf32[6] = 0;
16014 device_param->kernel_params_mp_r_buf32[7] = 0;
16015
16016 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]);
16017 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]);
16018 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]);
16019
16020 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]);
16021 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]);
16022 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]);
16023
16024 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);
16025 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);
16026 }
16027 }
16028
16029 u64 words_base = data.words_cnt;
16030
16031 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16032 {
16033 if (data.kernel_rules_cnt)
16034 {
16035 words_base /= data.kernel_rules_cnt;
16036 }
16037 }
16038 else if (data.attack_kern == ATTACK_KERN_COMBI)
16039 {
16040 if (data.combs_cnt)
16041 {
16042 words_base /= data.combs_cnt;
16043 }
16044 }
16045 else if (data.attack_kern == ATTACK_KERN_BF)
16046 {
16047 if (data.bfs_cnt)
16048 {
16049 words_base /= data.bfs_cnt;
16050 }
16051 }
16052
16053 data.words_base = words_base;
16054
16055 if (keyspace == 1)
16056 {
16057 log_info ("%llu", (unsigned long long int) words_base);
16058
16059 return (0);
16060 }
16061
16062 if (data.words_cur > data.words_base)
16063 {
16064 log_error ("ERROR: restore value greater keyspace");
16065
16066 return (-1);
16067 }
16068
16069 if (data.words_cur)
16070 {
16071 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16072 {
16073 for (uint i = 0; i < data.salts_cnt; i++)
16074 {
16075 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16076 }
16077 }
16078 else if (data.attack_kern == ATTACK_KERN_COMBI)
16079 {
16080 for (uint i = 0; i < data.salts_cnt; i++)
16081 {
16082 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16083 }
16084 }
16085 else if (data.attack_kern == ATTACK_KERN_BF)
16086 {
16087 for (uint i = 0; i < data.salts_cnt; i++)
16088 {
16089 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16090 }
16091 }
16092 }
16093
16094 /*
16095 * Inform user about possible slow speeds
16096 */
16097
16098 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16099 {
16100 if (data.words_base < kernel_blocks_all)
16101 {
16102 if (quiet == 0)
16103 {
16104 log_info ("");
16105 log_info ("ATTENTION!");
16106 log_info (" The wordlist or mask you are using is too small.");
16107 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16108 log_info (" The cracking speed will drop.");
16109 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16110 log_info ("");
16111 }
16112 }
16113 }
16114
16115 /*
16116 * Update loopback file
16117 */
16118
16119 if (loopback == 1)
16120 {
16121 time_t now;
16122
16123 time (&now);
16124
16125 uint random_num = get_random_num (0, 9999);
16126
16127 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16128
16129 data.loopback_file = loopback_file;
16130 }
16131
16132 /*
16133 * Update dictionary statistic
16134 */
16135
16136 if (keyspace == 0)
16137 {
16138 dictstat_fp = fopen (dictstat, "wb");
16139
16140 if (dictstat_fp)
16141 {
16142 lock_file (dictstat_fp);
16143
16144 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16145
16146 fclose (dictstat_fp);
16147 }
16148 }
16149
16150 data.devices_status = STATUS_RUNNING;
16151
16152 if (initial_restore_done == 0)
16153 {
16154 if (data.restore_disable == 0) cycle_restore ();
16155
16156 initial_restore_done = 1;
16157 }
16158
16159 hc_timer_set (&data.timer_running);
16160
16161 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16162 {
16163 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16164 {
16165 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16166 if (quiet == 0) fflush (stdout);
16167 }
16168 }
16169 else if (wordlist_mode == WL_MODE_STDIN)
16170 {
16171 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16172 if (data.quiet == 0) log_info ("");
16173 }
16174
16175 time_t runtime_start;
16176
16177 time (&runtime_start);
16178
16179 data.runtime_start = runtime_start;
16180
16181 /**
16182 * create cracker threads
16183 */
16184
16185 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16186
16187 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16188 {
16189 hc_device_param_t *device_param = &devices_param[device_id];
16190
16191 if (wordlist_mode == WL_MODE_STDIN)
16192 {
16193 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16194 }
16195 else
16196 {
16197 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16198 }
16199 }
16200
16201 // wait for crack threads to exit
16202
16203 hc_thread_wait (devices_cnt, c_threads);
16204
16205 local_free (c_threads);
16206
16207 data.restore = 0;
16208
16209 // finalize task
16210
16211 logfile_sub_var_uint ("status-after-work", data.devices_status);
16212
16213 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16214
16215 if (data.devices_status == STATUS_CRACKED) break;
16216 if (data.devices_status == STATUS_ABORTED) break;
16217
16218 if (data.devices_status == STATUS_BYPASS)
16219 {
16220 data.devices_status = STATUS_RUNNING;
16221 }
16222
16223 if (induction_dictionaries_cnt)
16224 {
16225 unlink (induction_dictionaries[0]);
16226 }
16227
16228 free (induction_dictionaries);
16229
16230 if (attack_mode != ATTACK_MODE_BF)
16231 {
16232 induction_dictionaries = scan_directory (induction_directory);
16233
16234 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16235 }
16236
16237 if (benchmark == 0)
16238 {
16239 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16240 {
16241 if (quiet == 0) clear_prompt ();
16242
16243 if (quiet == 0) log_info ("");
16244
16245 if (status == 1)
16246 {
16247 status_display ();
16248 }
16249 else
16250 {
16251 if (quiet == 0) status_display ();
16252 }
16253
16254 if (quiet == 0) log_info ("");
16255 }
16256 }
16257
16258 if (attack_mode == ATTACK_MODE_BF)
16259 {
16260 dictpos++;
16261
16262 rd->dictpos = dictpos;
16263 }
16264 else
16265 {
16266 if (induction_dictionaries_cnt)
16267 {
16268 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16269 }
16270 else
16271 {
16272 dictpos++;
16273
16274 rd->dictpos = dictpos;
16275 }
16276 }
16277
16278 time_t runtime_stop;
16279
16280 time (&runtime_stop);
16281
16282 data.runtime_stop = runtime_stop;
16283
16284 logfile_sub_uint (runtime_start);
16285 logfile_sub_uint (runtime_stop);
16286
16287 logfile_sub_msg ("STOP");
16288
16289 global_free (subid);
16290 }
16291
16292 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16293
16294 if (data.devices_status == STATUS_CRACKED) break;
16295 if (data.devices_status == STATUS_ABORTED) break;
16296 if (data.devices_status == STATUS_QUIT) break;
16297
16298 if (data.devices_status == STATUS_BYPASS)
16299 {
16300 data.devices_status = STATUS_RUNNING;
16301 }
16302 }
16303
16304 // 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
16305
16306 if (attack_mode == ATTACK_MODE_STRAIGHT)
16307 {
16308 if (data.wordlist_mode == WL_MODE_FILE)
16309 {
16310 if (data.dictfile == NULL)
16311 {
16312 if (dictfiles != NULL)
16313 {
16314 data.dictfile = dictfiles[0];
16315
16316 hc_timer_set (&data.timer_running);
16317 }
16318 }
16319 }
16320 }
16321 // NOTE: combi is okay because it is already set beforehand
16322 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16323 {
16324 if (data.dictfile == NULL)
16325 {
16326 if (dictfiles != NULL)
16327 {
16328 hc_timer_set (&data.timer_running);
16329
16330 data.dictfile = dictfiles[0];
16331 }
16332 }
16333 }
16334 else if (attack_mode == ATTACK_MODE_BF)
16335 {
16336 if (data.mask == NULL)
16337 {
16338 hc_timer_set (&data.timer_running);
16339
16340 data.mask = masks[0];
16341 }
16342 }
16343
16344 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16345 {
16346 data.devices_status = STATUS_EXHAUSTED;
16347 }
16348
16349 // if cracked / aborted remove last induction dictionary
16350
16351 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16352 {
16353 struct stat induct_stat;
16354
16355 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16356 {
16357 unlink (induction_dictionaries[file_pos]);
16358 }
16359 }
16360
16361 // wait for non-interactive threads
16362
16363 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16364 {
16365 hc_thread_wait (1, &ni_threads[thread_idx]);
16366 }
16367
16368 local_free (ni_threads);
16369
16370 // wait for interactive threads
16371
16372 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16373 {
16374 hc_thread_wait (1, &i_thread);
16375 }
16376
16377 // we dont need restore file anymore
16378 if (data.restore_disable == 0)
16379 {
16380 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16381 {
16382 unlink (eff_restore_file);
16383 unlink (new_restore_file);
16384 }
16385 else
16386 {
16387 cycle_restore ();
16388 }
16389 }
16390
16391 // finally save left hashes
16392
16393 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16394 {
16395 save_hash ();
16396 }
16397
16398 /**
16399 * Clean up
16400 */
16401
16402 if (benchmark == 1)
16403 {
16404 status_benchmark ();
16405
16406 log_info ("");
16407 }
16408 else
16409 {
16410 if (quiet == 0) clear_prompt ();
16411
16412 if (quiet == 0) log_info ("");
16413
16414 if (status == 1)
16415 {
16416 status_display ();
16417 }
16418 else
16419 {
16420 if (quiet == 0) status_display ();
16421 }
16422
16423 if (quiet == 0) log_info ("");
16424 }
16425
16426 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16427 {
16428 hc_device_param_t *device_param = &data.devices_param[device_id];
16429
16430 if (device_param->skipped) continue;
16431
16432 local_free (device_param->result);
16433
16434 local_free (device_param->pw_caches);
16435
16436 local_free (device_param->combs_buf);
16437
16438 local_free (device_param->hooks_buf);
16439
16440 local_free (device_param->device_name);
16441
16442 local_free (device_param->device_name_chksum);
16443
16444 local_free (device_param->device_version);
16445
16446 local_free (device_param->driver_version);
16447
16448 if (device_param->pws_buf) myfree (device_param->pws_buf);
16449 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16450 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16451 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16452 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16453 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16454 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16455 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16456 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16457 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16458 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16459 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16460 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16461 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16462 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16463 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16464 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16465 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16466 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16467 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16468 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16469 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16470 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16471 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16472 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16473 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16474 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16475 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16476 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16477
16478 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16479 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16480 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16481 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16482 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16483 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16484 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16485 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16486 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16487 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16488 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16489
16490 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16491 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16492 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16493
16494 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16495 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16496 }
16497
16498 // reset default fan speed
16499
16500 #ifdef HAVE_HWMON
16501 if (gpu_temp_disable == 0)
16502 {
16503 #ifdef HAVE_ADL
16504 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16505 {
16506 hc_thread_mutex_lock (mux_adl);
16507
16508 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16509 {
16510 hc_device_param_t *device_param = &data.devices_param[device_id];
16511
16512 if (device_param->skipped) continue;
16513
16514 if (data.hm_device[device_id].fan_supported == 1)
16515 {
16516 int fanspeed = temp_retain_fanspeed_value[device_id];
16517
16518 if (fanspeed == -1) continue;
16519
16520 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16521
16522 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16523 }
16524 }
16525
16526 hc_thread_mutex_unlock (mux_adl);
16527 }
16528 #endif // HAVE_ADL
16529 }
16530
16531 // reset power tuning
16532
16533 #ifdef HAVE_ADL
16534 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16535 {
16536 hc_thread_mutex_lock (mux_adl);
16537
16538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16539 {
16540 hc_device_param_t *device_param = &data.devices_param[device_id];
16541
16542 if (device_param->skipped) continue;
16543
16544 if (data.hm_device[device_id].od_version == 6)
16545 {
16546 // check powertune capabilities first, if not available then skip device
16547
16548 int powertune_supported = 0;
16549
16550 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16551 {
16552 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16553
16554 return (-1);
16555 }
16556
16557 if (powertune_supported != 0)
16558 {
16559 // powercontrol settings
16560
16561 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16562 {
16563 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16564
16565 return (-1);
16566 }
16567
16568 // clocks
16569
16570 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16571
16572 performance_state->iNumberOfPerformanceLevels = 2;
16573
16574 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16575 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16576 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16577 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16578
16579 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16580 {
16581 log_info ("ERROR: Failed to restore ADL performance state");
16582
16583 return (-1);
16584 }
16585
16586 local_free (performance_state);
16587 }
16588 }
16589 }
16590
16591 hc_thread_mutex_unlock (mux_adl);
16592 }
16593 #endif // HAVE_ADL
16594
16595 if (gpu_temp_disable == 0)
16596 {
16597 #if defined(LINUX) && defined(HAVE_NVML)
16598 if (data.hm_dll_nv)
16599 {
16600 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16601
16602 hm_close (data.hm_dll_nv);
16603 }
16604 #endif
16605
16606 #if defined(WIN) && (HAVE_NVAPI)
16607 NvAPI_Unload ();
16608 #endif
16609
16610 #ifdef HAVE_ADL
16611 if (data.hm_dll_amd)
16612 {
16613 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16614
16615 hm_close (data.hm_dll_amd);
16616 }
16617 #endif
16618 }
16619 #endif // HAVE_HWMON
16620
16621 // free memory
16622
16623 local_free (masks);
16624
16625 local_free (dictstat_base);
16626
16627 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16628 {
16629 pot_t *pot_ptr = &pot[pot_pos];
16630
16631 hash_t *hash = &pot_ptr->hash;
16632
16633 local_free (hash->digest);
16634
16635 if (isSalted)
16636 {
16637 local_free (hash->salt);
16638 }
16639 }
16640
16641 local_free (pot);
16642
16643 local_free (all_kernel_rules_cnt);
16644 local_free (all_kernel_rules_buf);
16645
16646 local_free (wl_data->buf);
16647 local_free (wl_data);
16648
16649 local_free (bitmap_s1_a);
16650 local_free (bitmap_s1_b);
16651 local_free (bitmap_s1_c);
16652 local_free (bitmap_s1_d);
16653 local_free (bitmap_s2_a);
16654 local_free (bitmap_s2_b);
16655 local_free (bitmap_s2_c);
16656 local_free (bitmap_s2_d);
16657
16658 #ifdef HAVE_HWMON
16659 local_free (temp_retain_fanspeed_value);
16660 #ifdef HAVE_ADL
16661 local_free (od_clock_mem_status);
16662 local_free (od_power_control_status);
16663 #endif // ADL
16664 #endif
16665
16666 global_free (devices_param);
16667
16668 global_free (kernel_rules_buf);
16669
16670 global_free (root_css_buf);
16671 global_free (markov_css_buf);
16672
16673 global_free (digests_buf);
16674 global_free (digests_shown);
16675 global_free (digests_shown_tmp);
16676
16677 global_free (salts_buf);
16678 global_free (salts_shown);
16679
16680 global_free (esalts_buf);
16681
16682 global_free (words_progress_done);
16683 global_free (words_progress_rejected);
16684 global_free (words_progress_restored);
16685
16686 if (pot_fp) fclose (pot_fp);
16687
16688 if (data.devices_status == STATUS_QUIT) break;
16689 }
16690
16691 // destroy others mutex
16692
16693 hc_thread_mutex_delete (mux_dispatcher);
16694 hc_thread_mutex_delete (mux_counter);
16695 hc_thread_mutex_delete (mux_display);
16696 hc_thread_mutex_delete (mux_adl);
16697
16698 // free memory
16699
16700 local_free (eff_restore_file);
16701 local_free (new_restore_file);
16702
16703 local_free (rd);
16704
16705 // loopback
16706
16707 local_free (loopback_file);
16708
16709 if (loopback == 1) unlink (loopback_file);
16710
16711 // induction directory
16712
16713 if (induction_dir == NULL)
16714 {
16715 if (attack_mode != ATTACK_MODE_BF)
16716 {
16717 if (rmdir (induction_directory) == -1)
16718 {
16719 if (errno == ENOENT)
16720 {
16721 // good, we can ignore
16722 }
16723 else if (errno == ENOTEMPTY)
16724 {
16725 // good, we can ignore
16726 }
16727 else
16728 {
16729 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16730
16731 return (-1);
16732 }
16733 }
16734
16735 local_free (induction_directory);
16736 }
16737 }
16738
16739 // outfile-check directory
16740
16741 if (outfile_check_dir == NULL)
16742 {
16743 if (rmdir (outfile_check_directory) == -1)
16744 {
16745 if (errno == ENOENT)
16746 {
16747 // good, we can ignore
16748 }
16749 else if (errno == ENOTEMPTY)
16750 {
16751 // good, we can ignore
16752 }
16753 else
16754 {
16755 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16756
16757 return (-1);
16758 }
16759 }
16760
16761 local_free (outfile_check_directory);
16762 }
16763
16764 time_t proc_stop;
16765
16766 time (&proc_stop);
16767
16768 logfile_top_uint (proc_start);
16769 logfile_top_uint (proc_stop);
16770
16771 logfile_top_msg ("STOP");
16772
16773 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16774 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16775
16776 if (data.ocl) ocl_close (data.ocl);
16777
16778 if (data.devices_status == STATUS_ABORTED) return 2;
16779 if (data.devices_status == STATUS_QUIT) return 2;
16780 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16781 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16782 if (data.devices_status == STATUS_CRACKED) return 0;
16783
16784 return -1;
16785 }
Hashcat additions to support pwdhash