projects / hashcat.git / blob
? search:


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