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