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