projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
cleanup unnecessary clGetProgramBuildInfo code
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100, // broken in osx
166 6900, // broken in osx
167 11700, // broken in osx
168 11800, // broken in osx
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300, // broken in osx
178 5400, // broken in osx
179 5500, // broken in osx
180 5600, // broken in osx
181 7300,
182 7500, // broken in osx
183 8300,
184 11100, // broken in osx
185 11200,
186 11400, // broken in osx
187 121,
188 2611, // broken in osx
189 2711, // broken in osx
190 2811, // broken in osx
191 8400, // broken in osx
192 11,
193 2612, // broken in osx
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711, // broken in osx
200 7600, // broken in osx
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100, // broken in osx
208 112,
209 12300,
210 8000, // broken in osx
211 141,
212 1441,
213 1600,
214 12600, // broken in osx
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400, // broken in osx
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500, // broken in osx
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600, // broken in osx
253 8700, // broken in osx
254 9100, // broken in osx
255 133,
256 11600, // broken in osx
257 12500, // broken in osx
258 13000,
259 6211,
260 6221,
261 6231, // broken in osx
262 6241,
263 8800, // broken in osx
264 12900,
265 12200,
266 9700, // broken in osx
267 9710, // broken in osx
268 9800, // broken in osx
269 9810, // broken in osx
270 9400, // broken in osx
271 9500, // broken in osx
272 9600, // broken in osx
273 10400, // broken in osx
274 10410, // broken in osx
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800, // broken in osx
281 6600, // broken in osx
282 8200,
283 11300, // broken in osx
284 12700 // broken in osx
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 #ifndef OSX
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 #else
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
397 #endif
398 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
399 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
400 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
401 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
402 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
403 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
404 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 #ifdef HAVE_HWMON
407 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
408 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
409 #ifdef HAVE_ADL
410 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
411 #endif
412 #endif
413 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
414 "",
415 "* Distributed:",
416 "",
417 " -s, --skip=NUM Skip number of words",
418 " -l, --limit=NUM Limit number of words",
419 " --keyspace Show keyspace base:mod values and quit",
420 "",
421 "* Rules:",
422 "",
423 " -j, --rule-left=RULE Single rule applied to each word from left dict",
424 " -k, --rule-right=RULE Single rule applied to each word from right dict",
425 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
426 " -g, --generate-rules=NUM Generate NUM random rules",
427 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
428 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
429 " --generate-rules-seed=NUM Force RNG seed to NUM",
430 "",
431 "* Custom charsets:",
432 "",
433 " -1, --custom-charset1=CS User-defined charsets",
434 " -2, --custom-charset2=CS Example:",
435 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
436 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
437 "",
438 "* Increment:",
439 "",
440 " -i, --increment Enable increment mode",
441 " --increment-min=NUM Start incrementing at NUM",
442 " --increment-max=NUM Stop incrementing at NUM",
443 "",
444 "==========",
445 "References",
446 "==========",
447 "",
448 "* Workload Profile:",
449 "",
450 " 1 = Reduced performance profile (low latency desktop)",
451 " 2 = Default performance profile",
452 " 3 = Tuned performance profile (high latency desktop)",
453 "",
454 "* Benchmark Settings:",
455 "",
456 " 0 = Manual Tuning",
457 " 1 = Performance Tuning, default",
458 "",
459 "* OpenCL device-types:",
460 "",
461 " 1 = CPU devices",
462 " 2 = GPU devices",
463 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
464 "",
465 "* Outfile Formats:",
466 "",
467 " 1 = hash[:salt]",
468 " 2 = plain",
469 " 3 = hash[:salt]:plain",
470 " 4 = hex_plain",
471 " 5 = hash[:salt]:hex_plain",
472 " 6 = plain:hex_plain",
473 " 7 = hash[:salt]:plain:hex_plain",
474 " 8 = crackpos",
475 " 9 = hash[:salt]:crackpos",
476 " 10 = plain:crackpos",
477 " 11 = hash[:salt]:plain:crackpos",
478 " 12 = hex_plain:crackpos",
479 " 13 = hash[:salt]:hex_plain:crackpos",
480 " 14 = plain:hex_plain:crackpos",
481 " 15 = hash[:salt]:plain:hex_plain:crackpos",
482 "",
483 "* Debug mode output formats (for hybrid mode only, by using rules):",
484 "",
485 " 1 = save finding rule",
486 " 2 = save original word",
487 " 3 = save original word and finding rule",
488 " 4 = save original word, finding rule and modified plain",
489 "",
490 "* Built-in charsets:",
491 "",
492 " ?l = abcdefghijklmnopqrstuvwxyz",
493 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
494 " ?d = 0123456789",
495 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
496 " ?a = ?l?u?d?s",
497 " ?b = 0x00 - 0xff",
498 "",
499 "* Attack modes:",
500 "",
501 " 0 = Straight",
502 " 1 = Combination",
503 " 3 = Brute-force",
504 " 6 = Hybrid dict + mask",
505 " 7 = Hybrid mask + dict",
506 "",
507 "* Hash types:",
508 "",
509 "[[ Roll-your-own: Raw Hashes ]]",
510 "",
511 " 900 = MD4",
512 " 0 = MD5",
513 " 5100 = Half MD5",
514 " 100 = SHA1",
515 " 10800 = SHA-384",
516 " 1400 = SHA-256",
517 " 1700 = SHA-512",
518 " 5000 = SHA-3(Keccak)",
519 " 10100 = SipHash",
520 " 6000 = RipeMD160",
521 " 6100 = Whirlpool",
522 " 6900 = GOST R 34.11-94",
523 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
524 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
525 "",
526 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
527 "",
528 " 10 = md5($pass.$salt)",
529 " 20 = md5($salt.$pass)",
530 " 30 = md5(unicode($pass).$salt)",
531 " 40 = md5($salt.unicode($pass))",
532 " 3800 = md5($salt.$pass.$salt)",
533 " 3710 = md5($salt.md5($pass))",
534 " 2600 = md5(md5($pass)",
535 " 4300 = md5(strtoupper(md5($pass)))",
536 " 4400 = md5(sha1($pass))",
537 " 110 = sha1($pass.$salt)",
538 " 120 = sha1($salt.$pass)",
539 " 130 = sha1(unicode($pass).$salt)",
540 " 140 = sha1($salt.unicode($pass))",
541 " 4500 = sha1(sha1($pass)",
542 " 4700 = sha1(md5($pass))",
543 " 4900 = sha1($salt.$pass.$salt)",
544 " 1410 = sha256($pass.$salt)",
545 " 1420 = sha256($salt.$pass)",
546 " 1430 = sha256(unicode($pass).$salt)",
547 " 1440 = sha256($salt.unicode($pass))",
548 " 1710 = sha512($pass.$salt)",
549 " 1720 = sha512($salt.$pass)",
550 " 1730 = sha512(unicode($pass).$salt)",
551 " 1740 = sha512($salt.unicode($pass))",
552 "",
553 "[[ Roll-your-own: Authenticated Hashes ]]",
554 "",
555 " 50 = HMAC-MD5 (key = $pass)",
556 " 60 = HMAC-MD5 (key = $salt)",
557 " 150 = HMAC-SHA1 (key = $pass)",
558 " 160 = HMAC-SHA1 (key = $salt)",
559 " 1450 = HMAC-SHA256 (key = $pass)",
560 " 1460 = HMAC-SHA256 (key = $salt)",
561 " 1750 = HMAC-SHA512 (key = $pass)",
562 " 1760 = HMAC-SHA512 (key = $salt)",
563 "",
564 "[[ Generic KDF ]]",
565 "",
566 " 400 = phpass",
567 " 8900 = scrypt",
568 " 11900 = PBKDF2-HMAC-MD5",
569 " 12000 = PBKDF2-HMAC-SHA1",
570 " 10900 = PBKDF2-HMAC-SHA256",
571 " 12100 = PBKDF2-HMAC-SHA512",
572 "",
573 "[[ Network protocols, Challenge-Response ]]",
574 "",
575 " 23 = Skype",
576 " 2500 = WPA/WPA2",
577 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
578 " 5300 = IKE-PSK MD5",
579 " 5400 = IKE-PSK SHA1",
580 " 5500 = NetNTLMv1",
581 " 5500 = NetNTLMv1 + ESS",
582 " 5600 = NetNTLMv2",
583 " 7300 = IPMI2 RAKP HMAC-SHA1",
584 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
585 " 8300 = DNSSEC (NSEC3)",
586 " 10200 = Cram MD5",
587 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
588 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
589 " 11400 = SIP digest authentication (MD5)",
590 "",
591 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
592 "",
593 " 121 = SMF (Simple Machines Forum)",
594 " 400 = phpBB3",
595 " 2611 = vBulletin < v3.8.5",
596 " 2711 = vBulletin > v3.8.5",
597 " 2811 = MyBB",
598 " 2811 = IPB (Invison Power Board)",
599 " 8400 = WBB3 (Woltlab Burning Board)",
600 " 11 = Joomla < 2.5.18",
601 " 400 = Joomla > 2.5.18",
602 " 400 = Wordpress",
603 " 2612 = PHPS",
604 " 7900 = Drupal7",
605 " 21 = osCommerce",
606 " 21 = xt:Commerce",
607 " 11000 = PrestaShop",
608 " 124 = Django (SHA-1)",
609 " 10000 = Django (PBKDF2-SHA256)",
610 " 3711 = Mediawiki B type",
611 " 7600 = Redmine",
612 "",
613 "[[ Database Server ]]",
614 "",
615 " 12 = PostgreSQL",
616 " 131 = MSSQL(2000)",
617 " 132 = MSSQL(2005)",
618 " 1731 = MSSQL(2012)",
619 " 1731 = MSSQL(2014)",
620 " 200 = MySQL323",
621 " 300 = MySQL4.1/MySQL5",
622 " 3100 = Oracle H: Type (Oracle 7+)",
623 " 112 = Oracle S: Type (Oracle 11+)",
624 " 12300 = Oracle T: Type (Oracle 12+)",
625 " 8000 = Sybase ASE",
626 "",
627 "[[ HTTP, SMTP, LDAP Server ]]",
628 "",
629 " 141 = EPiServer 6.x < v4",
630 " 1441 = EPiServer 6.x > v4",
631 " 1600 = Apache $apr1$",
632 " 12600 = ColdFusion 10+",
633 " 1421 = hMailServer",
634 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
635 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
636 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
637 "",
638 "[[ Checksums ]]",
639 "",
640 " 11500 = CRC32",
641 "",
642 "[[ Operating-Systems ]]",
643 "",
644 " 3000 = LM",
645 " 1000 = NTLM",
646 " 1100 = Domain Cached Credentials (DCC), MS Cache",
647 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
648 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
649 " 1500 = descrypt, DES(Unix), Traditional DES",
650 " 12400 = BSDiCrypt, Extended DES",
651 " 500 = md5crypt $1$, MD5(Unix)",
652 " 3200 = bcrypt $2*$, Blowfish(Unix)",
653 " 7400 = sha256crypt $5$, SHA256(Unix)",
654 " 1800 = sha512crypt $6$, SHA512(Unix)",
655 " 122 = OSX v10.4",
656 " 122 = OSX v10.5",
657 " 122 = OSX v10.6",
658 " 1722 = OSX v10.7",
659 " 7100 = OSX v10.8",
660 " 7100 = OSX v10.9",
661 " 7100 = OSX v10.10",
662 " 6300 = AIX {smd5}",
663 " 6700 = AIX {ssha1}",
664 " 6400 = AIX {ssha256}",
665 " 6500 = AIX {ssha512}",
666 " 2400 = Cisco-PIX",
667 " 2410 = Cisco-ASA",
668 " 500 = Cisco-IOS $1$",
669 " 5700 = Cisco-IOS $4$",
670 " 9200 = Cisco-IOS $8$",
671 " 9300 = Cisco-IOS $9$",
672 " 22 = Juniper Netscreen/SSG (ScreenOS)",
673 " 501 = Juniper IVE",
674 " 5800 = Android PIN",
675 " 8100 = Citrix Netscaler",
676 " 8500 = RACF",
677 " 7200 = GRUB 2",
678 " 9900 = Radmin2",
679 "",
680 "[[ Enterprise Application Software (EAS) ]]",
681 "",
682 " 7700 = SAP CODVN B (BCODE)",
683 " 7800 = SAP CODVN F/G (PASSCODE)",
684 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
685 " 8600 = Lotus Notes/Domino 5",
686 " 8700 = Lotus Notes/Domino 6",
687 " 9100 = Lotus Notes/Domino 8",
688 " 133 = PeopleSoft",
689 "",
690 "[[ Archives ]]",
691 "",
692 " 11600 = 7-Zip",
693 " 12500 = RAR3-hp",
694 " 13000 = RAR5",
695 "",
696 "[[ Full-Disk encryptions (FDE) ]]",
697 "",
698 " 62XY = TrueCrypt 5.0+",
699 " X = 1 = PBKDF2-HMAC-RipeMD160",
700 " X = 2 = PBKDF2-HMAC-SHA512",
701 " X = 3 = PBKDF2-HMAC-Whirlpool",
702 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
703 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
704 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
705 " Y = 3 = XTS 1536 bit (Ciphers: All)",
706 " 8800 = Android FDE < v4.3",
707 " 12900 = Android FDE (Samsung DEK)",
708 " 12200 = eCryptfs",
709 "",
710 "[[ Documents ]]",
711 "",
712 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
713 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
714 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
715 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
716 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
717 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
718 " 9400 = MS Office 2007",
719 " 9500 = MS Office 2010",
720 " 9600 = MS Office 2013",
721 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
722 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
723 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
724 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
725 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
726 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
727 "",
728 "[[ Password Managers ]]",
729 "",
730 " 9000 = Password Safe v2",
731 " 5200 = Password Safe v3",
732 " 6800 = Lastpass",
733 " 6600 = 1Password, agilekeychain",
734 " 8200 = 1Password, cloudkeychain",
735 " 11300 = Bitcoin/Litecoin wallet.dat",
736 " 12700 = Blockchain, My Wallet",
737 "",
738 NULL
739 };
740
741 /**
742 * oclHashcat specific functions
743 */
744
745 void status_display_automat ()
746 {
747 FILE *out = stdout;
748
749 fprintf (out, "STATUS\t%u\t", data.devices_status);
750
751 /**
752 * speed new
753 */
754
755 fprintf (out, "SPEED\t");
756
757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
758 {
759 hc_device_param_t *device_param = &data.devices_param[device_id];
760
761 if (device_param->skipped) continue;
762
763 u64 speed_cnt = 0;
764 float speed_ms = 0;
765
766 for (int i = 0; i < SPEED_CACHE; i++)
767 {
768 float rec_ms;
769
770 hc_timer_get (device_param->speed_rec[i], rec_ms);
771
772 if (rec_ms > SPEED_MAXAGE) continue;
773
774 speed_cnt += device_param->speed_cnt[i];
775 speed_ms += device_param->speed_ms[i];
776 }
777
778 speed_cnt /= SPEED_CACHE;
779 speed_ms /= SPEED_CACHE;
780
781 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
782 }
783
784 /**
785 * words_cur
786 */
787
788 u64 words_cur = get_lowest_words_done ();
789
790 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
791
792 /**
793 * counter
794 */
795
796 uint salts_left = data.salts_cnt - data.salts_done;
797
798 if (salts_left == 0) salts_left = 1;
799
800 u64 progress_total = data.words_cnt * salts_left;
801
802 u64 all_done = 0;
803 u64 all_rejected = 0;
804 u64 all_restored = 0;
805
806 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
807 {
808 if (salts_left > 1)
809 {
810 // otherwise the final cracked status shows 0/XXX progress
811
812 if (data.salts_shown[salt_pos] == 1) continue;
813 }
814
815 all_done += data.words_progress_done[salt_pos];
816 all_rejected += data.words_progress_rejected[salt_pos];
817 all_restored += data.words_progress_restored[salt_pos];
818 }
819
820 u64 progress_cur = all_restored + all_done + all_rejected;
821 u64 progress_end = progress_total;
822
823 u64 progress_skip = 0;
824
825 if (data.skip)
826 {
827 progress_skip = MIN (data.skip, data.words_base) * salts_left;
828
829 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
830 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
831 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
832 }
833
834 if (data.limit)
835 {
836 progress_end = MIN (data.limit, data.words_base) * salts_left;
837
838 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
839 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
840 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
841 }
842
843 u64 progress_cur_relative_skip = progress_cur - progress_skip;
844 u64 progress_end_relative_skip = progress_end - progress_skip;
845
846 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
847
848 /**
849 * cracks
850 */
851
852 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
853 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
854
855 /**
856 * temperature
857 */
858
859 #ifdef HAVE_HWMON
860 if (data.gpu_temp_disable == 0)
861 {
862 fprintf (out, "TEMP\t");
863
864 hc_thread_mutex_lock (mux_adl);
865
866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
867 {
868 hc_device_param_t *device_param = &data.devices_param[device_id];
869
870 if (device_param->skipped) continue;
871
872 int temp = hm_get_temperature_with_device_id (device_id);
873
874 fprintf (out, "%d\t", temp);
875 }
876
877 hc_thread_mutex_unlock (mux_adl);
878 }
879 #endif // HAVE_HWMON
880
881 #ifdef _WIN
882 fputc ('\r', out);
883 fputc ('\n', out);
884 #endif
885
886 #ifdef _POSIX
887 fputc ('\n', out);
888 #endif
889
890 fflush (out);
891 }
892
893 void status_display ()
894 {
895 if (data.devices_status == STATUS_INIT) return;
896 if (data.devices_status == STATUS_STARTING) return;
897 if (data.devices_status == STATUS_BYPASS) return;
898
899 if (data.status_automat == 1)
900 {
901 status_display_automat ();
902
903 return;
904 }
905
906 char tmp_buf[1000] = { 0 };
907
908 uint tmp_len = 0;
909
910 log_info ("Session.Name...: %s", data.session);
911
912 char *status_type = strstatus (data.devices_status);
913
914 uint hash_mode = data.hash_mode;
915
916 char *hash_type = strhashtype (hash_mode); // not a bug
917
918 log_info ("Status.........: %s", status_type);
919
920 /**
921 * show rules
922 */
923
924 if (data.rp_files_cnt)
925 {
926 uint i;
927
928 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
929 {
930 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
931 }
932
933 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
934
935 log_info ("Rules.Type.....: %s", tmp_buf);
936
937 tmp_len = 0;
938 }
939
940 if (data.rp_gen)
941 {
942 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
943
944 if (data.rp_gen_seed)
945 {
946 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
947 }
948 }
949
950 /**
951 * show input
952 */
953
954 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
955 {
956 if (data.wordlist_mode == WL_MODE_FILE)
957 {
958 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
959 }
960 else if (data.wordlist_mode == WL_MODE_STDIN)
961 {
962 log_info ("Input.Mode.....: Pipe");
963 }
964 }
965 else if (data.attack_mode == ATTACK_MODE_COMBI)
966 {
967 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
968 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
969 }
970 else if (data.attack_mode == ATTACK_MODE_BF)
971 {
972 char *mask = data.mask;
973
974 if (mask != NULL)
975 {
976 uint mask_len = data.css_cnt;
977
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
979
980 if (mask_len > 0)
981 {
982 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
983 {
984 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
985 {
986 mask_len -= data.salts_buf[0].salt_len;
987 }
988 }
989
990 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
991
992 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
993 }
994
995 if (data.maskcnt > 1)
996 {
997 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1000 }
1001
1002 log_info ("Input.Mode.....: %s", tmp_buf);
1003 }
1004
1005 tmp_len = 0;
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1008 {
1009 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1010 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1013 {
1014 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1015 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1016 }
1017
1018 if (data.digests_cnt == 1)
1019 {
1020 if (data.hash_mode == 2500)
1021 {
1022 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1023
1024 uint pke[25] = { 0 };
1025
1026 char *pke_ptr = (char *) pke;
1027
1028 for (uint i = 0; i < 25; i++)
1029 {
1030 pke[i] = byte_swap_32 (wpa->pke[i]);
1031 }
1032
1033 char mac1[6] = { 0 };
1034 char mac2[6] = { 0 };
1035
1036 memcpy (mac1, pke_ptr + 23, 6);
1037 memcpy (mac2, pke_ptr + 29, 6);
1038
1039 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1040 (char *) data.salts_buf[0].salt_buf,
1041 mac1[0] & 0xff,
1042 mac1[1] & 0xff,
1043 mac1[2] & 0xff,
1044 mac1[3] & 0xff,
1045 mac1[4] & 0xff,
1046 mac1[5] & 0xff,
1047 mac2[0] & 0xff,
1048 mac2[1] & 0xff,
1049 mac2[2] & 0xff,
1050 mac2[3] & 0xff,
1051 mac2[4] & 0xff,
1052 mac2[5] & 0xff);
1053 }
1054 else if (data.hash_mode == 5200)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if (data.hash_mode == 9000)
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else
1067 {
1068 char out_buf[4096] = { 0 };
1069
1070 ascii_digest (out_buf, 0, 0);
1071
1072 // limit length
1073 if (strlen (out_buf) > 40)
1074 {
1075 out_buf[41] = '.';
1076 out_buf[42] = '.';
1077 out_buf[43] = '.';
1078 out_buf[44] = 0;
1079 }
1080
1081 log_info ("Hash.Target....: %s", out_buf);
1082 }
1083 }
1084 else
1085 {
1086 if (data.hash_mode == 3000)
1087 {
1088 char out_buf1[4096] = { 0 };
1089 char out_buf2[4096] = { 0 };
1090
1091 ascii_digest (out_buf1, 0, 0);
1092 ascii_digest (out_buf2, 0, 1);
1093
1094 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1095 }
1096 else
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 }
1101
1102 log_info ("Hash.Type......: %s", hash_type);
1103
1104 /**
1105 * speed new
1106 */
1107
1108 u64 speed_cnt[DEVICES_MAX] = { 0 };
1109 float speed_ms[DEVICES_MAX] = { 0 };
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hc_device_param_t *device_param = &data.devices_param[device_id];
1114
1115 if (device_param->skipped) continue;
1116
1117 // we need to clear values (set to 0) because in case the device does
1118 // not get new candidates it idles around but speed display would
1119 // show it as working.
1120 // if we instantly set it to 0 after reading it happens that the
1121 // speed can be shown as zero if the users refreshes too fast.
1122 // therefore, we add a timestamp when a stat was recorded and if its
1123 // too old we will not use it
1124
1125 speed_cnt[device_id] = 0;
1126 speed_ms[device_id] = 0;
1127
1128 for (int i = 0; i < SPEED_CACHE; i++)
1129 {
1130 float rec_ms;
1131
1132 hc_timer_get (device_param->speed_rec[i], rec_ms);
1133
1134 if (rec_ms > SPEED_MAXAGE) continue;
1135
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 float hashes_all_ms = 0;
1145
1146 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * timers
1166 */
1167
1168 float ms_running = 0;
1169
1170 hc_timer_get (data.timer_running, ms_running);
1171
1172 float ms_paused = data.ms_paused;
1173
1174 if (data.devices_status == STATUS_PAUSED)
1175 {
1176 float ms_paused_tmp = 0;
1177
1178 hc_timer_get (data.timer_paused, ms_paused_tmp);
1179
1180 ms_paused += ms_paused_tmp;
1181 }
1182
1183 #ifdef WIN
1184
1185 __time64_t sec_run = ms_running / 1000;
1186
1187 #else
1188
1189 time_t sec_run = ms_running / 1000;
1190
1191 #endif
1192
1193 if (sec_run)
1194 {
1195 char display_run[32] = { 0 };
1196
1197 struct tm tm_run;
1198
1199 struct tm *tmp = NULL;
1200
1201 #ifdef WIN
1202
1203 tmp = _gmtime64 (&sec_run);
1204
1205 #else
1206
1207 tmp = gmtime (&sec_run);
1208
1209 #endif
1210
1211 if (tmp != NULL)
1212 {
1213 memset (&tm_run, 0, sizeof (tm_run));
1214
1215 memcpy (&tm_run, tmp, sizeof (tm_run));
1216
1217 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1218
1219 char *start = ctime (&data.proc_start);
1220
1221 size_t start_len = strlen (start);
1222
1223 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1224 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1225
1226 log_info ("Time.Started...: %s (%s)", start, display_run);
1227 }
1228 }
1229 else
1230 {
1231 log_info ("Time.Started...: 0 secs");
1232 }
1233
1234 /**
1235 * counters
1236 */
1237
1238 uint salts_left = data.salts_cnt - data.salts_done;
1239
1240 if (salts_left == 0) salts_left = 1;
1241
1242 u64 progress_total = data.words_cnt * salts_left;
1243
1244 u64 all_done = 0;
1245 u64 all_rejected = 0;
1246 u64 all_restored = 0;
1247
1248 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1249 {
1250 if (salts_left > 1)
1251 {
1252 // otherwise the final cracked status shows 0/XXX progress
1253
1254 if (data.salts_shown[salt_pos] == 1) continue;
1255 }
1256
1257 all_done += data.words_progress_done[salt_pos];
1258 all_rejected += data.words_progress_rejected[salt_pos];
1259 all_restored += data.words_progress_restored[salt_pos];
1260 }
1261
1262 u64 progress_cur = all_restored + all_done + all_rejected;
1263 u64 progress_end = progress_total;
1264
1265 u64 progress_skip = 0;
1266
1267 if (data.skip)
1268 {
1269 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1270
1271 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1272 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1273 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1274 }
1275
1276 if (data.limit)
1277 {
1278 progress_end = MIN (data.limit, data.words_base) * salts_left;
1279
1280 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1281 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1282 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1283 }
1284
1285 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1286 u64 progress_end_relative_skip = progress_end - progress_skip;
1287
1288 float speed_ms_real = ms_running - ms_paused;
1289 u64 speed_plains_real = all_done;
1290
1291 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1292 {
1293 if (data.devices_status != STATUS_CRACKED)
1294 {
1295 u64 words_per_ms = 0;
1296
1297 if (speed_plains_real && speed_ms_real)
1298 {
1299 words_per_ms = speed_plains_real / speed_ms_real;
1300 }
1301
1302 #ifdef WIN
1303 __time64_t sec_etc = 0;
1304 #else
1305 time_t sec_etc = 0;
1306 #endif
1307
1308 if (words_per_ms)
1309 {
1310 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1311
1312 u64 ms_left = progress_left_relative_skip / words_per_ms;
1313
1314 sec_etc = ms_left / 1000;
1315 }
1316
1317 if (sec_etc == 0)
1318 {
1319 log_info ("Time.Estimated.: 0 secs");
1320 }
1321 else if ((u64) sec_etc > ETC_MAX)
1322 {
1323 log_info ("Time.Estimated.: > 10 Years");
1324 }
1325 else
1326 {
1327 char display_etc[32] = { 0 };
1328
1329 struct tm tm_etc;
1330
1331 struct tm *tmp = NULL;
1332
1333 #ifdef WIN
1334
1335 tmp = _gmtime64 (&sec_etc);
1336
1337 #else
1338
1339 tmp = gmtime (&sec_etc);
1340
1341 #endif
1342
1343 if (tmp != NULL)
1344 {
1345 memset (&tm_etc, 0, sizeof (tm_etc));
1346
1347 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1348
1349 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1350
1351 time_t now;
1352
1353 time (&now);
1354
1355 now += sec_etc;
1356
1357 char *etc = ctime (&now);
1358
1359 size_t etc_len = strlen (etc);
1360
1361 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1362 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1363
1364 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1365 }
1366 }
1367 }
1368 }
1369
1370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1371 {
1372 hc_device_param_t *device_param = &data.devices_param[device_id];
1373
1374 if (device_param->skipped) continue;
1375
1376 char display_dev_cur[16] = { 0 };
1377
1378 strncpy (display_dev_cur, "0.00", 4);
1379
1380 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1381
1382 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1383 }
1384
1385 char display_all_cur[16] = { 0 };
1386
1387 strncpy (display_all_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1390
1391 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1392
1393 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1394 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1395
1396 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1397
1398 // crack-per-time
1399
1400 if (data.digests_cnt > 100)
1401 {
1402 time_t now = time (NULL);
1403
1404 int cpt_cur_min = 0;
1405 int cpt_cur_hour = 0;
1406 int cpt_cur_day = 0;
1407
1408 for (int i = 0; i < CPT_BUF; i++)
1409 {
1410 const uint cracked = data.cpt_buf[i].cracked;
1411 const time_t timestamp = data.cpt_buf[i].timestamp;
1412
1413 if ((timestamp + 60) > now)
1414 {
1415 cpt_cur_min += cracked;
1416 }
1417
1418 if ((timestamp + 3600) > now)
1419 {
1420 cpt_cur_hour += cracked;
1421 }
1422
1423 if ((timestamp + 86400) > now)
1424 {
1425 cpt_cur_day += cracked;
1426 }
1427 }
1428
1429 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1430 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1431 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1432
1433 if ((data.cpt_start + 86400) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_cur_hour,
1438 cpt_cur_day,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else if ((data.cpt_start + 3600) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 60) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else
1461 {
1462 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 }
1468
1469 // Restore point
1470
1471 u64 restore_point = get_lowest_words_done ();
1472
1473 u64 restore_total = data.words_base;
1474
1475 float percent_restore = 0;
1476
1477 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1478
1479 if (progress_end_relative_skip)
1480 {
1481 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1482 {
1483 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1484 float percent_rejected = 0.0;
1485
1486 if (progress_cur)
1487 {
1488 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1489 }
1490
1491 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1492 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1493
1494 if (data.restore_disable == 0)
1495 {
1496 if (percent_finished != 1)
1497 {
1498 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1499 }
1500 }
1501 }
1502 }
1503 else
1504 {
1505 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1506 {
1507 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509
1510 if (data.restore_disable == 0)
1511 {
1512 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513 }
1514 }
1515 else
1516 {
1517 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1518 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1519
1520 // --restore not allowed if stdin is used -- really? why?
1521
1522 //if (data.restore_disable == 0)
1523 //{
1524 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1525 //}
1526 }
1527 }
1528
1529 #ifdef HAVE_HWMON
1530 if (data.gpu_temp_disable == 0)
1531 {
1532 hc_thread_mutex_lock (mux_adl);
1533
1534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1535 {
1536 hc_device_param_t *device_param = &data.devices_param[device_id];
1537
1538 if (device_param->skipped) continue;
1539
1540 #define HM_STR_BUF_SIZE 255
1541
1542 if (data.hm_device[device_id].fan_supported == 1)
1543 {
1544 char utilization[HM_STR_BUF_SIZE] = { 0 };
1545 char temperature[HM_STR_BUF_SIZE] = { 0 };
1546 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1547
1548 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1549 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1550
1551 if (device_param->vendor_id == VENDOR_ID_AMD)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555 else if (device_param->vendor_id == VENDOR_ID_NV)
1556 {
1557 #ifdef LINUX
1558 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1559 #else
1560 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1561 #endif
1562 }
1563
1564 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1565 }
1566 else
1567 {
1568 char utilization[HM_STR_BUF_SIZE] = { 0 };
1569 char temperature[HM_STR_BUF_SIZE] = { 0 };
1570
1571 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1572 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1573
1574 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1575 }
1576 }
1577
1578 hc_thread_mutex_unlock (mux_adl);
1579 }
1580 #endif // HAVE_HWMON
1581 }
1582
1583 static void status_benchmark ()
1584 {
1585 if (data.devices_status == STATUS_INIT) return;
1586 if (data.devices_status == STATUS_STARTING) return;
1587
1588 if (data.words_cnt == 0) return;
1589
1590 u64 speed_cnt[DEVICES_MAX] = { 0 };
1591 float speed_ms[DEVICES_MAX] = { 0 };
1592
1593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1594 {
1595 hc_device_param_t *device_param = &data.devices_param[device_id];
1596
1597 if (device_param->skipped) continue;
1598
1599 speed_cnt[device_id] = 0;
1600 speed_ms[device_id] = 0;
1601
1602 for (int i = 0; i < SPEED_CACHE; i++)
1603 {
1604 speed_cnt[device_id] += device_param->speed_cnt[i];
1605 speed_ms[device_id] += device_param->speed_ms[i];
1606 }
1607
1608 speed_cnt[device_id] /= SPEED_CACHE;
1609 speed_ms[device_id] /= SPEED_CACHE;
1610 }
1611
1612 float hashes_all_ms = 0;
1613
1614 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 hashes_dev_ms[device_id] = 0;
1623
1624 if (speed_ms[device_id])
1625 {
1626 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1627
1628 hashes_all_ms += hashes_dev_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 char display_dev_cur[16] = { 0 };
1639
1640 strncpy (display_dev_cur, "0.00", 4);
1641
1642 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1643
1644 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1645 }
1646
1647 char display_all_cur[16] = { 0 };
1648
1649 strncpy (display_all_cur, "0.00", 4);
1650
1651 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1652
1653 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1654 }
1655
1656 /**
1657 * oclHashcat -only- functions
1658 */
1659
1660 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1661 {
1662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1663 {
1664 if (attack_kern == ATTACK_KERN_STRAIGHT)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1666 else if (attack_kern == ATTACK_KERN_COMBI)
1667 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1668 else if (attack_kern == ATTACK_KERN_BF)
1669 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1670 }
1671 else
1672 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1673 }
1674
1675 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1676 {
1677 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1678 {
1679 if (attack_kern == ATTACK_KERN_STRAIGHT)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 else if (attack_kern == ATTACK_KERN_COMBI)
1682 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1683 else if (attack_kern == ATTACK_KERN_BF)
1684 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1685 }
1686 else
1687 {
1688 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1689 }
1690 }
1691
1692 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1693 {
1694 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1695 {
1696 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1697 }
1698 else
1699 {
1700 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1701 }
1702 }
1703
1704 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1705 {
1706 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1707 {
1708 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1709 }
1710 else
1711 {
1712 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1713 }
1714 }
1715
1716 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1717 {
1718 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1719 }
1720
1721 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1722 {
1723 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1724 }
1725
1726 static uint convert_from_hex (char *line_buf, const uint line_len)
1727 {
1728 if (line_len & 1) return (line_len); // not in hex
1729
1730 if (data.hex_wordlist == 1)
1731 {
1732 uint i;
1733 uint j;
1734
1735 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1736 {
1737 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1738 }
1739
1740 memset (line_buf + i, 0, line_len - i);
1741
1742 return (i);
1743 }
1744 else if (line_len >= 6) // $HEX[] = 6
1745 {
1746 if (line_buf[0] != '$') return (line_len);
1747 if (line_buf[1] != 'H') return (line_len);
1748 if (line_buf[2] != 'E') return (line_len);
1749 if (line_buf[3] != 'X') return (line_len);
1750 if (line_buf[4] != '[') return (line_len);
1751 if (line_buf[line_len - 1] != ']') return (line_len);
1752
1753 uint i;
1754 uint j;
1755
1756 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1757 {
1758 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1759 }
1760
1761 memset (line_buf + i, 0, line_len - i);
1762
1763 return (i);
1764 }
1765
1766 return (line_len);
1767 }
1768
1769 static uint count_lines (FILE *fd)
1770 {
1771 uint cnt = 0;
1772
1773 char *buf = (char *) mymalloc (BUFSIZ + 1);
1774
1775 size_t nread_tmp = 0;
1776
1777 char *ptr = buf;
1778
1779 while (!feof (fd))
1780 {
1781 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1782 nread_tmp = nread;
1783
1784 if (nread < 1) continue;
1785
1786 ptr = buf;
1787
1788 do
1789 {
1790 if (*ptr++ == '\n') cnt++;
1791
1792 } while (nread--);
1793 }
1794
1795 // special case (if last line did not contain a newline char ... at the very end of the file)
1796
1797 if (nread_tmp > 3)
1798 {
1799 ptr -= 2;
1800
1801 if (*ptr != '\n')
1802 {
1803 ptr--;
1804
1805 if (*ptr != '\n') // needed ? different on windows systems?
1806 {
1807 cnt++;
1808 }
1809 }
1810 }
1811
1812 myfree (buf);
1813
1814 return cnt;
1815 }
1816
1817 static void clear_prompt ()
1818 {
1819 fputc ('\r', stdout);
1820
1821 for (size_t i = 0; i < strlen (PROMPT); i++)
1822 {
1823 fputc (' ', stdout);
1824 }
1825
1826 fputc ('\r', stdout);
1827
1828 fflush (stdout);
1829 }
1830
1831 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1832 {
1833 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1834 }
1835
1836 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1837 {
1838 char *outfile = data.outfile;
1839 uint quiet = data.quiet;
1840 FILE *pot_fp = data.pot_fp;
1841 uint loopback = data.loopback;
1842 uint debug_mode = data.debug_mode;
1843 char *debug_file = data.debug_file;
1844
1845 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1846 int debug_rule_len = 0; // -1 error
1847 uint debug_plain_len = 0;
1848
1849 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1850
1851 // hash
1852
1853 char out_buf[4096] = { 0 };
1854
1855 ascii_digest (out_buf, salt_pos, digest_pos);
1856
1857 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1858
1859 // plain
1860
1861 plain_t plain;
1862
1863 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1864
1865 uint gidvid = plain.gidvid;
1866 uint il_pos = plain.il_pos;
1867
1868 u64 crackpos = device_param->words_off;
1869
1870 uint plain_buf[16] = { 0 };
1871
1872 u8 *plain_ptr = (u8 *) plain_buf;
1873 unsigned int plain_len = 0;
1874
1875 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1876 {
1877 u64 gidd = gidvid;
1878 u64 gidm = 0;
1879
1880 pw_t pw;
1881
1882 gidd_to_pw_t (device_param, gidd, &pw);
1883
1884 for (int i = 0, j = gidm; i < 16; i++, j++)
1885 {
1886 plain_buf[i] = pw.h.hi1[0][j];
1887 }
1888
1889 plain_len = pw.pw_len;
1890
1891 const uint off = device_param->innerloop_pos + il_pos;
1892
1893 if (debug_mode > 0)
1894 {
1895 debug_rule_len = 0;
1896
1897 // save rule
1898 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1899 {
1900 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1901
1902 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1903 }
1904
1905 // save plain
1906 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1907 {
1908 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1909
1910 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1911
1912 debug_plain_len = plain_len;
1913 }
1914 }
1915
1916 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1917
1918 crackpos += gidvid;
1919 crackpos *= data.kernel_rules_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921
1922 if (plain_len > data.pw_max) plain_len = data.pw_max;
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_COMBI)
1925 {
1926 u64 gidd = gidvid;
1927 u64 gidm = 0;
1928
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidd, &pw);
1932
1933 for (int i = 0, j = gidm; i < 16; i++, j++)
1934 {
1935 plain_buf[i] = pw.h.hi1[0][j];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1941 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1942
1943 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1944 {
1945 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1946 }
1947 else
1948 {
1949 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1950
1951 memcpy (plain_ptr, comb_buf, comb_len);
1952 }
1953
1954 plain_len += comb_len;
1955
1956 crackpos += gidvid;
1957 crackpos *= data.combs_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (data.pw_max != PW_DICTMAX1)
1961 {
1962 if (plain_len > data.pw_max) plain_len = data.pw_max;
1963 }
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_BF)
1966 {
1967 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1968 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1969
1970 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1971 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1972
1973 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1974 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1975
1976 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1977 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1978
1979 plain_len = data.css_cnt;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.bfs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984 }
1985 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1986 {
1987 u64 gidd = gidvid;
1988 u64 gidm = 0;
1989
1990 pw_t pw;
1991
1992 gidd_to_pw_t (device_param, gidd, &pw);
1993
1994 for (int i = 0, j = gidm; i < 16; i++, j++)
1995 {
1996 plain_buf[i] = pw.h.hi1[0][j];
1997 }
1998
1999 plain_len = pw.pw_len;
2000
2001 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2002
2003 uint start = 0;
2004 uint stop = device_param->kernel_params_mp_buf32[4];
2005
2006 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2007
2008 plain_len += start + stop;
2009
2010 crackpos += gidvid;
2011 crackpos *= data.combs_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013
2014 if (data.pw_max != PW_DICTMAX1)
2015 {
2016 if (plain_len > data.pw_max) plain_len = data.pw_max;
2017 }
2018 }
2019 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2020 {
2021 u64 gidd = gidvid;
2022 u64 gidm = 0;
2023
2024 pw_t pw;
2025
2026 gidd_to_pw_t (device_param, gidd, &pw);
2027
2028 for (int i = 0, j = gidm; i < 16; i++, j++)
2029 {
2030 plain_buf[i] = pw.h.hi1[0][j];
2031 }
2032
2033 plain_len = pw.pw_len;
2034
2035 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2036
2037 uint start = 0;
2038 uint stop = device_param->kernel_params_mp_buf32[4];
2039
2040 memmove (plain_ptr + stop, plain_ptr, plain_len);
2041
2042 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2043
2044 plain_len += start + stop;
2045
2046 crackpos += gidvid;
2047 crackpos *= data.combs_cnt;
2048 crackpos += device_param->innerloop_pos + il_pos;
2049
2050 if (data.pw_max != PW_DICTMAX1)
2051 {
2052 if (plain_len > data.pw_max) plain_len = data.pw_max;
2053 }
2054 }
2055
2056 if (data.attack_mode == ATTACK_MODE_BF)
2057 {
2058 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2059 {
2060 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2061 {
2062 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2063 {
2064 plain_len = plain_len - data.salts_buf[0].salt_len;
2065 }
2066 }
2067
2068 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2069 {
2070 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2071 {
2072 plain_ptr[j] = plain_ptr[i];
2073 }
2074
2075 plain_len = plain_len / 2;
2076 }
2077 }
2078 }
2079
2080 // if enabled, update also the potfile
2081
2082 if (pot_fp)
2083 {
2084 lock_file (pot_fp);
2085
2086 fprintf (pot_fp, "%s:", out_buf);
2087
2088 format_plain (pot_fp, plain_ptr, plain_len, 1);
2089
2090 fputc ('\n', pot_fp);
2091
2092 fflush (pot_fp);
2093
2094 unlock_file (pot_fp);
2095 }
2096
2097 // outfile
2098
2099 FILE *out_fp = NULL;
2100
2101 if (outfile != NULL)
2102 {
2103 if ((out_fp = fopen (outfile, "ab")) == NULL)
2104 {
2105 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2106
2107 out_fp = stdout;
2108 }
2109 lock_file (out_fp);
2110 }
2111 else
2112 {
2113 out_fp = stdout;
2114
2115 if (quiet == 0) clear_prompt ();
2116 }
2117
2118 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2119
2120 if (outfile != NULL)
2121 {
2122 if (out_fp != stdout)
2123 {
2124 fclose (out_fp);
2125 }
2126 }
2127 else
2128 {
2129 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2130 {
2131 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2132 {
2133 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2134 if (quiet == 0) fflush (stdout);
2135 }
2136 }
2137 }
2138
2139 // loopback
2140
2141 if (loopback)
2142 {
2143 char *loopback_file = data.loopback_file;
2144
2145 FILE *fb_fp = NULL;
2146
2147 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2148 {
2149 lock_file (fb_fp);
2150
2151 format_plain (fb_fp, plain_ptr, plain_len, 1);
2152
2153 fputc ('\n', fb_fp);
2154
2155 fclose (fb_fp);
2156 }
2157 }
2158
2159 // (rule) debug mode
2160
2161 // the next check implies that:
2162 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2163 // - debug_mode > 0
2164
2165 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2166 {
2167 if (debug_rule_len < 0) debug_rule_len = 0;
2168
2169 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2170
2171 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2172
2173 if ((quiet == 0) && (debug_file == NULL))
2174 {
2175 fprintf (stdout, "%s", PROMPT);
2176 fflush (stdout);
2177 }
2178 }
2179 }
2180
2181 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2182 {
2183 salt_t *salt_buf = &data.salts_buf[salt_pos];
2184
2185 int found = 0;
2186
2187 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2188
2189 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2190
2191 if (found == 1)
2192 {
2193 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2194
2195 log_info_nn ("");
2196
2197 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2198
2199 uint cpt_cracked = 0;
2200
2201 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2202 {
2203 uint idx = salt_buf->digests_offset + digest_pos;
2204
2205 if (data.digests_shown_tmp[idx] == 0) continue;
2206
2207 if (data.digests_shown[idx] == 1) continue;
2208
2209 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2210 {
2211 data.digests_shown[idx] = 1;
2212
2213 data.digests_done++;
2214
2215 cpt_cracked++;
2216
2217 salt_buf->digests_done++;
2218
2219 if (salt_buf->digests_done == salt_buf->digests_cnt)
2220 {
2221 data.salts_shown[salt_pos] = 1;
2222
2223 data.salts_done++;
2224 }
2225 }
2226
2227 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2228
2229 check_hash (device_param, salt_pos, digest_pos);
2230 }
2231
2232 if (cpt_cracked > 0)
2233 {
2234 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2235 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2236
2237 data.cpt_pos++;
2238
2239 data.cpt_total += cpt_cracked;
2240
2241 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2242 }
2243
2244 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2245 {
2246 // we need to reset cracked state on the device
2247 // otherwise host thinks again and again the hash was cracked
2248 // and returns invalid password each time
2249
2250 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2251
2252 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2253 }
2254
2255 memset (device_param->result, 0, device_param->size_results);
2256
2257 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2258 }
2259 }
2260
2261 static void save_hash ()
2262 {
2263 char *hashfile = data.hashfile;
2264
2265 char new_hashfile[256] = { 0 };
2266 char old_hashfile[256] = { 0 };
2267
2268 snprintf (new_hashfile, 255, "%s.new", hashfile);
2269 snprintf (old_hashfile, 255, "%s.old", hashfile);
2270
2271 unlink (new_hashfile);
2272
2273 char separator = data.separator;
2274
2275 FILE *fp = fopen (new_hashfile, "wb");
2276
2277 if (fp == NULL)
2278 {
2279 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2280
2281 exit (-1);
2282 }
2283
2284 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2285 {
2286 if (data.salts_shown[salt_pos] == 1) continue;
2287
2288 salt_t *salt_buf = &data.salts_buf[salt_pos];
2289
2290 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2291 {
2292 uint idx = salt_buf->digests_offset + digest_pos;
2293
2294 if (data.digests_shown[idx] == 1) continue;
2295
2296 if (data.hash_mode != 2500)
2297 {
2298 char out_buf[4096] = { 0 };
2299
2300 if (data.username == 1)
2301 {
2302 user_t *user = data.hash_info[idx]->user;
2303
2304 uint i;
2305
2306 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2307
2308 fputc (separator, fp);
2309 }
2310
2311 ascii_digest (out_buf, salt_pos, digest_pos);
2312
2313 fputs (out_buf, fp);
2314
2315 log_out (fp, "");
2316 }
2317 else
2318 {
2319 hccap_t hccap;
2320
2321 to_hccap_t (&hccap, salt_pos, digest_pos);
2322
2323 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2324 }
2325 }
2326 }
2327
2328 fflush (fp);
2329
2330 fclose (fp);
2331
2332 unlink (old_hashfile);
2333
2334 if (rename (hashfile, old_hashfile) != 0)
2335 {
2336 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2337
2338 exit (-1);
2339 }
2340
2341 unlink (hashfile);
2342
2343 if (rename (new_hashfile, hashfile) != 0)
2344 {
2345 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2346
2347 exit (-1);
2348 }
2349
2350 unlink (old_hashfile);
2351 }
2352
2353 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2354 {
2355 // function called only in case kernel_blocks_all > words_left)
2356
2357 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2358
2359 kernel_blocks_div += kernel_blocks_div / 100;
2360
2361 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2362
2363 while (kernel_blocks_new < total_left)
2364 {
2365 kernel_blocks_div += kernel_blocks_div / 100;
2366
2367 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2368 }
2369
2370 if (data.quiet == 0)
2371 {
2372 clear_prompt ();
2373
2374 log_info ("");
2375
2376 log_info ("INFO: approaching final keyspace, workload adjusted");
2377
2378 log_info ("");
2379
2380 fprintf (stdout, "%s", PROMPT);
2381
2382 fflush (stdout);
2383 }
2384
2385 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2386
2387 return kernel_blocks_div;
2388 }
2389
2390 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2391 {
2392 uint num_elements = num;
2393
2394 device_param->kernel_params_buf32[30] = data.combs_mode;
2395 device_param->kernel_params_buf32[31] = num;
2396
2397 uint kernel_threads = device_param->kernel_threads;
2398
2399 while (num_elements % kernel_threads) num_elements++;
2400
2401 cl_kernel kernel = NULL;
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_1: kernel = device_param->kernel1; break;
2406 case KERN_RUN_12: kernel = device_param->kernel12; break;
2407 case KERN_RUN_2: kernel = device_param->kernel2; break;
2408 case KERN_RUN_23: kernel = device_param->kernel23; break;
2409 case KERN_RUN_3: kernel = device_param->kernel3; break;
2410 }
2411
2412 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2413 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2414 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2415 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2416 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2417 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2418 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2419 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2420 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2421 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2422 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2423
2424 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2425 {
2426 const size_t global_work_size[3] = { num_elements, 32, 1 };
2427 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2428
2429 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2430 }
2431 else
2432 {
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2437 }
2438
2439 hc_clFlush (data.ocl, device_param->command_queue);
2440
2441 hc_clFinish (data.ocl, device_param->command_queue);
2442 }
2443
2444 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2445 {
2446 uint num_elements = num;
2447
2448 switch (kern_run)
2449 {
2450 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2451 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2452 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2453 }
2454
2455 // causes problems with special threads like in bcrypt
2456 // const uint kernel_threads = device_param->kernel_threads;
2457
2458 const uint kernel_threads = KERNEL_THREADS;
2459
2460 while (num_elements % kernel_threads) num_elements++;
2461
2462 cl_kernel kernel = NULL;
2463
2464 switch (kern_run)
2465 {
2466 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2467 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2468 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2469 }
2470
2471 switch (kern_run)
2472 {
2473 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2474 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2475 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2476 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2477 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2478 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2479 break;
2480 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2481 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2482 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2483 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2484 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2485 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2486 break;
2487 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2493 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2494 break;
2495 }
2496
2497 const size_t global_work_size[3] = { num_elements, 1, 1 };
2498 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2499
2500 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2501
2502 hc_clFlush (data.ocl, device_param->command_queue);
2503
2504 hc_clFinish (data.ocl, device_param->command_queue);
2505 }
2506
2507 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2508 {
2509 uint num_elements = num;
2510
2511 uint kernel_threads = device_param->kernel_threads;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = device_param->kernel_tb;
2516
2517 const size_t global_work_size[3] = { num_elements, 1, 1 };
2518 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2519
2520 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2521
2522 hc_clFlush (data.ocl, device_param->command_queue);
2523
2524 hc_clFinish (data.ocl, device_param->command_queue);
2525 }
2526
2527 static void run_kernel_tm (hc_device_param_t *device_param)
2528 {
2529 const uint num_elements = 1024; // fixed
2530
2531 const uint kernel_threads = 32;
2532
2533 cl_kernel kernel = device_param->kernel_tm;
2534
2535 const size_t global_work_size[3] = { num_elements, 1, 1 };
2536 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2537
2538 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2539
2540 hc_clFlush (data.ocl, device_param->command_queue);
2541
2542 hc_clFinish (data.ocl, device_param->command_queue);
2543 }
2544
2545 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2546 {
2547 uint num_elements = num;
2548
2549 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2550 device_param->kernel_params_amp_buf32[6] = num_elements;
2551
2552 // causes problems with special threads like in bcrypt
2553 // const uint kernel_threads = device_param->kernel_threads;
2554
2555 const uint kernel_threads = KERNEL_THREADS;
2556
2557 while (num_elements % kernel_threads) num_elements++;
2558
2559 cl_kernel kernel = device_param->kernel_amp;
2560
2561 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2562 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2563
2564 const size_t global_work_size[3] = { num_elements, 1, 1 };
2565 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2566
2567 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2568
2569 hc_clFlush (data.ocl, device_param->command_queue);
2570
2571 hc_clFinish (data.ocl, device_param->command_queue);
2572 }
2573
2574 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2575 {
2576 if (device_param->vendor_id == VENDOR_ID_AMD)
2577 {
2578 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2579
2580 const cl_uchar zero = 0;
2581
2582 hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2583 }
2584 else
2585 {
2586 // NOTE: clEnqueueFillBuffer () always fails with -59
2587 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2588 // How's that possible, OpenCL 1.2 support is advertised??
2589 // We need to workaround...
2590
2591 #define FILLSZ 0x100000
2592
2593 char *tmp = (char *) mymalloc (FILLSZ);
2594
2595 for (uint i = 0; i < size; i += FILLSZ)
2596 {
2597 const int left = size - i;
2598
2599 const int fillsz = MIN (FILLSZ, left);
2600
2601 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2602 }
2603
2604 myfree (tmp);
2605 }
2606 }
2607
2608 static int run_rule_engine (const int rule_len, const char *rule_buf)
2609 {
2610 if (rule_len == 0)
2611 {
2612 return 0;
2613 }
2614 else if (rule_len == 1)
2615 {
2616 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2617 }
2618
2619 return 1;
2620 }
2621
2622 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2623 {
2624 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2625 {
2626 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2627 }
2628 else if (data.attack_kern == ATTACK_KERN_COMBI)
2629 {
2630 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2631 }
2632 else if (data.attack_kern == ATTACK_KERN_BF)
2633 {
2634 const u64 off = device_param->words_off;
2635
2636 device_param->kernel_params_mp_l_buf64[3] = off;
2637
2638 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2639 }
2640 }
2641
2642 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2643 {
2644 const uint kernel_loops = data.kernel_loops;
2645
2646 // init speed timer
2647
2648 uint speed_pos = device_param->speed_pos;
2649
2650 #ifdef _POSIX
2651 if (device_param->timer_speed.tv_sec == 0)
2652 {
2653 hc_timer_set (&device_param->timer_speed);
2654 }
2655 #endif
2656
2657 #ifdef _WIN
2658 if (device_param->timer_speed.QuadPart == 0)
2659 {
2660 hc_timer_set (&device_param->timer_speed);
2661 }
2662 #endif
2663
2664 // find higest password length, this is for optimization stuff
2665
2666 uint highest_pw_len = 0;
2667
2668 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2669 {
2670 }
2671 else if (data.attack_kern == ATTACK_KERN_COMBI)
2672 {
2673 }
2674 else if (data.attack_kern == ATTACK_KERN_BF)
2675 {
2676 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2677 + device_param->kernel_params_mp_l_buf32[5];
2678 }
2679
2680 // bitslice optimization stuff
2681
2682 if (data.attack_mode == ATTACK_MODE_BF)
2683 {
2684 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2685 {
2686 run_kernel_tb (device_param, pws_cnt);
2687 }
2688 }
2689
2690 // iteration type
2691
2692 uint innerloop_step = 0;
2693 uint innerloop_cnt = 0;
2694
2695 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2696 else innerloop_step = 1;
2697
2698 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2699 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2700 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2701
2702 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2703
2704 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2705 {
2706 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2707
2708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2709
2710 if (data.devices_status == STATUS_CRACKED) break;
2711 if (data.devices_status == STATUS_ABORTED) break;
2712 if (data.devices_status == STATUS_QUIT) break;
2713 if (data.devices_status == STATUS_BYPASS) break;
2714
2715 if (data.salts_shown[salt_pos] == 1) continue;
2716
2717 salt_t *salt_buf = &data.salts_buf[salt_pos];
2718
2719 device_param->kernel_params_buf32[24] = salt_pos;
2720 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2721 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2722
2723 FILE *combs_fp = device_param->combs_fp;
2724
2725 if (data.attack_mode == ATTACK_MODE_COMBI)
2726 {
2727 rewind (combs_fp);
2728 }
2729
2730 // innerloops
2731
2732 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2733 {
2734 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2735
2736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2737
2738 if (data.devices_status == STATUS_CRACKED) break;
2739 if (data.devices_status == STATUS_ABORTED) break;
2740 if (data.devices_status == STATUS_QUIT) break;
2741 if (data.devices_status == STATUS_BYPASS) break;
2742
2743 uint innerloop_left = innerloop_cnt - innerloop_pos;
2744
2745 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2746
2747 device_param->innerloop_pos = innerloop_pos;
2748 device_param->innerloop_left = innerloop_left;
2749
2750 device_param->kernel_params_buf32[27] = innerloop_left;
2751
2752 if (innerloop_left == 0) continue;
2753
2754 // initialize amplifiers
2755
2756 if (data.attack_mode == ATTACK_MODE_COMBI)
2757 {
2758 char line_buf[BUFSIZ] = { 0 };
2759
2760 uint i = 0;
2761
2762 while (i < innerloop_left)
2763 {
2764 if (feof (combs_fp)) break;
2765
2766 int line_len = fgetl (combs_fp, line_buf);
2767
2768 if (line_len >= PW_MAX1) continue;
2769
2770 line_len = convert_from_hex (line_buf, line_len);
2771
2772 char *line_buf_new = line_buf;
2773
2774 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2775 {
2776 char rule_buf_out[BLOCK_SIZE] = { 0 };
2777
2778 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2779
2780 if (rule_len_out < 0)
2781 {
2782 data.words_progress_rejected[salt_pos] += pw_cnt;
2783
2784 continue;
2785 }
2786
2787 line_len = rule_len_out;
2788
2789 line_buf_new = rule_buf_out;
2790 }
2791
2792 line_len = MIN (line_len, PW_DICTMAX);
2793
2794 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2795
2796 memcpy (ptr, line_buf_new, line_len);
2797
2798 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2799
2800 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2801 {
2802 uppercase (ptr, line_len);
2803 }
2804
2805 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2806 {
2807 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2808 {
2809 ptr[line_len] = 0x80;
2810 }
2811
2812 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2813 {
2814 ptr[line_len] = 0x01;
2815 }
2816 }
2817
2818 device_param->combs_buf[i].pw_len = line_len;
2819
2820 i++;
2821 }
2822
2823 for (uint j = i; j < innerloop_left; j++)
2824 {
2825 device_param->combs_buf[j].i[0] = 0;
2826 device_param->combs_buf[j].i[1] = 0;
2827 device_param->combs_buf[j].i[2] = 0;
2828 device_param->combs_buf[j].i[3] = 0;
2829 device_param->combs_buf[j].i[4] = 0;
2830 device_param->combs_buf[j].i[5] = 0;
2831 device_param->combs_buf[j].i[6] = 0;
2832 device_param->combs_buf[j].i[7] = 0;
2833
2834 device_param->combs_buf[j].pw_len = 0;
2835 }
2836
2837 innerloop_left = i;
2838 }
2839 else if (data.attack_mode == ATTACK_MODE_BF)
2840 {
2841 u64 off = innerloop_pos;
2842
2843 device_param->kernel_params_mp_r_buf64[3] = off;
2844
2845 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2846 }
2847 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2848 {
2849 u64 off = innerloop_pos;
2850
2851 device_param->kernel_params_mp_buf64[3] = off;
2852
2853 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2854 }
2855 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2856 {
2857 u64 off = innerloop_pos;
2858
2859 device_param->kernel_params_mp_buf64[3] = off;
2860
2861 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2862 }
2863
2864 // copy amplifiers
2865
2866 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2867 {
2868 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2869 }
2870 else if (data.attack_mode == ATTACK_MODE_COMBI)
2871 {
2872 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2873 }
2874 else if (data.attack_mode == ATTACK_MODE_BF)
2875 {
2876 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2877 }
2878 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2879 {
2880 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2881 }
2882 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2883 {
2884 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2885 }
2886
2887 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2888 {
2889 if (data.attack_mode == ATTACK_MODE_BF)
2890 {
2891 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2892 {
2893 const uint size_tm = 32 * sizeof (bs_word_t);
2894
2895 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2896
2897 run_kernel_tm (device_param);
2898
2899 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2900 }
2901 }
2902
2903 if (highest_pw_len < 16)
2904 {
2905 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2906 }
2907 else if (highest_pw_len < 32)
2908 {
2909 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2910 }
2911 else
2912 {
2913 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2914 }
2915 }
2916 else
2917 {
2918 run_kernel_amp (device_param, pws_cnt);
2919
2920 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2921
2922 if (data.opts_type & OPTS_TYPE_HOOK12)
2923 {
2924 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2925 }
2926
2927 uint iter = salt_buf->salt_iter;
2928
2929 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2930 {
2931 uint loop_left = iter - loop_pos;
2932
2933 loop_left = MIN (loop_left, kernel_loops);
2934
2935 device_param->kernel_params_buf32[25] = loop_pos;
2936 device_param->kernel_params_buf32[26] = loop_left;
2937
2938 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2939
2940 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2941
2942 if (data.devices_status == STATUS_CRACKED) break;
2943 if (data.devices_status == STATUS_ABORTED) break;
2944 if (data.devices_status == STATUS_QUIT) break;
2945 }
2946
2947 if (data.opts_type & OPTS_TYPE_HOOK23)
2948 {
2949 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2950
2951 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2952
2953 // do something with data
2954
2955 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2956 }
2957
2958 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2959 }
2960
2961 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2962
2963 if (data.devices_status == STATUS_CRACKED) break;
2964 if (data.devices_status == STATUS_ABORTED) break;
2965 if (data.devices_status == STATUS_QUIT) break;
2966
2967 /**
2968 * result
2969 */
2970
2971 hc_thread_mutex_lock (mux_display);
2972
2973 check_cracked (device_param, salt_pos);
2974
2975 hc_thread_mutex_unlock (mux_display);
2976
2977 /**
2978 * progress
2979 */
2980
2981 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2982
2983 hc_thread_mutex_lock (mux_counter);
2984
2985 data.words_progress_done[salt_pos] += perf_sum_all;
2986
2987 hc_thread_mutex_unlock (mux_counter);
2988
2989 /**
2990 * speed
2991 */
2992
2993 float speed_ms;
2994
2995 hc_timer_get (device_param->timer_speed, speed_ms);
2996
2997 hc_timer_set (&device_param->timer_speed);
2998
2999 hc_thread_mutex_lock (mux_display);
3000
3001 device_param->speed_cnt[speed_pos] = perf_sum_all;
3002
3003 device_param->speed_ms[speed_pos] = speed_ms;
3004
3005 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3006
3007 hc_thread_mutex_unlock (mux_display);
3008
3009 speed_pos++;
3010
3011 if (speed_pos == SPEED_CACHE)
3012 {
3013 speed_pos = 0;
3014 }
3015 }
3016 }
3017
3018 device_param->speed_pos = speed_pos;
3019 }
3020
3021 static void load_segment (wl_data_t *wl_data, FILE *fd)
3022 {
3023 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3024
3025 wl_data->pos = 0;
3026
3027 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3028
3029 wl_data->buf[wl_data->cnt] = 0;
3030
3031 if (wl_data->cnt == 0) return;
3032
3033 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3034
3035 while (!feof (fd))
3036 {
3037 if (wl_data->cnt == wl_data->avail)
3038 {
3039 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3040
3041 wl_data->avail += wl_data->incr;
3042 }
3043
3044 const int c = fgetc (fd);
3045
3046 if (c == EOF) break;
3047
3048 wl_data->buf[wl_data->cnt] = (char) c;
3049
3050 wl_data->cnt++;
3051
3052 if (c == '\n') break;
3053 }
3054
3055 // ensure stream ends with a newline
3056
3057 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3058 {
3059 wl_data->cnt++;
3060
3061 wl_data->buf[wl_data->cnt - 1] = '\n';
3062 }
3063
3064 return;
3065 }
3066
3067 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3068 {
3069 char *ptr = buf;
3070
3071 for (u32 i = 0; i < sz; i++, ptr++)
3072 {
3073 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3074
3075 if (i == 7)
3076 {
3077 *off = i;
3078 *len = i;
3079
3080 return;
3081 }
3082
3083 if (*ptr != '\n') continue;
3084
3085 *off = i + 1;
3086
3087 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3088
3089 *len = i;
3090
3091 return;
3092 }
3093
3094 *off = sz;
3095 *len = sz;
3096 }
3097
3098 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3099 {
3100 char *ptr = buf;
3101
3102 for (u32 i = 0; i < sz; i++, ptr++)
3103 {
3104 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3105
3106 if (*ptr != '\n') continue;
3107
3108 *off = i + 1;
3109
3110 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3111
3112 *len = i;
3113
3114 return;
3115 }
3116
3117 *off = sz;
3118 *len = sz;
3119 }
3120
3121 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3122 {
3123 char *ptr = buf;
3124
3125 for (u32 i = 0; i < sz; i++, ptr++)
3126 {
3127 if (*ptr != '\n') continue;
3128
3129 *off = i + 1;
3130
3131 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3132
3133 *len = i;
3134
3135 return;
3136 }
3137
3138 *off = sz;
3139 *len = sz;
3140 }
3141
3142 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3143 {
3144 while (wl_data->pos < wl_data->cnt)
3145 {
3146 uint off;
3147 uint len;
3148
3149 char *ptr = wl_data->buf + wl_data->pos;
3150
3151 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3152
3153 wl_data->pos += off;
3154
3155 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3156 {
3157 char rule_buf_out[BLOCK_SIZE] = { 0 };
3158
3159 int rule_len_out = -1;
3160
3161 if (len < BLOCK_SIZE)
3162 {
3163 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3164 }
3165
3166 if (rule_len_out < 0)
3167 {
3168 continue;
3169 }
3170
3171 if (rule_len_out > PW_MAX)
3172 {
3173 continue;
3174 }
3175 }
3176 else
3177 {
3178 if (len > PW_MAX)
3179 {
3180 continue;
3181 }
3182 }
3183
3184 *out_buf = ptr;
3185 *out_len = len;
3186
3187 return;
3188 }
3189
3190 if (feof (fd))
3191 {
3192 fprintf (stderr, "bug!!\n");
3193
3194 return;
3195 }
3196
3197 load_segment (wl_data, fd);
3198
3199 get_next_word (wl_data, fd, out_buf, out_len);
3200 }
3201
3202 #ifdef _POSIX
3203 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3204 #endif
3205
3206 #ifdef _WIN
3207 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3208 #endif
3209 {
3210 hc_signal (NULL);
3211
3212 dictstat_t d;
3213
3214 d.cnt = 0;
3215
3216 #ifdef _POSIX
3217 fstat (fileno (fd), &d.stat);
3218 #endif
3219
3220 #ifdef _WIN
3221 _fstat64 (fileno (fd), &d.stat);
3222 #endif
3223
3224 d.stat.st_mode = 0;
3225 d.stat.st_nlink = 0;
3226 d.stat.st_uid = 0;
3227 d.stat.st_gid = 0;
3228 d.stat.st_rdev = 0;
3229 d.stat.st_atime = 0;
3230
3231 #ifdef _POSIX
3232 d.stat.st_blksize = 0;
3233 d.stat.st_blocks = 0;
3234 #endif
3235
3236 if (d.stat.st_size == 0) return 0;
3237
3238 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3239
3240 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3241 {
3242 if (d_cache)
3243 {
3244 u64 cnt = d_cache->cnt;
3245
3246 u64 keyspace = cnt;
3247
3248 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3249 {
3250 keyspace *= data.kernel_rules_cnt;
3251 }
3252 else if (data.attack_kern == ATTACK_KERN_COMBI)
3253 {
3254 keyspace *= data.combs_cnt;
3255 }
3256
3257 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3258 if (data.quiet == 0) log_info ("");
3259
3260 hc_signal (sigHandler_default);
3261
3262 return (keyspace);
3263 }
3264 }
3265
3266 time_t now = 0;
3267 time_t prev = 0;
3268
3269 u64 comp = 0;
3270 u64 cnt = 0;
3271 u64 cnt2 = 0;
3272
3273 while (!feof (fd))
3274 {
3275 load_segment (wl_data, fd);
3276
3277 comp += wl_data->cnt;
3278
3279 u32 i = 0;
3280
3281 while (i < wl_data->cnt)
3282 {
3283 u32 len;
3284 u32 off;
3285
3286 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3287
3288 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3289 {
3290 char rule_buf_out[BLOCK_SIZE] = { 0 };
3291
3292 int rule_len_out = -1;
3293
3294 if (len < BLOCK_SIZE)
3295 {
3296 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3297 }
3298
3299 if (rule_len_out < 0)
3300 {
3301 len = PW_MAX1;
3302 }
3303 else
3304 {
3305 len = rule_len_out;
3306 }
3307 }
3308
3309 if (len < PW_MAX1)
3310 {
3311 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3312 {
3313 cnt += data.kernel_rules_cnt;
3314 }
3315 else if (data.attack_kern == ATTACK_KERN_COMBI)
3316 {
3317 cnt += data.combs_cnt;
3318 }
3319
3320 d.cnt++;
3321 }
3322
3323 i += off;
3324
3325 cnt2++;
3326 }
3327
3328 time (&now);
3329
3330 if ((now - prev) == 0) continue;
3331
3332 float percent = (float) comp / (float) d.stat.st_size;
3333
3334 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3335
3336 time (&prev);
3337 }
3338
3339 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3340 if (data.quiet == 0) log_info ("");
3341
3342 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3343
3344 hc_signal (sigHandler_default);
3345
3346 return (cnt);
3347 }
3348
3349 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3350 {
3351 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3352 }
3353
3354 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3355 {
3356 if (data.devices_status == STATUS_BYPASS) return 0;
3357
3358 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3359
3360 uint cache_cnt = pw_cache->cnt;
3361
3362 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3363
3364 memcpy (pw_hc1, pw_buf, pw_len);
3365
3366 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3367
3368 uint pws_cnt = device_param->pws_cnt;
3369
3370 cache_cnt++;
3371
3372 pw_t *pw = device_param->pws_buf + pws_cnt;
3373
3374 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3375
3376 pw->pw_len = pw_len;
3377
3378 pws_cnt++;
3379
3380 device_param->pws_cnt = pws_cnt;
3381 device_param->pw_cnt = pws_cnt * 1;
3382
3383 cache_cnt = 0;
3384
3385 pw_cache->cnt = cache_cnt;
3386
3387 return pws_cnt;
3388 }
3389
3390 static void *thread_monitor (void *p)
3391 {
3392 uint runtime_check = 0;
3393 uint remove_check = 0;
3394 uint status_check = 0;
3395 uint restore_check = 0;
3396
3397 uint restore_left = data.restore_timer;
3398 uint remove_left = data.remove_timer;
3399 uint status_left = data.status_timer;
3400
3401 #ifdef HAVE_HWMON
3402 uint hwmon_check = 0;
3403
3404 // these variables are mainly used for fan control (AMD only)
3405
3406 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3407
3408 // temperature controller "loopback" values
3409
3410 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3411 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3412
3413 #ifdef HAVE_ADL
3414 int temp_threshold = 1; // degrees celcius
3415
3416 int fan_speed_min = 15; // in percentage
3417 int fan_speed_max = 100;
3418 #endif // HAVE_ADL
3419
3420 time_t last_temp_check_time;
3421 #endif // HAVE_HWMON
3422
3423 uint sleep_time = 1;
3424
3425 if (data.runtime)
3426 {
3427 runtime_check = 1;
3428 }
3429
3430 if (data.restore_timer)
3431 {
3432 restore_check = 1;
3433 }
3434
3435 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3436 {
3437 remove_check = 1;
3438 }
3439
3440 if (data.status == 1)
3441 {
3442 status_check = 1;
3443 }
3444
3445 #ifdef HAVE_HWMON
3446 if (data.gpu_temp_disable == 0)
3447 {
3448 time (&last_temp_check_time);
3449
3450 hwmon_check = 1;
3451 }
3452 #endif
3453
3454 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3455 {
3456 #ifdef HAVE_HWMON
3457 if (hwmon_check == 0)
3458 #endif
3459 return (p);
3460 }
3461
3462 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3463 {
3464 hc_sleep (sleep_time);
3465
3466 if (data.devices_status != STATUS_RUNNING) continue;
3467
3468 #ifdef HAVE_HWMON
3469 if (hwmon_check == 1)
3470 {
3471 hc_thread_mutex_lock (mux_adl);
3472
3473 time_t temp_check_time;
3474
3475 time (&temp_check_time);
3476
3477 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3478
3479 if (Ta == 0) Ta = 1;
3480
3481 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3482 {
3483 hc_device_param_t *device_param = &data.devices_param[device_id];
3484
3485 if (device_param->skipped) continue;
3486
3487 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3488
3489 const int temperature = hm_get_temperature_with_device_id (device_id);
3490
3491 if (temperature > (int) data.gpu_temp_abort)
3492 {
3493 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3494
3495 if (data.devices_status != STATUS_QUIT) myabort ();
3496
3497 break;
3498 }
3499
3500 #ifdef HAVE_ADL
3501 const int gpu_temp_retain = data.gpu_temp_retain;
3502
3503 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3504 {
3505 if (data.hm_device[device_id].fan_supported == 1)
3506 {
3507 int temp_cur = temperature;
3508
3509 int temp_diff_new = gpu_temp_retain - temp_cur;
3510
3511 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3512
3513 // calculate Ta value (time difference in seconds between the last check and this check)
3514
3515 last_temp_check_time = temp_check_time;
3516
3517 float Kp = 1.8;
3518 float Ki = 0.005;
3519 float Kd = 6;
3520
3521 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3522
3523 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3524
3525 if (abs (fan_diff_required) >= temp_threshold)
3526 {
3527 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3528
3529 int fan_speed_level = fan_speed_cur;
3530
3531 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3532
3533 int fan_speed_new = fan_speed_level - fan_diff_required;
3534
3535 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3536 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3537
3538 if (fan_speed_new != fan_speed_cur)
3539 {
3540 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3541 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3542
3543 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3544 {
3545 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3546
3547 fan_speed_chgd[device_id] = 1;
3548 }
3549
3550 temp_diff_old[device_id] = temp_diff_new;
3551 }
3552 }
3553 }
3554 }
3555 #endif // HAVE_ADL
3556 }
3557
3558 hc_thread_mutex_unlock (mux_adl);
3559 }
3560 #endif // HAVE_HWMON
3561
3562 if (restore_check == 1)
3563 {
3564 restore_left--;
3565
3566 if (restore_left == 0)
3567 {
3568 if (data.restore_disable == 0) cycle_restore ();
3569
3570 restore_left = data.restore_timer;
3571 }
3572 }
3573
3574 if ((runtime_check == 1) && (data.runtime_start > 0))
3575 {
3576 time_t runtime_cur;
3577
3578 time (&runtime_cur);
3579
3580 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3581
3582 if (runtime_left <= 0)
3583 {
3584 if (data.benchmark == 0)
3585 {
3586 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3587 }
3588
3589 if (data.devices_status != STATUS_QUIT) myabort ();
3590 }
3591 }
3592
3593 if (remove_check == 1)
3594 {
3595 remove_left--;
3596
3597 if (remove_left == 0)
3598 {
3599 if (data.digests_saved != data.digests_done)
3600 {
3601 data.digests_saved = data.digests_done;
3602
3603 save_hash ();
3604 }
3605
3606 remove_left = data.remove_timer;
3607 }
3608 }
3609
3610 if (status_check == 1)
3611 {
3612 status_left--;
3613
3614 if (status_left == 0)
3615 {
3616 hc_thread_mutex_lock (mux_display);
3617
3618 if (data.quiet == 0) clear_prompt ();
3619
3620 if (data.quiet == 0) log_info ("");
3621
3622 status_display ();
3623
3624 if (data.quiet == 0) log_info ("");
3625
3626 hc_thread_mutex_unlock (mux_display);
3627
3628 status_left = data.status_timer;
3629 }
3630 }
3631 }
3632
3633 #ifdef HAVE_HWMON
3634 myfree (fan_speed_chgd);
3635
3636 myfree (temp_diff_old);
3637 myfree (temp_diff_sum);
3638 #endif
3639
3640 p = NULL;
3641
3642 return (p);
3643 }
3644
3645 static void *thread_outfile_remove (void *p)
3646 {
3647 // some hash-dependent constants
3648 char *outfile_dir = data.outfile_check_directory;
3649 uint dgst_size = data.dgst_size;
3650 uint isSalted = data.isSalted;
3651 uint esalt_size = data.esalt_size;
3652 uint hash_mode = data.hash_mode;
3653
3654 uint outfile_check_timer = data.outfile_check_timer;
3655
3656 char separator = data.separator;
3657
3658 // some hash-dependent functions
3659 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3660 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3661
3662 // buffers
3663 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3664
3665 hash_buf.digest = mymalloc (dgst_size);
3666
3667 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3668
3669 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3670
3671 uint digest_buf[64] = { 0 };
3672
3673 outfile_data_t *out_info = NULL;
3674
3675 char **out_files = NULL;
3676
3677 time_t folder_mtime = 0;
3678
3679 int out_cnt = 0;
3680
3681 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3682
3683 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3684 {
3685 hc_sleep (1);
3686
3687 if (data.devices_status != STATUS_RUNNING) continue;
3688
3689 check_left--;
3690
3691 if (check_left == 0)
3692 {
3693 struct stat outfile_check_stat;
3694
3695 if (stat (outfile_dir, &outfile_check_stat) == 0)
3696 {
3697 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3698
3699 if (is_dir == 1)
3700 {
3701 if (outfile_check_stat.st_mtime > folder_mtime)
3702 {
3703 char **out_files_new = scan_directory (outfile_dir);
3704
3705 int out_cnt_new = count_dictionaries (out_files_new);
3706
3707 outfile_data_t *out_info_new = NULL;
3708
3709 if (out_cnt_new > 0)
3710 {
3711 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3712
3713 for (int i = 0; i < out_cnt_new; i++)
3714 {
3715 out_info_new[i].file_name = out_files_new[i];
3716
3717 // check if there are files that we have seen/checked before (and not changed)
3718
3719 for (int j = 0; j < out_cnt; j++)
3720 {
3721 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3722 {
3723 struct stat outfile_stat;
3724
3725 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3726 {
3727 if (outfile_stat.st_ctime == out_info[j].ctime)
3728 {
3729 out_info_new[i].ctime = out_info[j].ctime;
3730 out_info_new[i].seek = out_info[j].seek;
3731 }
3732 }
3733 }
3734 }
3735 }
3736 }
3737
3738 local_free (out_info);
3739 local_free (out_files);
3740
3741 out_files = out_files_new;
3742 out_cnt = out_cnt_new;
3743 out_info = out_info_new;
3744
3745 folder_mtime = outfile_check_stat.st_mtime;
3746 }
3747
3748 for (int j = 0; j < out_cnt; j++)
3749 {
3750 FILE *fp = fopen (out_info[j].file_name, "rb");
3751
3752 if (fp != NULL)
3753 {
3754 //hc_thread_mutex_lock (mux_display);
3755
3756 #ifdef _POSIX
3757 struct stat outfile_stat;
3758
3759 fstat (fileno (fp), &outfile_stat);
3760 #endif
3761
3762 #ifdef _WIN
3763 struct stat64 outfile_stat;
3764
3765 _fstat64 (fileno (fp), &outfile_stat);
3766 #endif
3767
3768 if (outfile_stat.st_ctime > out_info[j].ctime)
3769 {
3770 out_info[j].ctime = outfile_stat.st_ctime;
3771 out_info[j].seek = 0;
3772 }
3773
3774 fseek (fp, out_info[j].seek, SEEK_SET);
3775
3776 while (!feof (fp))
3777 {
3778 char line_buf[BUFSIZ] = { 0 };
3779
3780 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3781
3782 if (ptr == NULL) break;
3783
3784 int line_len = strlen (line_buf);
3785
3786 if (line_len <= 0) continue;
3787
3788 int iter = MAX_CUT_TRIES;
3789
3790 for (uint i = line_len - 1; i && iter; i--, line_len--)
3791 {
3792 if (line_buf[i] != separator) continue;
3793
3794 int parser_status = PARSER_OK;
3795
3796 if ((hash_mode != 2500) && (hash_mode != 6800))
3797 {
3798 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3799 }
3800
3801 uint found = 0;
3802
3803 if (parser_status == PARSER_OK)
3804 {
3805 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3806 {
3807 if (data.salts_shown[salt_pos] == 1) continue;
3808
3809 salt_t *salt_buf = &data.salts_buf[salt_pos];
3810
3811 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3812 {
3813 uint idx = salt_buf->digests_offset + digest_pos;
3814
3815 if (data.digests_shown[idx] == 1) continue;
3816
3817 uint cracked = 0;
3818
3819 if (hash_mode == 6800)
3820 {
3821 if (i == salt_buf->salt_len)
3822 {
3823 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3824 }
3825 }
3826 else if (hash_mode == 2500)
3827 {
3828 // BSSID : MAC1 : MAC2 (:plain)
3829 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3830 {
3831 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3832
3833 if (!cracked) continue;
3834
3835 // now compare MAC1 and MAC2 too, since we have this additional info
3836 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3837 char *mac2_pos = mac1_pos + 12 + 1;
3838
3839 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3840 wpa_t *wpa = &wpas[salt_pos];
3841
3842 uint pke[25] = { 0 };
3843
3844 char *pke_ptr = (char *) pke;
3845
3846 for (uint i = 0; i < 25; i++)
3847 {
3848 pke[i] = byte_swap_32 (wpa->pke[i]);
3849 }
3850
3851 u8 mac1[6] = { 0 };
3852 u8 mac2[6] = { 0 };
3853
3854 memcpy (mac1, pke_ptr + 23, 6);
3855 memcpy (mac2, pke_ptr + 29, 6);
3856
3857 // compare hex string(s) vs binary MAC address(es)
3858
3859 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3860 {
3861 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3862 {
3863 cracked = 0;
3864 break;
3865 }
3866 }
3867
3868 // early skip ;)
3869 if (!cracked) continue;
3870
3871 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3872 {
3873 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3874 {
3875 cracked = 0;
3876 break;
3877 }
3878 }
3879 }
3880 }
3881 else
3882 {
3883 char *digests_buf_ptr = (char *) data.digests_buf;
3884
3885 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3886
3887 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3888 }
3889
3890 if (cracked == 1)
3891 {
3892 found = 1;
3893
3894 data.digests_shown[idx] = 1;
3895
3896 data.digests_done++;
3897
3898 salt_buf->digests_done++;
3899
3900 if (salt_buf->digests_done == salt_buf->digests_cnt)
3901 {
3902 data.salts_shown[salt_pos] = 1;
3903
3904 data.salts_done++;
3905
3906 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3907 }
3908 }
3909 }
3910
3911 if (data.devices_status == STATUS_CRACKED) break;
3912 }
3913 }
3914
3915 if (found) break;
3916
3917 if (data.devices_status == STATUS_CRACKED) break;
3918
3919 iter--;
3920 }
3921
3922 if (data.devices_status == STATUS_CRACKED) break;
3923 }
3924
3925 out_info[j].seek = ftell (fp);
3926
3927 //hc_thread_mutex_unlock (mux_display);
3928
3929 fclose (fp);
3930 }
3931 }
3932 }
3933 }
3934
3935 check_left = outfile_check_timer;
3936 }
3937 }
3938
3939 if (esalt_size) local_free (hash_buf.esalt);
3940
3941 if (isSalted) local_free (hash_buf.salt);
3942
3943 local_free (hash_buf.digest);
3944
3945 local_free (out_info);
3946
3947 local_free (out_files);
3948
3949 p = NULL;
3950
3951 return (p);
3952 }
3953
3954 static uint get_work (hc_device_param_t *device_param, const u64 max)
3955 {
3956 hc_thread_mutex_lock (mux_dispatcher);
3957
3958 const u64 words_cur = data.words_cur;
3959 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3960
3961 device_param->words_off = words_cur;
3962
3963 const u64 words_left = words_base - words_cur;
3964
3965 if (data.kernel_blocks_all > words_left)
3966 {
3967 if (data.kernel_blocks_div == 0)
3968 {
3969 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3970 }
3971 }
3972
3973 if (data.kernel_blocks_div)
3974 {
3975 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3976 {
3977 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3978 const u32 kernel_power_new = kernel_blocks_new;
3979
3980 if (kernel_blocks_new < device_param->kernel_blocks)
3981 {
3982 device_param->kernel_blocks = kernel_blocks_new;
3983 device_param->kernel_power = kernel_power_new;
3984 }
3985 }
3986 }
3987
3988 const uint kernel_blocks = device_param->kernel_blocks;
3989
3990 uint work = MIN (words_left, kernel_blocks);
3991
3992 work = MIN (work, max);
3993
3994 data.words_cur += work;
3995
3996 hc_thread_mutex_unlock (mux_dispatcher);
3997
3998 return work;
3999 }
4000
4001 static void *thread_calc_stdin (void *p)
4002 {
4003 hc_device_param_t *device_param = (hc_device_param_t *) p;
4004
4005 if (device_param->skipped) return NULL;
4006
4007 const uint attack_kern = data.attack_kern;
4008
4009 const uint kernel_blocks = device_param->kernel_blocks;
4010
4011 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4012 {
4013 hc_thread_mutex_lock (mux_dispatcher);
4014
4015 if (feof (stdin) != 0)
4016 {
4017 hc_thread_mutex_unlock (mux_dispatcher);
4018
4019 break;
4020 }
4021
4022 uint words_cur = 0;
4023
4024 while (words_cur < kernel_blocks)
4025 {
4026 char buf[BUFSIZ] = { 0 };
4027
4028 char *line_buf = fgets (buf, sizeof (buf), stdin);
4029
4030 if (line_buf == NULL) break;
4031
4032 uint line_len = in_superchop (line_buf);
4033
4034 line_len = convert_from_hex (line_buf, line_len);
4035
4036 // post-process rule engine
4037
4038 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4039 {
4040 char rule_buf_out[BLOCK_SIZE] = { 0 };
4041
4042 int rule_len_out = -1;
4043
4044 if (line_len < BLOCK_SIZE)
4045 {
4046 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4047 }
4048
4049 if (rule_len_out < 0) continue;
4050
4051 line_buf = rule_buf_out;
4052 line_len = rule_len_out;
4053 }
4054
4055 if (line_len > PW_MAX)
4056 {
4057 continue;
4058 }
4059
4060 if (attack_kern == ATTACK_KERN_STRAIGHT)
4061 {
4062 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4063 {
4064 hc_thread_mutex_lock (mux_counter);
4065
4066 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4067 {
4068 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4069 }
4070
4071 hc_thread_mutex_unlock (mux_counter);
4072
4073 continue;
4074 }
4075 }
4076 else if (attack_kern == ATTACK_KERN_COMBI)
4077 {
4078 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4079 // since we still need to combine the plains
4080
4081 if (line_len > data.pw_max)
4082 {
4083 hc_thread_mutex_lock (mux_counter);
4084
4085 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4086 {
4087 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4088 }
4089
4090 hc_thread_mutex_unlock (mux_counter);
4091
4092 continue;
4093 }
4094 }
4095
4096 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4097
4098 words_cur++;
4099
4100 if (data.devices_status == STATUS_CRACKED) break;
4101 if (data.devices_status == STATUS_ABORTED) break;
4102 if (data.devices_status == STATUS_QUIT) break;
4103 if (data.devices_status == STATUS_BYPASS) break;
4104 }
4105
4106 hc_thread_mutex_unlock (mux_dispatcher);
4107
4108 if (data.devices_status == STATUS_CRACKED) break;
4109 if (data.devices_status == STATUS_ABORTED) break;
4110 if (data.devices_status == STATUS_QUIT) break;
4111 if (data.devices_status == STATUS_BYPASS) break;
4112
4113 // we need 2 flushing because we have two independant caches and it can occur
4114 // that one buffer is already at threshold plus for that length also exists
4115 // more data in the 2nd buffer so it would overflow
4116
4117 // flush session 1
4118
4119 {
4120 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4121 {
4122 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4123
4124 const uint pw_cache_cnt = pw_cache->cnt;
4125
4126 if (pw_cache_cnt == 0) continue;
4127
4128 pw_cache->cnt = 0;
4129
4130 uint pws_cnt = device_param->pws_cnt;
4131
4132 pw_t *pw = device_param->pws_buf + pws_cnt;
4133
4134 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4135
4136 pw->pw_len = pw_len;
4137
4138 uint pw_cnt = device_param->pw_cnt;
4139
4140 pw_cnt += pw_cache_cnt;
4141
4142 device_param->pw_cnt = pw_cnt;
4143
4144 pws_cnt++;
4145
4146 device_param->pws_cnt = pws_cnt;
4147
4148 if (pws_cnt == device_param->kernel_power_user) break;
4149 }
4150
4151 const uint pw_cnt = device_param->pw_cnt;
4152 const uint pws_cnt = device_param->pws_cnt;
4153
4154 if (pws_cnt)
4155 {
4156 run_copy (device_param, pws_cnt);
4157
4158 run_cracker (device_param, pw_cnt, pws_cnt);
4159
4160 device_param->pw_cnt = 0;
4161 device_param->pws_cnt = 0;
4162 }
4163 }
4164
4165 // flush session 2
4166
4167 {
4168 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4169 {
4170 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4171
4172 const uint pw_cache_cnt = pw_cache->cnt;
4173
4174 if (pw_cache_cnt == 0) continue;
4175
4176 pw_cache->cnt = 0;
4177
4178 uint pws_cnt = device_param->pws_cnt;
4179
4180 pw_t *pw = device_param->pws_buf + pws_cnt;
4181
4182 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4183
4184 pw->pw_len = pw_len;
4185
4186 uint pw_cnt = device_param->pw_cnt;
4187
4188 pw_cnt += pw_cache_cnt;
4189
4190 device_param->pw_cnt = pw_cnt;
4191
4192 pws_cnt++;
4193
4194 device_param->pws_cnt = pws_cnt;
4195 }
4196
4197 const uint pw_cnt = device_param->pw_cnt;
4198 const uint pws_cnt = device_param->pws_cnt;
4199
4200 if (pws_cnt)
4201 {
4202 run_copy (device_param, pws_cnt);
4203
4204 run_cracker (device_param, pw_cnt, pws_cnt);
4205
4206 device_param->pw_cnt = 0;
4207 device_param->pws_cnt = 0;
4208 }
4209 }
4210 }
4211
4212 return NULL;
4213 }
4214
4215 static void *thread_calc (void *p)
4216 {
4217 hc_device_param_t *device_param = (hc_device_param_t *) p;
4218
4219 if (device_param->skipped) return NULL;
4220
4221 const uint attack_mode = data.attack_mode;
4222 const uint attack_kern = data.attack_kern;
4223
4224 if (attack_mode == ATTACK_MODE_BF)
4225 {
4226 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4227 {
4228 const uint work = get_work (device_param, -1);
4229
4230 if (work == 0) break;
4231
4232 const u64 words_off = device_param->words_off;
4233 const u64 words_fin = words_off + work;
4234
4235 const uint pw_cnt = work;
4236 const uint pws_cnt = work;
4237
4238 device_param->pw_cnt = pw_cnt;
4239 device_param->pws_cnt = pws_cnt;
4240
4241 if (pws_cnt)
4242 {
4243 run_copy (device_param, pws_cnt);
4244
4245 run_cracker (device_param, pw_cnt, pws_cnt);
4246
4247 device_param->pw_cnt = 0;
4248 device_param->pws_cnt = 0;
4249 }
4250
4251 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4252
4253 if (data.devices_status == STATUS_CRACKED) break;
4254 if (data.devices_status == STATUS_ABORTED) break;
4255 if (data.devices_status == STATUS_QUIT) break;
4256 if (data.devices_status == STATUS_BYPASS) break;
4257
4258 device_param->words_done = words_fin;
4259 }
4260 }
4261 else
4262 {
4263 const uint segment_size = data.segment_size;
4264
4265 char *dictfile = data.dictfile;
4266
4267 if (attack_mode == ATTACK_MODE_COMBI)
4268 {
4269 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4270 {
4271 dictfile = data.dictfile2;
4272 }
4273 }
4274
4275 FILE *fd = fopen (dictfile, "rb");
4276
4277 if (fd == NULL)
4278 {
4279 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4280
4281 return NULL;
4282 }
4283
4284 if (attack_mode == ATTACK_MODE_COMBI)
4285 {
4286 const uint combs_mode = data.combs_mode;
4287
4288 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4289 {
4290 const char *dictfilec = data.dictfile2;
4291
4292 FILE *combs_fp = fopen (dictfilec, "rb");
4293
4294 if (combs_fp == NULL)
4295 {
4296 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4297
4298 fclose (fd);
4299
4300 return NULL;
4301 }
4302
4303 device_param->combs_fp = combs_fp;
4304 }
4305 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4306 {
4307 const char *dictfilec = data.dictfile;
4308
4309 FILE *combs_fp = fopen (dictfilec, "rb");
4310
4311 if (combs_fp == NULL)
4312 {
4313 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4314
4315 fclose (fd);
4316
4317 return NULL;
4318 }
4319
4320 device_param->combs_fp = combs_fp;
4321 }
4322 }
4323
4324 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4325
4326 wl_data->buf = (char *) mymalloc (segment_size);
4327 wl_data->avail = segment_size;
4328 wl_data->incr = segment_size;
4329 wl_data->cnt = 0;
4330 wl_data->pos = 0;
4331
4332 u64 words_cur = 0;
4333
4334 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4335 {
4336 u64 words_off = 0;
4337 u64 words_fin = 0;
4338
4339 u64 max = -1;
4340
4341 while (max)
4342 {
4343 const uint work = get_work (device_param, max);
4344
4345 if (work == 0) break;
4346
4347 words_off = device_param->words_off;
4348 words_fin = words_off + work;
4349
4350 char *line_buf;
4351 uint line_len;
4352
4353 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4354
4355 max = 0;
4356
4357 for ( ; words_cur < words_fin; words_cur++)
4358 {
4359 get_next_word (wl_data, fd, &line_buf, &line_len);
4360
4361 line_len = convert_from_hex (line_buf, line_len);
4362
4363 // post-process rule engine
4364
4365 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4366 {
4367 char rule_buf_out[BLOCK_SIZE] = { 0 };
4368
4369 int rule_len_out = -1;
4370
4371 if (line_len < BLOCK_SIZE)
4372 {
4373 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4374 }
4375
4376 if (rule_len_out < 0) continue;
4377
4378 line_buf = rule_buf_out;
4379 line_len = rule_len_out;
4380 }
4381
4382 if (attack_kern == ATTACK_KERN_STRAIGHT)
4383 {
4384 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4385 {
4386 max++;
4387
4388 hc_thread_mutex_lock (mux_counter);
4389
4390 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4391 {
4392 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4393 }
4394
4395 hc_thread_mutex_unlock (mux_counter);
4396
4397 continue;
4398 }
4399 }
4400 else if (attack_kern == ATTACK_KERN_COMBI)
4401 {
4402 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4403 // since we still need to combine the plains
4404
4405 if (line_len > data.pw_max)
4406 {
4407 max++;
4408
4409 hc_thread_mutex_lock (mux_counter);
4410
4411 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4412 {
4413 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4414 }
4415
4416 hc_thread_mutex_unlock (mux_counter);
4417
4418 continue;
4419 }
4420 }
4421
4422 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4423
4424 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4425
4426 if (data.devices_status == STATUS_CRACKED) break;
4427 if (data.devices_status == STATUS_ABORTED) break;
4428 if (data.devices_status == STATUS_QUIT) break;
4429 if (data.devices_status == STATUS_BYPASS) break;
4430 }
4431
4432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438 }
4439
4440 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4441
4442 if (data.devices_status == STATUS_CRACKED) break;
4443 if (data.devices_status == STATUS_ABORTED) break;
4444 if (data.devices_status == STATUS_QUIT) break;
4445 if (data.devices_status == STATUS_BYPASS) break;
4446
4447 // we need 2 flushing because we have two independant caches and it can occur
4448 // that one buffer is already at threshold plus for that length also exists
4449 // more data in the 2nd buffer so it would overflow
4450
4451 //
4452 // flush session 1
4453 //
4454
4455 {
4456 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4457 {
4458 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4459
4460 const uint pw_cache_cnt = pw_cache->cnt;
4461
4462 if (pw_cache_cnt == 0) continue;
4463
4464 pw_cache->cnt = 0;
4465
4466 uint pws_cnt = device_param->pws_cnt;
4467
4468 pw_t *pw = device_param->pws_buf + pws_cnt;
4469
4470 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4471
4472 pw->pw_len = pw_len;
4473
4474 uint pw_cnt = device_param->pw_cnt;
4475
4476 pw_cnt += pw_cache_cnt;
4477
4478 device_param->pw_cnt = pw_cnt;
4479
4480 pws_cnt++;
4481
4482 device_param->pws_cnt = pws_cnt;
4483
4484 if (pws_cnt == device_param->kernel_power_user) break;
4485 }
4486
4487 const uint pw_cnt = device_param->pw_cnt;
4488 const uint pws_cnt = device_param->pws_cnt;
4489
4490 if (pws_cnt)
4491 {
4492 run_copy (device_param, pws_cnt);
4493
4494 run_cracker (device_param, pw_cnt, pws_cnt);
4495
4496 device_param->pw_cnt = 0;
4497 device_param->pws_cnt = 0;
4498 }
4499
4500 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4501
4502 if (data.devices_status == STATUS_CRACKED) break;
4503 if (data.devices_status == STATUS_ABORTED) break;
4504 if (data.devices_status == STATUS_QUIT) break;
4505 if (data.devices_status == STATUS_BYPASS) break;
4506 }
4507
4508 //
4509 // flush session 2
4510 //
4511
4512 {
4513 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4514 {
4515 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4516
4517 const uint pw_cache_cnt = pw_cache->cnt;
4518
4519 if (pw_cache_cnt == 0) continue;
4520
4521 pw_cache->cnt = 0;
4522
4523 uint pws_cnt = device_param->pws_cnt;
4524
4525 pw_t *pw = device_param->pws_buf + pws_cnt;
4526
4527 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4528
4529 pw->pw_len = pw_len;
4530
4531 uint pw_cnt = device_param->pw_cnt;
4532
4533 pw_cnt += pw_cache_cnt;
4534
4535 device_param->pw_cnt = pw_cnt;
4536
4537 pws_cnt++;
4538
4539 device_param->pws_cnt = pws_cnt;
4540 }
4541
4542 const uint pw_cnt = device_param->pw_cnt;
4543 const uint pws_cnt = device_param->pws_cnt;
4544
4545 if (pws_cnt)
4546 {
4547 run_copy (device_param, pws_cnt);
4548
4549 run_cracker (device_param, pw_cnt, pws_cnt);
4550
4551 device_param->pw_cnt = 0;
4552 device_param->pws_cnt = 0;
4553 }
4554
4555 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4556
4557 if (data.devices_status == STATUS_CRACKED) break;
4558 if (data.devices_status == STATUS_ABORTED) break;
4559 if (data.devices_status == STATUS_QUIT) break;
4560 if (data.devices_status == STATUS_BYPASS) break;
4561 }
4562
4563 if (words_fin == 0) break;
4564
4565 device_param->words_done = words_fin;
4566 }
4567
4568 if (attack_mode == ATTACK_MODE_COMBI)
4569 {
4570 fclose (device_param->combs_fp);
4571 }
4572
4573 free (wl_data->buf);
4574 free (wl_data);
4575
4576 fclose (fd);
4577 }
4578
4579 return NULL;
4580 }
4581
4582 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4583 {
4584 salt_t *salt_buf = &data.salts_buf[salt_pos];
4585
4586 device_param->kernel_params_buf32[24] = salt_pos;
4587 device_param->kernel_params_buf32[27] = 1;
4588 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4589 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4590 device_param->kernel_params_buf32[30] = 0;
4591 device_param->kernel_params_buf32[31] = 1;
4592
4593 char *dictfile_old = data.dictfile;
4594
4595 const char *weak_hash_check = "weak-hash-check";
4596
4597 data.dictfile = (char *) weak_hash_check;
4598
4599 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4600
4601 data.kernel_rules_buf[0].cmds[0] = 0;
4602
4603 /**
4604 * run the kernel
4605 */
4606
4607 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4608 {
4609 run_kernel (KERN_RUN_1, device_param, 1);
4610 }
4611 else
4612 {
4613 run_kernel (KERN_RUN_1, device_param, 1);
4614
4615 const uint iter = salt_buf->salt_iter;
4616
4617 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4618 {
4619 uint loop_left = iter - loop_pos;
4620
4621 loop_left = MIN (loop_left, kernel_loops);
4622
4623 device_param->kernel_params_buf32[25] = loop_pos;
4624 device_param->kernel_params_buf32[26] = loop_left;
4625
4626 run_kernel (KERN_RUN_2, device_param, 1);
4627 }
4628
4629 run_kernel (KERN_RUN_3, device_param, 1);
4630 }
4631
4632 /**
4633 * result
4634 */
4635
4636 check_cracked (device_param, salt_pos);
4637
4638 /**
4639 * cleanup
4640 */
4641
4642 device_param->kernel_params_buf32[24] = 0;
4643 device_param->kernel_params_buf32[25] = 0;
4644 device_param->kernel_params_buf32[26] = 0;
4645 device_param->kernel_params_buf32[27] = 0;
4646 device_param->kernel_params_buf32[28] = 0;
4647 device_param->kernel_params_buf32[29] = 0;
4648 device_param->kernel_params_buf32[30] = 0;
4649 device_param->kernel_params_buf32[31] = 0;
4650
4651 data.dictfile = dictfile_old;
4652
4653 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4654 }
4655
4656 // hlfmt hashcat
4657
4658 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4659 {
4660 if (data.username == 0)
4661 {
4662 *hashbuf_pos = line_buf;
4663 *hashbuf_len = line_len;
4664 }
4665 else
4666 {
4667 char *pos = line_buf;
4668 int len = line_len;
4669
4670 for (int i = 0; i < line_len; i++, pos++, len--)
4671 {
4672 if (line_buf[i] == data.separator)
4673 {
4674 pos++;
4675
4676 len--;
4677
4678 break;
4679 }
4680 }
4681
4682 *hashbuf_pos = pos;
4683 *hashbuf_len = len;
4684 }
4685 }
4686
4687 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4688 {
4689 char *pos = NULL;
4690 int len = 0;
4691
4692 int sep_cnt = 0;
4693
4694 for (int i = 0; i < line_len; i++)
4695 {
4696 if (line_buf[i] == data.separator)
4697 {
4698 sep_cnt++;
4699
4700 continue;
4701 }
4702
4703 if (sep_cnt == 0)
4704 {
4705 if (pos == NULL) pos = line_buf + i;
4706
4707 len++;
4708 }
4709 }
4710
4711 *userbuf_pos = pos;
4712 *userbuf_len = len;
4713 }
4714
4715 // hlfmt pwdump
4716
4717 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4718 {
4719 int sep_cnt = 0;
4720
4721 int sep2_len = 0;
4722 int sep3_len = 0;
4723
4724 for (int i = 0; i < line_len; i++)
4725 {
4726 if (line_buf[i] == ':')
4727 {
4728 sep_cnt++;
4729
4730 continue;
4731 }
4732
4733 if (sep_cnt == 2) sep2_len++;
4734 if (sep_cnt == 3) sep3_len++;
4735 }
4736
4737 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4738
4739 return 0;
4740 }
4741
4742 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4743 {
4744 char *pos = NULL;
4745 int len = 0;
4746
4747 int sep_cnt = 0;
4748
4749 for (int i = 0; i < line_len; i++)
4750 {
4751 if (line_buf[i] == ':')
4752 {
4753 sep_cnt++;
4754
4755 continue;
4756 }
4757
4758 if (data.hash_mode == 1000)
4759 {
4760 if (sep_cnt == 3)
4761 {
4762 if (pos == NULL) pos = line_buf + i;
4763
4764 len++;
4765 }
4766 }
4767 else if (data.hash_mode == 3000)
4768 {
4769 if (sep_cnt == 2)
4770 {
4771 if (pos == NULL) pos = line_buf + i;
4772
4773 len++;
4774 }
4775 }
4776 }
4777
4778 *hashbuf_pos = pos;
4779 *hashbuf_len = len;
4780 }
4781
4782 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4783 {
4784 char *pos = NULL;
4785 int len = 0;
4786
4787 int sep_cnt = 0;
4788
4789 for (int i = 0; i < line_len; i++)
4790 {
4791 if (line_buf[i] == ':')
4792 {
4793 sep_cnt++;
4794
4795 continue;
4796 }
4797
4798 if (sep_cnt == 0)
4799 {
4800 if (pos == NULL) pos = line_buf + i;
4801
4802 len++;
4803 }
4804 }
4805
4806 *userbuf_pos = pos;
4807 *userbuf_len = len;
4808 }
4809
4810 // hlfmt passwd
4811
4812 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4813 {
4814 int sep_cnt = 0;
4815
4816 char sep5_first = 0;
4817 char sep6_first = 0;
4818
4819 for (int i = 0; i < line_len; i++)
4820 {
4821 if (line_buf[i] == ':')
4822 {
4823 sep_cnt++;
4824
4825 continue;
4826 }
4827
4828 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4829 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4830 }
4831
4832 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4833
4834 return 0;
4835 }
4836
4837 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4838 {
4839 char *pos = NULL;
4840 int len = 0;
4841
4842 int sep_cnt = 0;
4843
4844 for (int i = 0; i < line_len; i++)
4845 {
4846 if (line_buf[i] == ':')
4847 {
4848 sep_cnt++;
4849
4850 continue;
4851 }
4852
4853 if (sep_cnt == 1)
4854 {
4855 if (pos == NULL) pos = line_buf + i;
4856
4857 len++;
4858 }
4859 }
4860
4861 *hashbuf_pos = pos;
4862 *hashbuf_len = len;
4863 }
4864
4865 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4866 {
4867 char *pos = NULL;
4868 int len = 0;
4869
4870 int sep_cnt = 0;
4871
4872 for (int i = 0; i < line_len; i++)
4873 {
4874 if (line_buf[i] == ':')
4875 {
4876 sep_cnt++;
4877
4878 continue;
4879 }
4880
4881 if (sep_cnt == 0)
4882 {
4883 if (pos == NULL) pos = line_buf + i;
4884
4885 len++;
4886 }
4887 }
4888
4889 *userbuf_pos = pos;
4890 *userbuf_len = len;
4891 }
4892
4893 // hlfmt shadow
4894
4895 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4896 {
4897 int sep_cnt = 0;
4898
4899 for (int i = 0; i < line_len; i++)
4900 {
4901 if (line_buf[i] == ':') sep_cnt++;
4902 }
4903
4904 if (sep_cnt == 8) return 1;
4905
4906 return 0;
4907 }
4908
4909 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4910 {
4911 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4912 }
4913
4914 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4915 {
4916 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4917 }
4918
4919 // hlfmt main
4920
4921 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4922 {
4923 switch (hashfile_format)
4924 {
4925 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4926 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4927 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4928 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4929 }
4930 }
4931
4932 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4933 {
4934 switch (hashfile_format)
4935 {
4936 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4937 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4938 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4939 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4940 }
4941 }
4942
4943 static uint hlfmt_detect (FILE *fp, uint max_check)
4944 {
4945 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4946
4947 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4948 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4949
4950 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4951
4952 uint num_check = 0;
4953
4954 while (!feof (fp))
4955 {
4956 char line_buf[BUFSIZ] = { 0 };
4957
4958 int line_len = fgetl (fp, line_buf);
4959
4960 if (line_len == 0) continue;
4961
4962 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4963 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4964 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4965
4966 if (num_check == max_check) break;
4967
4968 num_check++;
4969 }
4970
4971 uint hashlist_format = HLFMT_HASHCAT;
4972
4973 for (int i = 1; i < HLFMTS_CNT; i++)
4974 {
4975 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4976
4977 hashlist_format = i;
4978 }
4979
4980 free (formats_cnt);
4981
4982 return hashlist_format;
4983 }
4984
4985 /**
4986 * some further helper function
4987 */
4988
4989 // wrapper around mymalloc for ADL
4990
4991 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
4992 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4993 {
4994 return mymalloc (iSize);
4995 }
4996 #endif
4997
4998 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
4999 {
5000 u64 collisions = 0;
5001
5002 const uint dgst_pos0 = data.dgst_pos0;
5003 const uint dgst_pos1 = data.dgst_pos1;
5004 const uint dgst_pos2 = data.dgst_pos2;
5005 const uint dgst_pos3 = data.dgst_pos3;
5006
5007 memset (bitmap_a, 0, bitmap_size);
5008 memset (bitmap_b, 0, bitmap_size);
5009 memset (bitmap_c, 0, bitmap_size);
5010 memset (bitmap_d, 0, bitmap_size);
5011
5012 for (uint i = 0; i < digests_cnt; i++)
5013 {
5014 uint *digest_ptr = (uint *) digests_buf_ptr;
5015
5016 digests_buf_ptr += dgst_size;
5017
5018 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5019 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5020 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5021 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5022
5023 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5024 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5025 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5026 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5027
5028 if (bitmap_a[idx0] & val0) collisions++;
5029 if (bitmap_b[idx1] & val1) collisions++;
5030 if (bitmap_c[idx2] & val2) collisions++;
5031 if (bitmap_d[idx3] & val3) collisions++;
5032
5033 bitmap_a[idx0] |= val0;
5034 bitmap_b[idx1] |= val1;
5035 bitmap_c[idx2] |= val2;
5036 bitmap_d[idx3] |= val3;
5037
5038 if (collisions >= collisions_max) return 0x7fffffff;
5039 }
5040
5041 return collisions;
5042 }
5043
5044 /**
5045 * main
5046 */
5047
5048 int main (int argc, char **argv)
5049 {
5050 /**
5051 * To help users a bit
5052 */
5053
5054 char *compute = getenv ("COMPUTE");
5055
5056 if (compute)
5057 {
5058 char display[100] = { 0 };
5059
5060 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5061
5062 putenv (display);
5063 }
5064 else
5065 {
5066 if (getenv ("DISPLAY") == NULL)
5067 putenv ((char *) "DISPLAY=:0");
5068 }
5069
5070 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5071 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5072
5073 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5074 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5075
5076 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5077 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5078
5079 /**
5080 * Real init
5081 */
5082
5083 memset (&data, 0, sizeof (hc_global_data_t));
5084
5085 time_t proc_start;
5086
5087 time (&proc_start);
5088
5089 data.proc_start = proc_start;
5090
5091 int myargc = argc;
5092 char **myargv = argv;
5093
5094 hc_thread_mutex_init (mux_dispatcher);
5095 hc_thread_mutex_init (mux_counter);
5096 hc_thread_mutex_init (mux_display);
5097 hc_thread_mutex_init (mux_adl);
5098
5099 /**
5100 * commandline parameters
5101 */
5102
5103 uint usage = USAGE;
5104 uint version = VERSION;
5105 uint quiet = QUIET;
5106 uint benchmark = BENCHMARK;
5107 uint benchmark_mode = BENCHMARK_MODE;
5108 uint show = SHOW;
5109 uint left = LEFT;
5110 uint username = USERNAME;
5111 uint remove = REMOVE;
5112 uint remove_timer = REMOVE_TIMER;
5113 u64 skip = SKIP;
5114 u64 limit = LIMIT;
5115 uint keyspace = KEYSPACE;
5116 uint potfile_disable = POTFILE_DISABLE;
5117 uint debug_mode = DEBUG_MODE;
5118 char *debug_file = NULL;
5119 char *induction_dir = NULL;
5120 char *outfile_check_dir = NULL;
5121 uint force = FORCE;
5122 uint runtime = RUNTIME;
5123 uint hash_mode = HASH_MODE;
5124 uint attack_mode = ATTACK_MODE;
5125 uint markov_disable = MARKOV_DISABLE;
5126 uint markov_classic = MARKOV_CLASSIC;
5127 uint markov_threshold = MARKOV_THRESHOLD;
5128 char *markov_hcstat = NULL;
5129 char *outfile = NULL;
5130 uint outfile_format = OUTFILE_FORMAT;
5131 uint outfile_autohex = OUTFILE_AUTOHEX;
5132 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5133 uint restore = RESTORE;
5134 uint restore_timer = RESTORE_TIMER;
5135 uint restore_disable = RESTORE_DISABLE;
5136 uint status = STATUS;
5137 uint status_timer = STATUS_TIMER;
5138 uint status_automat = STATUS_AUTOMAT;
5139 uint loopback = LOOPBACK;
5140 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5141 char *session = NULL;
5142 uint hex_charset = HEX_CHARSET;
5143 uint hex_salt = HEX_SALT;
5144 uint hex_wordlist = HEX_WORDLIST;
5145 uint rp_gen = RP_GEN;
5146 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5147 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5148 uint rp_gen_seed = RP_GEN_SEED;
5149 char *rule_buf_l = (char *) RULE_BUF_L;
5150 char *rule_buf_r = (char *) RULE_BUF_R;
5151 uint increment = INCREMENT;
5152 uint increment_min = INCREMENT_MIN;
5153 uint increment_max = INCREMENT_MAX;
5154 #ifndef OSX
5155 char *cpu_affinity = NULL;
5156 #endif
5157 OCL_PTR *ocl = NULL;
5158 char *opencl_devices = NULL;
5159 char *opencl_platforms = NULL;
5160 char *opencl_device_types = NULL;
5161 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5162 char *truecrypt_keyfiles = NULL;
5163 uint workload_profile = WORKLOAD_PROFILE;
5164 uint kernel_accel = KERNEL_ACCEL;
5165 uint kernel_loops = KERNEL_LOOPS;
5166 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5167 #ifdef HAVE_HWMON
5168 uint gpu_temp_abort = GPU_TEMP_ABORT;
5169 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5170 #ifdef HAVE_ADL
5171 uint powertune_enable = POWERTUNE_ENABLE;
5172 #endif
5173 #endif
5174 uint logfile_disable = LOGFILE_DISABLE;
5175 uint segment_size = SEGMENT_SIZE;
5176 uint scrypt_tmto = SCRYPT_TMTO;
5177 char separator = SEPARATOR;
5178 uint bitmap_min = BITMAP_MIN;
5179 uint bitmap_max = BITMAP_MAX;
5180 char *custom_charset_1 = NULL;
5181 char *custom_charset_2 = NULL;
5182 char *custom_charset_3 = NULL;
5183 char *custom_charset_4 = NULL;
5184
5185 #define IDX_HELP 'h'
5186 #define IDX_VERSION 'V'
5187 #define IDX_VERSION_LOWER 'v'
5188 #define IDX_QUIET 0xff02
5189 #define IDX_SHOW 0xff03
5190 #define IDX_LEFT 0xff04
5191 #define IDX_REMOVE 0xff05
5192 #define IDX_REMOVE_TIMER 0xff37
5193 #define IDX_SKIP 's'
5194 #define IDX_LIMIT 'l'
5195 #define IDX_KEYSPACE 0xff35
5196 #define IDX_POTFILE_DISABLE 0xff06
5197 #define IDX_DEBUG_MODE 0xff43
5198 #define IDX_DEBUG_FILE 0xff44
5199 #define IDX_INDUCTION_DIR 0xff46
5200 #define IDX_OUTFILE_CHECK_DIR 0xff47
5201 #define IDX_USERNAME 0xff07
5202 #define IDX_FORCE 0xff08
5203 #define IDX_RUNTIME 0xff09
5204 #define IDX_BENCHMARK 'b'
5205 #define IDX_BENCHMARK_MODE 0xff32
5206 #define IDX_HASH_MODE 'm'
5207 #define IDX_ATTACK_MODE 'a'
5208 #define IDX_RP_FILE 'r'
5209 #define IDX_RP_GEN 'g'
5210 #define IDX_RP_GEN_FUNC_MIN 0xff10
5211 #define IDX_RP_GEN_FUNC_MAX 0xff11
5212 #define IDX_RP_GEN_SEED 0xff34
5213 #define IDX_RULE_BUF_L 'j'
5214 #define IDX_RULE_BUF_R 'k'
5215 #define IDX_INCREMENT 'i'
5216 #define IDX_INCREMENT_MIN 0xff12
5217 #define IDX_INCREMENT_MAX 0xff13
5218 #define IDX_OUTFILE 'o'
5219 #define IDX_OUTFILE_FORMAT 0xff14
5220 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5221 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5222 #define IDX_RESTORE 0xff15
5223 #define IDX_RESTORE_DISABLE 0xff27
5224 #define IDX_STATUS 0xff17
5225 #define IDX_STATUS_TIMER 0xff18
5226 #define IDX_STATUS_AUTOMAT 0xff50
5227 #define IDX_LOOPBACK 0xff38
5228 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5229 #define IDX_SESSION 0xff19
5230 #define IDX_HEX_CHARSET 0xff20
5231 #define IDX_HEX_SALT 0xff21
5232 #define IDX_HEX_WORDLIST 0xff40
5233 #define IDX_MARKOV_DISABLE 0xff22
5234 #define IDX_MARKOV_CLASSIC 0xff23
5235 #define IDX_MARKOV_THRESHOLD 't'
5236 #define IDX_MARKOV_HCSTAT 0xff24
5237 #define IDX_CPU_AFFINITY 0xff25
5238 #define IDX_OPENCL_DEVICES 'd'
5239 #define IDX_OPENCL_PLATFORMS 0xff72
5240 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5241 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5242 #define IDX_WORKLOAD_PROFILE 'w'
5243 #define IDX_KERNEL_ACCEL 'n'
5244 #define IDX_KERNEL_LOOPS 'u'
5245 #define IDX_GPU_TEMP_DISABLE 0xff29
5246 #define IDX_GPU_TEMP_ABORT 0xff30
5247 #define IDX_GPU_TEMP_RETAIN 0xff31
5248 #define IDX_POWERTUNE_ENABLE 0xff41
5249 #define IDX_LOGFILE_DISABLE 0xff51
5250 #define IDX_TRUECRYPT_KEYFILES 0xff52
5251 #define IDX_SCRYPT_TMTO 0xff61
5252 #define IDX_SEGMENT_SIZE 'c'
5253 #define IDX_SEPARATOR 'p'
5254 #define IDX_BITMAP_MIN 0xff70
5255 #define IDX_BITMAP_MAX 0xff71
5256 #define IDX_CUSTOM_CHARSET_1 '1'
5257 #define IDX_CUSTOM_CHARSET_2 '2'
5258 #define IDX_CUSTOM_CHARSET_3 '3'
5259 #define IDX_CUSTOM_CHARSET_4 '4'
5260
5261 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5262
5263 struct option long_options[] =
5264 {
5265 {"help", no_argument, 0, IDX_HELP},
5266 {"version", no_argument, 0, IDX_VERSION},
5267 {"quiet", no_argument, 0, IDX_QUIET},
5268 {"show", no_argument, 0, IDX_SHOW},
5269 {"left", no_argument, 0, IDX_LEFT},
5270 {"username", no_argument, 0, IDX_USERNAME},
5271 {"remove", no_argument, 0, IDX_REMOVE},
5272 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5273 {"skip", required_argument, 0, IDX_SKIP},
5274 {"limit", required_argument, 0, IDX_LIMIT},
5275 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5276 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5277 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5278 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5279 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5280 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5281 {"force", no_argument, 0, IDX_FORCE},
5282 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5283 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5284 {"restore", no_argument, 0, IDX_RESTORE},
5285 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5286 {"status", no_argument, 0, IDX_STATUS},
5287 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5288 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5289 {"loopback", no_argument, 0, IDX_LOOPBACK},
5290 {"weak-hash-threshold",
5291 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5292 {"session", required_argument, 0, IDX_SESSION},
5293 {"runtime", required_argument, 0, IDX_RUNTIME},
5294 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5295 {"generate-rules-func-min",
5296 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5297 {"generate-rules-func-max",
5298 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5299 {"generate-rules-seed",
5300 required_argument, 0, IDX_RP_GEN_SEED},
5301 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5302 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5303 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5304 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5305 {"rules-file", required_argument, 0, IDX_RP_FILE},
5306 {"outfile", required_argument, 0, IDX_OUTFILE},
5307 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5308 {"outfile-autohex-disable",
5309 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5310 {"outfile-check-timer",
5311 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5312 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5313 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5314 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5315 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5316 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5317 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5318 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5319 #ifndef OSX
5320 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5321 #endif
5322 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5323 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5324 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5325 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5326 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5327 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5328 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5329 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5330 #ifdef HAVE_HWMON
5331 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5332 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5333 #ifdef HAVE_ADL
5334 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5335 #endif
5336 #endif // HAVE_HWMON
5337 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5338 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5339 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5340 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5341 // deprecated
5342 {"seperator", required_argument, 0, IDX_SEPARATOR},
5343 {"separator", required_argument, 0, IDX_SEPARATOR},
5344 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5345 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5346 {"increment", no_argument, 0, IDX_INCREMENT},
5347 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5348 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5349 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5350 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5351 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5352 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5353
5354 {0, 0, 0, 0}
5355 };
5356
5357 uint rp_files_cnt = 0;
5358
5359 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5360
5361 int option_index = 0;
5362 int c = -1;
5363
5364 optind = 1;
5365 optopt = 0;
5366
5367 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5368 {
5369 switch (c)
5370 {
5371 case IDX_HELP: usage = 1; break;
5372 case IDX_VERSION:
5373 case IDX_VERSION_LOWER: version = 1; break;
5374 case IDX_RESTORE: restore = 1; break;
5375 case IDX_SESSION: session = optarg; break;
5376 case IDX_SHOW: show = 1; break;
5377 case IDX_LEFT: left = 1; break;
5378 case '?': return (-1);
5379 }
5380 }
5381
5382 if (optopt != 0)
5383 {
5384 log_error ("ERROR: Invalid argument specified");
5385
5386 return (-1);
5387 }
5388
5389 /**
5390 * exit functions
5391 */
5392
5393 if (version)
5394 {
5395 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5396
5397 return (0);
5398 }
5399
5400 if (usage)
5401 {
5402 usage_big_print (PROGNAME);
5403
5404 return (0);
5405 }
5406
5407 /**
5408 * session needs to be set, always!
5409 */
5410
5411 if (session == NULL) session = (char *) PROGNAME;
5412
5413 /**
5414 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5415 */
5416
5417 char *exec_path = get_exec_path ();
5418
5419 #ifdef LINUX
5420
5421 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5422 char *resolved_exec_path = realpath (exec_path, NULL);
5423
5424 char *install_dir = get_install_dir (resolved_exec_path);
5425 char *profile_dir = NULL;
5426 char *session_dir = NULL;
5427 char *shared_dir = NULL;
5428
5429 if (strcmp (install_dir, resolved_install_folder) == 0)
5430 {
5431 struct passwd *pw = getpwuid (getuid ());
5432
5433 const char *homedir = pw->pw_dir;
5434
5435 profile_dir = get_profile_dir (homedir);
5436 session_dir = get_session_dir (profile_dir);
5437 shared_dir = strdup (SHARED_FOLDER);
5438
5439 mkdir (profile_dir, 0700);
5440 mkdir (session_dir, 0700);
5441 }
5442 else
5443 {
5444 profile_dir = install_dir;
5445 session_dir = install_dir;
5446 shared_dir = install_dir;
5447 }
5448
5449 myfree (resolved_install_folder);
5450 myfree (resolved_exec_path);
5451
5452 #else
5453
5454 char *install_dir = get_install_dir (exec_path);
5455 char *profile_dir = install_dir;
5456 char *session_dir = install_dir;
5457 char *shared_dir = install_dir;
5458
5459 #endif
5460
5461 data.install_dir = install_dir;
5462 data.profile_dir = profile_dir;
5463 data.session_dir = session_dir;
5464 data.shared_dir = shared_dir;
5465
5466 myfree (exec_path);
5467
5468 /**
5469 * kernel cache, we need to make sure folder exist
5470 */
5471
5472 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5473
5474 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5475
5476 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5477
5478 mkdir (kernels_folder, 0700);
5479
5480 myfree (kernels_folder);
5481
5482 /**
5483 * session
5484 */
5485
5486 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5487
5488 data.session = session;
5489
5490 char *eff_restore_file = (char *) mymalloc (session_size);
5491 char *new_restore_file = (char *) mymalloc (session_size);
5492
5493 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5494 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5495
5496 data.eff_restore_file = eff_restore_file;
5497 data.new_restore_file = new_restore_file;
5498
5499 if (((show == 1) || (left == 1)) && (restore == 1))
5500 {
5501 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5502 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5503
5504 return (-1);
5505 }
5506
5507 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5508 if ((show == 1) || (left == 1))
5509 {
5510 restore_disable = 1;
5511
5512 restore = 0;
5513 }
5514
5515 data.restore_disable = restore_disable;
5516
5517 restore_data_t *rd = init_restore (argc, argv);
5518
5519 data.rd = rd;
5520
5521 /**
5522 * restore file
5523 */
5524
5525 if (restore == 1)
5526 {
5527 read_restore (eff_restore_file, rd);
5528
5529 if (rd->version_bin < RESTORE_MIN)
5530 {
5531 log_error ("ERROR: Incompatible restore-file version");
5532
5533 return (-1);
5534 }
5535
5536 myargc = rd->argc;
5537 myargv = rd->argv;
5538
5539 #ifdef _POSIX
5540 rd->pid = getpid ();
5541 #elif _WIN
5542 rd->pid = GetCurrentProcessId ();
5543 #endif
5544 }
5545
5546 uint hash_mode_chgd = 0;
5547 uint runtime_chgd = 0;
5548 uint kernel_loops_chgd = 0;
5549 uint kernel_accel_chgd = 0;
5550 uint attack_mode_chgd = 0;
5551 uint outfile_format_chgd = 0;
5552 uint rp_gen_seed_chgd = 0;
5553 uint remove_timer_chgd = 0;
5554 uint increment_min_chgd = 0;
5555 uint increment_max_chgd = 0;
5556 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5557 uint gpu_temp_retain_chgd = 0;
5558 uint gpu_temp_abort_chgd = 0;
5559 #endif
5560
5561 optind = 1;
5562 optopt = 0;
5563 option_index = 0;
5564
5565 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5566 {
5567 switch (c)
5568 {
5569 //case IDX_HELP: usage = 1; break;
5570 //case IDX_VERSION: version = 1; break;
5571 //case IDX_RESTORE: restore = 1; break;
5572 case IDX_QUIET: quiet = 1; break;
5573 //case IDX_SHOW: show = 1; break;
5574 case IDX_SHOW: break;
5575 //case IDX_LEFT: left = 1; break;
5576 case IDX_LEFT: break;
5577 case IDX_USERNAME: username = 1; break;
5578 case IDX_REMOVE: remove = 1; break;
5579 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5580 remove_timer_chgd = 1; break;
5581 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5582 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5583 case IDX_DEBUG_FILE: debug_file = optarg; break;
5584 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5585 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5586 case IDX_FORCE: force = 1; break;
5587 case IDX_SKIP: skip = atoll (optarg); break;
5588 case IDX_LIMIT: limit = atoll (optarg); break;
5589 case IDX_KEYSPACE: keyspace = 1; break;
5590 case IDX_BENCHMARK: benchmark = 1; break;
5591 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5592 case IDX_RESTORE: break;
5593 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5594 case IDX_STATUS: status = 1; break;
5595 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5596 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5597 case IDX_LOOPBACK: loopback = 1; break;
5598 case IDX_WEAK_HASH_THRESHOLD:
5599 weak_hash_threshold = atoi (optarg); break;
5600 //case IDX_SESSION: session = optarg; break;
5601 case IDX_SESSION: break;
5602 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5603 hash_mode_chgd = 1; break;
5604 case IDX_RUNTIME: runtime = atoi (optarg);
5605 runtime_chgd = 1; break;
5606 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5607 attack_mode_chgd = 1; break;
5608 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5609 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5610 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5611 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5612 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5613 rp_gen_seed_chgd = 1; break;
5614 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5615 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5616 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5617 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5618 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5619 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5620 case IDX_OUTFILE: outfile = optarg; break;
5621 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5622 outfile_format_chgd = 1; break;
5623 case IDX_OUTFILE_AUTOHEX_DISABLE:
5624 outfile_autohex = 0; break;
5625 case IDX_OUTFILE_CHECK_TIMER:
5626 outfile_check_timer = atoi (optarg); break;
5627 case IDX_HEX_CHARSET: hex_charset = 1; break;
5628 case IDX_HEX_SALT: hex_salt = 1; break;
5629 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5630 #ifndef OSX
5631 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5632 #endif
5633 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5634 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5635 case IDX_OPENCL_DEVICE_TYPES:
5636 opencl_device_types = optarg; break;
5637 case IDX_OPENCL_VECTOR_WIDTH:
5638 opencl_vector_width = atoi (optarg); break;
5639 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5640 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5641 kernel_accel_chgd = 1; break;
5642 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5643 kernel_loops_chgd = 1; break;
5644 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5645 #ifdef HAVE_HWMON
5646 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5647 #ifdef HAVE_ADL
5648 gpu_temp_abort_chgd = 1;
5649 #endif
5650 break;
5651 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5652 #ifdef HAVE_ADL
5653 gpu_temp_retain_chgd = 1;
5654 #endif
5655 break;
5656 #ifdef HAVE_ADL
5657 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5658 #endif
5659 #endif // HAVE_HWMON
5660 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5661 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5662 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5663 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5664 case IDX_SEPARATOR: separator = optarg[0]; break;
5665 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5666 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5667 case IDX_INCREMENT: increment = 1; break;
5668 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5669 increment_min_chgd = 1; break;
5670 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5671 increment_max_chgd = 1; break;
5672 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5673 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5674 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5675 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5676
5677 default:
5678 log_error ("ERROR: Invalid argument specified");
5679 return (-1);
5680 }
5681 }
5682
5683 if (optopt != 0)
5684 {
5685 log_error ("ERROR: Invalid argument specified");
5686
5687 return (-1);
5688 }
5689
5690 /**
5691 * Inform user things getting started,
5692 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5693 * - we do not need to check algorithm_pos
5694 */
5695
5696 if (quiet == 0)
5697 {
5698 if (benchmark == 1)
5699 {
5700 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5701
5702 log_info ("");
5703 }
5704 else if (restore == 1)
5705 {
5706 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5707
5708 log_info ("");
5709 }
5710 else
5711 {
5712 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5713
5714 log_info ("");
5715 }
5716 }
5717
5718 /**
5719 * sanity check
5720 */
5721
5722 if (attack_mode > 7)
5723 {
5724 log_error ("ERROR: Invalid attack-mode specified");
5725
5726 return (-1);
5727 }
5728
5729 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5730 {
5731 log_error ("ERROR: Invalid runtime specified");
5732
5733 return (-1);
5734 }
5735
5736 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5737 {
5738 log_error ("ERROR: Invalid hash-type specified");
5739
5740 return (-1);
5741 }
5742
5743 // renamed hash modes
5744
5745 if (hash_mode_chgd)
5746 {
5747 int n = -1;
5748
5749 switch (hash_mode)
5750 {
5751 case 123: n = 124;
5752 break;
5753 }
5754
5755 if (n >= 0)
5756 {
5757 log_error ("Old -m specified, use -m %d instead", n);
5758
5759 return (-1);
5760 }
5761 }
5762
5763 if (username == 1)
5764 {
5765 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5766 {
5767 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5768
5769 return (-1);
5770 }
5771 }
5772
5773 if (outfile_format > 16)
5774 {
5775 log_error ("ERROR: Invalid outfile-format specified");
5776
5777 return (-1);
5778 }
5779
5780 if (left == 1)
5781 {
5782 if (outfile_format_chgd == 1)
5783 {
5784 if (outfile_format > 1)
5785 {
5786 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5787
5788 return (-1);
5789 }
5790 }
5791 else
5792 {
5793 outfile_format = OUTFILE_FMT_HASH;
5794 }
5795 }
5796
5797 if (show == 1)
5798 {
5799 if (outfile_format_chgd == 1)
5800 {
5801 if ((outfile_format > 7) && (outfile_format < 16))
5802 {
5803 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5804
5805 return (-1);
5806 }
5807 }
5808 }
5809
5810 if (increment_min < INCREMENT_MIN)
5811 {
5812 log_error ("ERROR: Invalid increment-min specified");
5813
5814 return (-1);
5815 }
5816
5817 if (increment_max > INCREMENT_MAX)
5818 {
5819 log_error ("ERROR: Invalid increment-max specified");
5820
5821 return (-1);
5822 }
5823
5824 if (increment_min > increment_max)
5825 {
5826 log_error ("ERROR: Invalid increment-min specified");
5827
5828 return (-1);
5829 }
5830
5831 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5832 {
5833 log_error ("ERROR: increment is not allowed in attack-mode 0");
5834
5835 return (-1);
5836 }
5837
5838 if ((increment == 0) && (increment_min_chgd == 1))
5839 {
5840 log_error ("ERROR: increment-min is only supported together with increment switch");
5841
5842 return (-1);
5843 }
5844
5845 if ((increment == 0) && (increment_max_chgd == 1))
5846 {
5847 log_error ("ERROR: increment-max is only supported together with increment switch");
5848
5849 return (-1);
5850 }
5851
5852 if (rp_files_cnt && rp_gen)
5853 {
5854 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5855
5856 return (-1);
5857 }
5858
5859 if (rp_files_cnt || rp_gen)
5860 {
5861 if (attack_mode != ATTACK_MODE_STRAIGHT)
5862 {
5863 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5864
5865 return (-1);
5866 }
5867 }
5868
5869 if (rp_gen_func_min > rp_gen_func_max)
5870 {
5871 log_error ("ERROR: Invalid rp-gen-func-min specified");
5872
5873 return (-1);
5874 }
5875
5876 if (kernel_accel_chgd == 1)
5877 {
5878 if (workload_profile != WORKLOAD_PROFILE)
5879 {
5880 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5881
5882 return (-1);
5883 }
5884
5885 if (kernel_accel < 1)
5886 {
5887 log_error ("ERROR: Invalid kernel-accel specified");
5888
5889 return (-1);
5890 }
5891
5892 if (kernel_accel > 800)
5893 {
5894 log_error ("ERROR: Invalid kernel-accel specified");
5895
5896 return (-1);
5897 }
5898 }
5899
5900 if (kernel_loops_chgd == 1)
5901 {
5902 if (workload_profile != WORKLOAD_PROFILE)
5903 {
5904 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5905
5906 return (-1);
5907 }
5908
5909 if (kernel_loops < 1)
5910 {
5911 log_error ("ERROR: Invalid kernel-loops specified");
5912
5913 return (-1);
5914 }
5915
5916 if (kernel_loops > 1024)
5917 {
5918 log_error ("ERROR: Invalid kernel-loops specified");
5919
5920 return (-1);
5921 }
5922 }
5923
5924 if (benchmark == 1)
5925 {
5926 if (workload_profile != WORKLOAD_PROFILE)
5927 {
5928 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5929
5930 return (-1);
5931 }
5932 }
5933
5934 if ((workload_profile < 1) || (workload_profile > 3))
5935 {
5936 log_error ("ERROR: workload-profile %i not available", workload_profile);
5937
5938 return (-1);
5939 }
5940
5941 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5942 {
5943 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5944
5945 return (-1);
5946 }
5947
5948 if (show == 1 || left == 1)
5949 {
5950 attack_mode = ATTACK_MODE_NONE;
5951
5952 if (remove == 1)
5953 {
5954 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5955
5956 return (-1);
5957 }
5958
5959 if (potfile_disable == 1)
5960 {
5961 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5962
5963 return (-1);
5964 }
5965 }
5966
5967 uint attack_kern = ATTACK_KERN_NONE;
5968
5969 switch (attack_mode)
5970 {
5971 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5972 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5973 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5974 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5975 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5976 }
5977
5978 if (benchmark == 0)
5979 {
5980 if (keyspace == 1)
5981 {
5982 int num_additional_params = 1;
5983
5984 if (attack_kern == ATTACK_KERN_COMBI)
5985 {
5986 num_additional_params = 2;
5987 }
5988
5989 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5990
5991 if (keyspace_wordlist_specified == 0) optind--;
5992 }
5993
5994 if (attack_kern == ATTACK_KERN_NONE)
5995 {
5996 if ((optind + 1) != myargc)
5997 {
5998 usage_mini_print (myargv[0]);
5999
6000 return (-1);
6001 }
6002 }
6003 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6004 {
6005 if ((optind + 1) > myargc)
6006 {
6007 usage_mini_print (myargv[0]);
6008
6009 return (-1);
6010 }
6011 }
6012 else if (attack_kern == ATTACK_KERN_COMBI)
6013 {
6014 if ((optind + 3) != myargc)
6015 {
6016 usage_mini_print (myargv[0]);
6017
6018 return (-1);
6019 }
6020 }
6021 else if (attack_kern == ATTACK_KERN_BF)
6022 {
6023 if ((optind + 1) > myargc)
6024 {
6025 usage_mini_print (myargv[0]);
6026
6027 return (-1);
6028 }
6029 }
6030 else
6031 {
6032 usage_mini_print (myargv[0]);
6033
6034 return (-1);
6035 }
6036 }
6037 else
6038 {
6039 if (myargv[optind] != 0)
6040 {
6041 log_error ("ERROR: Invalid argument for benchmark mode specified");
6042
6043 return (-1);
6044 }
6045
6046 if (attack_mode_chgd == 1)
6047 {
6048 if (attack_mode != ATTACK_MODE_BF)
6049 {
6050 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6051
6052 return (-1);
6053 }
6054 }
6055
6056 if (benchmark_mode == 0)
6057 {
6058 // nothing to do
6059 }
6060 else if (benchmark_mode == 1)
6061 {
6062 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6063 {
6064 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6065
6066 return (-1);
6067 }
6068 }
6069 else
6070 {
6071 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6072
6073 return (-1);
6074 }
6075 }
6076
6077 if (skip != 0 && limit != 0)
6078 {
6079 limit += skip;
6080 }
6081
6082 if (keyspace == 1)
6083 {
6084 if (show == 1)
6085 {
6086 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6087
6088 return (-1);
6089 }
6090 else if (left == 1)
6091 {
6092 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6093
6094 return (-1);
6095 }
6096
6097 potfile_disable = 1;
6098
6099 restore_disable = 1;
6100
6101 restore = 0;
6102
6103 weak_hash_threshold = 0;
6104
6105 quiet = 1;
6106 }
6107
6108 if (remove_timer_chgd == 1)
6109 {
6110 if (remove == 0)
6111 {
6112 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6113
6114 return (-1);
6115 }
6116
6117 if (remove_timer < 1)
6118 {
6119 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6120
6121 return (-1);
6122 }
6123 }
6124
6125 if (loopback == 1)
6126 {
6127 if (attack_mode == ATTACK_MODE_BF)
6128 {
6129 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6130
6131 return (-1);
6132 }
6133 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6134 {
6135 if ((rp_files_cnt == 0) && (rp_gen == 0))
6136 {
6137 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6138
6139 return (-1);
6140 }
6141 }
6142 }
6143
6144 if (debug_mode > 0)
6145 {
6146 if (attack_mode != ATTACK_MODE_STRAIGHT)
6147 {
6148 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6149
6150 return (-1);
6151 }
6152
6153 if ((rp_files_cnt == 0) && (rp_gen == 0))
6154 {
6155 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6156
6157 return (-1);
6158 }
6159 }
6160
6161 if (debug_mode > 4)
6162 {
6163 log_error ("ERROR: Invalid debug-mode specified");
6164
6165 return (-1);
6166 }
6167
6168 if (debug_file != NULL)
6169 {
6170 if (debug_mode < 1)
6171 {
6172 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (induction_dir != NULL)
6179 {
6180 if (attack_mode == ATTACK_MODE_BF)
6181 {
6182 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6183
6184 return (-1);
6185 }
6186 }
6187
6188 if (attack_mode != ATTACK_MODE_STRAIGHT)
6189 {
6190 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6191 {
6192 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6193
6194 return (-1);
6195 }
6196
6197 weak_hash_threshold = 0;
6198 }
6199
6200 /**
6201 * induction directory
6202 */
6203
6204 char *induction_directory = NULL;
6205
6206 if (attack_mode != ATTACK_MODE_BF)
6207 {
6208 if (induction_dir == NULL)
6209 {
6210 induction_directory = (char *) mymalloc (session_size);
6211
6212 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6213
6214 // create induction folder if it does not already exist
6215
6216 if (keyspace == 0)
6217 {
6218 if (rmdir (induction_directory) == -1)
6219 {
6220 if (errno == ENOENT)
6221 {
6222 // good, we can ignore
6223 }
6224 else if (errno == ENOTEMPTY)
6225 {
6226 char *induction_directory_mv = (char *) mymalloc (session_size);
6227
6228 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6229
6230 if (rename (induction_directory, induction_directory_mv) != 0)
6231 {
6232 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6233
6234 return (-1);
6235 }
6236 }
6237 else
6238 {
6239 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6240
6241 return (-1);
6242 }
6243 }
6244
6245 if (mkdir (induction_directory, 0700) == -1)
6246 {
6247 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6248
6249 return (-1);
6250 }
6251 }
6252 }
6253 else
6254 {
6255 induction_directory = induction_dir;
6256 }
6257 }
6258
6259 data.induction_directory = induction_directory;
6260
6261 /**
6262 * loopback
6263 */
6264
6265 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6266
6267 char *loopback_file = (char *) mymalloc (loopback_size);
6268
6269 /**
6270 * outfile-check directory
6271 */
6272
6273 char *outfile_check_directory = NULL;
6274
6275 if (outfile_check_dir == NULL)
6276 {
6277 outfile_check_directory = (char *) mymalloc (session_size);
6278
6279 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6280 }
6281 else
6282 {
6283 outfile_check_directory = outfile_check_dir;
6284 }
6285
6286 data.outfile_check_directory = outfile_check_directory;
6287
6288 if (keyspace == 0)
6289 {
6290 struct stat outfile_check_stat;
6291
6292 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6293 {
6294 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6295
6296 if (is_dir == 0)
6297 {
6298 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6299
6300 return (-1);
6301 }
6302 }
6303 else if (outfile_check_dir == NULL)
6304 {
6305 if (mkdir (outfile_check_directory, 0700) == -1)
6306 {
6307 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6308
6309 return (-1);
6310 }
6311 }
6312 }
6313
6314 /**
6315 * special other stuff
6316 */
6317
6318 if (hash_mode == 9710)
6319 {
6320 outfile_format = 5;
6321 outfile_format_chgd = 1;
6322 }
6323
6324 if (hash_mode == 9810)
6325 {
6326 outfile_format = 5;
6327 outfile_format_chgd = 1;
6328 }
6329
6330 if (hash_mode == 10410)
6331 {
6332 outfile_format = 5;
6333 outfile_format_chgd = 1;
6334 }
6335
6336 /**
6337 * store stuff
6338 */
6339
6340 data.hash_mode = hash_mode;
6341 data.restore = restore;
6342 data.restore_timer = restore_timer;
6343 data.restore_disable = restore_disable;
6344 data.status = status;
6345 data.status_timer = status_timer;
6346 data.status_automat = status_automat;
6347 data.loopback = loopback;
6348 data.runtime = runtime;
6349 data.remove = remove;
6350 data.remove_timer = remove_timer;
6351 data.debug_mode = debug_mode;
6352 data.debug_file = debug_file;
6353 data.username = username;
6354 data.quiet = quiet;
6355 data.outfile = outfile;
6356 data.outfile_format = outfile_format;
6357 data.outfile_autohex = outfile_autohex;
6358 data.hex_charset = hex_charset;
6359 data.hex_salt = hex_salt;
6360 data.hex_wordlist = hex_wordlist;
6361 data.separator = separator;
6362 data.rp_files = rp_files;
6363 data.rp_files_cnt = rp_files_cnt;
6364 data.rp_gen = rp_gen;
6365 data.rp_gen_seed = rp_gen_seed;
6366 data.force = force;
6367 data.benchmark = benchmark;
6368 data.skip = skip;
6369 data.limit = limit;
6370 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6371 data.powertune_enable = powertune_enable;
6372 #endif
6373 data.logfile_disable = logfile_disable;
6374 data.truecrypt_keyfiles = truecrypt_keyfiles;
6375 data.scrypt_tmto = scrypt_tmto;
6376
6377 /**
6378 * cpu affinity
6379 */
6380
6381 #ifndef OSX
6382 if (cpu_affinity)
6383 {
6384 set_cpu_affinity (cpu_affinity);
6385 }
6386 #endif
6387
6388 if (rp_gen_seed_chgd == 0)
6389 {
6390 srand (proc_start);
6391 }
6392 else
6393 {
6394 srand (rp_gen_seed);
6395 }
6396
6397 /**
6398 * logfile init
6399 */
6400
6401 if (logfile_disable == 0)
6402 {
6403 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6404
6405 char *logfile = (char *) mymalloc (logfile_size);
6406
6407 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6408
6409 data.logfile = logfile;
6410
6411 char *topid = logfile_generate_topid ();
6412
6413 data.topid = topid;
6414 }
6415
6416 // logfile_append() checks for logfile_disable internally to make it easier from here
6417
6418 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6419 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6420 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6421 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6422 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6423 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6424 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6425 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6426 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6427 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6428
6429 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6430 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6431 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6432 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6433 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6434 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6435 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6436 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6437
6438 logfile_top_msg ("START");
6439
6440 logfile_top_uint (attack_mode);
6441 logfile_top_uint (attack_kern);
6442 logfile_top_uint (benchmark);
6443 logfile_top_uint (benchmark_mode);
6444 logfile_top_uint (bitmap_min);
6445 logfile_top_uint (bitmap_max);
6446 logfile_top_uint (debug_mode);
6447 logfile_top_uint (force);
6448 logfile_top_uint (kernel_accel);
6449 logfile_top_uint (kernel_loops);
6450 logfile_top_uint (gpu_temp_disable);
6451 #ifdef HAVE_HWMON
6452 logfile_top_uint (gpu_temp_abort);
6453 logfile_top_uint (gpu_temp_retain);
6454 #endif
6455 logfile_top_uint (hash_mode);
6456 logfile_top_uint (hex_charset);
6457 logfile_top_uint (hex_salt);
6458 logfile_top_uint (hex_wordlist);
6459 logfile_top_uint (increment);
6460 logfile_top_uint (increment_max);
6461 logfile_top_uint (increment_min);
6462 logfile_top_uint (keyspace);
6463 logfile_top_uint (left);
6464 logfile_top_uint (logfile_disable);
6465 logfile_top_uint (loopback);
6466 logfile_top_uint (markov_classic);
6467 logfile_top_uint (markov_disable);
6468 logfile_top_uint (markov_threshold);
6469 logfile_top_uint (outfile_autohex);
6470 logfile_top_uint (outfile_check_timer);
6471 logfile_top_uint (outfile_format);
6472 logfile_top_uint (potfile_disable);
6473 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6474 logfile_top_uint (powertune_enable);
6475 #endif
6476 logfile_top_uint (scrypt_tmto);
6477 logfile_top_uint (quiet);
6478 logfile_top_uint (remove);
6479 logfile_top_uint (remove_timer);
6480 logfile_top_uint (restore);
6481 logfile_top_uint (restore_disable);
6482 logfile_top_uint (restore_timer);
6483 logfile_top_uint (rp_gen);
6484 logfile_top_uint (rp_gen_func_max);
6485 logfile_top_uint (rp_gen_func_min);
6486 logfile_top_uint (rp_gen_seed);
6487 logfile_top_uint (runtime);
6488 logfile_top_uint (segment_size);
6489 logfile_top_uint (show);
6490 logfile_top_uint (status);
6491 logfile_top_uint (status_automat);
6492 logfile_top_uint (status_timer);
6493 logfile_top_uint (usage);
6494 logfile_top_uint (username);
6495 logfile_top_uint (version);
6496 logfile_top_uint (weak_hash_threshold);
6497 logfile_top_uint (workload_profile);
6498 logfile_top_uint64 (limit);
6499 logfile_top_uint64 (skip);
6500 logfile_top_char (separator);
6501 #ifndef OSX
6502 logfile_top_string (cpu_affinity);
6503 #endif
6504 logfile_top_string (custom_charset_1);
6505 logfile_top_string (custom_charset_2);
6506 logfile_top_string (custom_charset_3);
6507 logfile_top_string (custom_charset_4);
6508 logfile_top_string (debug_file);
6509 logfile_top_string (opencl_devices);
6510 logfile_top_string (opencl_platforms);
6511 logfile_top_string (opencl_device_types);
6512 logfile_top_uint (opencl_vector_width);
6513 logfile_top_string (induction_dir);
6514 logfile_top_string (markov_hcstat);
6515 logfile_top_string (outfile);
6516 logfile_top_string (outfile_check_dir);
6517 logfile_top_string (rule_buf_l);
6518 logfile_top_string (rule_buf_r);
6519 logfile_top_string (session);
6520 logfile_top_string (truecrypt_keyfiles);
6521
6522 /**
6523 * Init OpenCL library loader
6524 */
6525
6526 if (keyspace == 0)
6527 {
6528 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6529
6530 ocl_init(ocl);
6531
6532 data.ocl = ocl;
6533 }
6534
6535 /**
6536 * OpenCL platform selection
6537 */
6538
6539 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6540
6541 /**
6542 * OpenCL device selection
6543 */
6544
6545 u32 devices_filter = setup_devices_filter (opencl_devices);
6546
6547 /**
6548 * OpenCL device type selection
6549 */
6550
6551 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6552
6553 /**
6554 * benchmark
6555 */
6556
6557 if (benchmark == 1)
6558 {
6559 /**
6560 * disable useless stuff for benchmark
6561 */
6562
6563 restore_timer = 0;
6564 status_timer = 0;
6565 restore_disable = 1;
6566 potfile_disable = 1;
6567 weak_hash_threshold = 0;
6568
6569 data.restore_timer = restore_timer;
6570 data.status_timer = status_timer;
6571 data.restore_disable = restore_disable;
6572
6573 if (benchmark_mode == 1)
6574 {
6575 markov_disable = 1;
6576 }
6577
6578 /**
6579 * force attack mode to be bruteforce
6580 */
6581
6582 attack_mode = ATTACK_MODE_BF;
6583 attack_kern = ATTACK_KERN_BF;
6584
6585 if (runtime_chgd == 0)
6586 {
6587 runtime = 8;
6588
6589 if (benchmark_mode == 1) runtime = 17;
6590
6591 data.runtime = runtime;
6592 }
6593 }
6594
6595 /**
6596 * config
6597 */
6598
6599 uint hash_type = 0;
6600 uint salt_type = 0;
6601 uint attack_exec = 0;
6602 uint opts_type = 0;
6603 uint kern_type = 0;
6604 uint dgst_size = 0;
6605 uint esalt_size = 0;
6606 uint opti_type = 0;
6607 uint dgst_pos0 = -1;
6608 uint dgst_pos1 = -1;
6609 uint dgst_pos2 = -1;
6610 uint dgst_pos3 = -1;
6611
6612 int (*parse_func) (char *, uint, hash_t *);
6613 int (*sort_by_digest) (const void *, const void *);
6614
6615 uint algorithm_pos = 0;
6616 uint algorithm_max = 1;
6617
6618 uint *algorithms = default_benchmark_algorithms;
6619
6620 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6621
6622 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6623 {
6624 /*
6625 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6626 * the following algos are skipped entirely
6627 */
6628
6629 if (algorithm_pos > 0)
6630 {
6631 local_free (rd);
6632
6633 rd = init_restore (argc, argv);
6634
6635 data.rd = rd;
6636 }
6637
6638 /**
6639 * update hash_mode in case of multihash benchmark
6640 */
6641
6642 if (benchmark == 1)
6643 {
6644 if (hash_mode_chgd == 0)
6645 {
6646 hash_mode = algorithms[algorithm_pos];
6647
6648 data.hash_mode = hash_mode;
6649 }
6650
6651 quiet = 1;
6652
6653 data.quiet = quiet;
6654 }
6655
6656 switch (hash_mode)
6657 {
6658 case 0: hash_type = HASH_TYPE_MD5;
6659 salt_type = SALT_TYPE_NONE;
6660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6661 opts_type = OPTS_TYPE_PT_GENERATE_LE
6662 | OPTS_TYPE_PT_ADD80
6663 | OPTS_TYPE_PT_ADDBITS14;
6664 kern_type = KERN_TYPE_MD5;
6665 dgst_size = DGST_SIZE_4_4;
6666 parse_func = md5_parse_hash;
6667 sort_by_digest = sort_by_digest_4_4;
6668 opti_type = OPTI_TYPE_ZERO_BYTE
6669 | OPTI_TYPE_PRECOMPUTE_INIT
6670 | OPTI_TYPE_PRECOMPUTE_MERKLE
6671 | OPTI_TYPE_MEET_IN_MIDDLE
6672 | OPTI_TYPE_EARLY_SKIP
6673 | OPTI_TYPE_NOT_ITERATED
6674 | OPTI_TYPE_NOT_SALTED
6675 | OPTI_TYPE_RAW_HASH;
6676 dgst_pos0 = 0;
6677 dgst_pos1 = 3;
6678 dgst_pos2 = 2;
6679 dgst_pos3 = 1;
6680 break;
6681
6682 case 10: hash_type = HASH_TYPE_MD5;
6683 salt_type = SALT_TYPE_INTERN;
6684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6685 opts_type = OPTS_TYPE_PT_GENERATE_LE
6686 | OPTS_TYPE_ST_ADD80
6687 | OPTS_TYPE_ST_ADDBITS14;
6688 kern_type = KERN_TYPE_MD5_PWSLT;
6689 dgst_size = DGST_SIZE_4_4;
6690 parse_func = md5s_parse_hash;
6691 sort_by_digest = sort_by_digest_4_4;
6692 opti_type = OPTI_TYPE_ZERO_BYTE
6693 | OPTI_TYPE_PRECOMPUTE_INIT
6694 | OPTI_TYPE_PRECOMPUTE_MERKLE
6695 | OPTI_TYPE_MEET_IN_MIDDLE
6696 | OPTI_TYPE_EARLY_SKIP
6697 | OPTI_TYPE_NOT_ITERATED
6698 | OPTI_TYPE_APPENDED_SALT
6699 | OPTI_TYPE_RAW_HASH;
6700 dgst_pos0 = 0;
6701 dgst_pos1 = 3;
6702 dgst_pos2 = 2;
6703 dgst_pos3 = 1;
6704 break;
6705
6706 case 11: hash_type = HASH_TYPE_MD5;
6707 salt_type = SALT_TYPE_INTERN;
6708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6709 opts_type = OPTS_TYPE_PT_GENERATE_LE
6710 | OPTS_TYPE_ST_ADD80
6711 | OPTS_TYPE_ST_ADDBITS14;
6712 kern_type = KERN_TYPE_MD5_PWSLT;
6713 dgst_size = DGST_SIZE_4_4;
6714 parse_func = joomla_parse_hash;
6715 sort_by_digest = sort_by_digest_4_4;
6716 opti_type = OPTI_TYPE_ZERO_BYTE
6717 | OPTI_TYPE_PRECOMPUTE_INIT
6718 | OPTI_TYPE_PRECOMPUTE_MERKLE
6719 | OPTI_TYPE_MEET_IN_MIDDLE
6720 | OPTI_TYPE_EARLY_SKIP
6721 | OPTI_TYPE_NOT_ITERATED
6722 | OPTI_TYPE_APPENDED_SALT
6723 | OPTI_TYPE_RAW_HASH;
6724 dgst_pos0 = 0;
6725 dgst_pos1 = 3;
6726 dgst_pos2 = 2;
6727 dgst_pos3 = 1;
6728 break;
6729
6730 case 12: hash_type = HASH_TYPE_MD5;
6731 salt_type = SALT_TYPE_INTERN;
6732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6733 opts_type = OPTS_TYPE_PT_GENERATE_LE
6734 | OPTS_TYPE_ST_ADD80
6735 | OPTS_TYPE_ST_ADDBITS14;
6736 kern_type = KERN_TYPE_MD5_PWSLT;
6737 dgst_size = DGST_SIZE_4_4;
6738 parse_func = postgresql_parse_hash;
6739 sort_by_digest = sort_by_digest_4_4;
6740 opti_type = OPTI_TYPE_ZERO_BYTE
6741 | OPTI_TYPE_PRECOMPUTE_INIT
6742 | OPTI_TYPE_PRECOMPUTE_MERKLE
6743 | OPTI_TYPE_MEET_IN_MIDDLE
6744 | OPTI_TYPE_EARLY_SKIP
6745 | OPTI_TYPE_NOT_ITERATED
6746 | OPTI_TYPE_APPENDED_SALT
6747 | OPTI_TYPE_RAW_HASH;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 20: hash_type = HASH_TYPE_MD5;
6755 salt_type = SALT_TYPE_INTERN;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_LE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS14;
6760 kern_type = KERN_TYPE_MD5_SLTPW;
6761 dgst_size = DGST_SIZE_4_4;
6762 parse_func = md5s_parse_hash;
6763 sort_by_digest = sort_by_digest_4_4;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_PREPENDED_SALT
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 0;
6772 dgst_pos1 = 3;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 21: hash_type = HASH_TYPE_MD5;
6778 salt_type = SALT_TYPE_INTERN;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_LE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS14;
6783 kern_type = KERN_TYPE_MD5_SLTPW;
6784 dgst_size = DGST_SIZE_4_4;
6785 parse_func = osc_parse_hash;
6786 sort_by_digest = sort_by_digest_4_4;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_PREPENDED_SALT
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 0;
6795 dgst_pos1 = 3;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 22: hash_type = HASH_TYPE_MD5;
6801 salt_type = SALT_TYPE_EMBEDDED;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_LE
6804 | OPTS_TYPE_PT_ADD80
6805 | OPTS_TYPE_PT_ADDBITS14;
6806 kern_type = KERN_TYPE_MD5_SLTPW;
6807 dgst_size = DGST_SIZE_4_4;
6808 parse_func = netscreen_parse_hash;
6809 sort_by_digest = sort_by_digest_4_4;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_PREPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 0;
6818 dgst_pos1 = 3;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 23: hash_type = HASH_TYPE_MD5;
6824 salt_type = SALT_TYPE_EMBEDDED;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_LE
6827 | OPTS_TYPE_PT_ADD80
6828 | OPTS_TYPE_PT_ADDBITS14;
6829 kern_type = KERN_TYPE_MD5_SLTPW;
6830 dgst_size = DGST_SIZE_4_4;
6831 parse_func = skype_parse_hash;
6832 sort_by_digest = sort_by_digest_4_4;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_PREPENDED_SALT
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 0;
6841 dgst_pos1 = 3;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 30: hash_type = HASH_TYPE_MD5;
6847 salt_type = SALT_TYPE_INTERN;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_LE
6850 | OPTS_TYPE_PT_UNICODE
6851 | OPTS_TYPE_ST_ADD80
6852 | OPTS_TYPE_ST_ADDBITS14;
6853 kern_type = KERN_TYPE_MD5_PWUSLT;
6854 dgst_size = DGST_SIZE_4_4;
6855 parse_func = md5s_parse_hash;
6856 sort_by_digest = sort_by_digest_4_4;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_MEET_IN_MIDDLE
6861 | OPTI_TYPE_EARLY_SKIP
6862 | OPTI_TYPE_NOT_ITERATED
6863 | OPTI_TYPE_APPENDED_SALT
6864 | OPTI_TYPE_RAW_HASH;
6865 dgst_pos0 = 0;
6866 dgst_pos1 = 3;
6867 dgst_pos2 = 2;
6868 dgst_pos3 = 1;
6869 break;
6870
6871 case 40: hash_type = HASH_TYPE_MD5;
6872 salt_type = SALT_TYPE_INTERN;
6873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6874 opts_type = OPTS_TYPE_PT_GENERATE_LE
6875 | OPTS_TYPE_PT_ADD80
6876 | OPTS_TYPE_PT_ADDBITS14
6877 | OPTS_TYPE_PT_UNICODE;
6878 kern_type = KERN_TYPE_MD5_SLTPWU;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5s_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_EARLY_SKIP
6886 | OPTI_TYPE_NOT_ITERATED
6887 | OPTI_TYPE_PREPENDED_SALT
6888 | OPTI_TYPE_RAW_HASH;
6889 dgst_pos0 = 0;
6890 dgst_pos1 = 3;
6891 dgst_pos2 = 2;
6892 dgst_pos3 = 1;
6893 break;
6894
6895 case 50: hash_type = HASH_TYPE_MD5;
6896 salt_type = SALT_TYPE_INTERN;
6897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6898 opts_type = OPTS_TYPE_PT_GENERATE_LE
6899 | OPTS_TYPE_ST_ADD80
6900 | OPTS_TYPE_ST_ADDBITS14;
6901 kern_type = KERN_TYPE_HMACMD5_PW;
6902 dgst_size = DGST_SIZE_4_4;
6903 parse_func = hmacmd5_parse_hash;
6904 sort_by_digest = sort_by_digest_4_4;
6905 opti_type = OPTI_TYPE_ZERO_BYTE
6906 | OPTI_TYPE_NOT_ITERATED;
6907 dgst_pos0 = 0;
6908 dgst_pos1 = 3;
6909 dgst_pos2 = 2;
6910 dgst_pos3 = 1;
6911 break;
6912
6913 case 60: hash_type = HASH_TYPE_MD5;
6914 salt_type = SALT_TYPE_INTERN;
6915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6916 opts_type = OPTS_TYPE_PT_GENERATE_LE
6917 | OPTS_TYPE_PT_ADD80
6918 | OPTS_TYPE_PT_ADDBITS14;
6919 kern_type = KERN_TYPE_HMACMD5_SLT;
6920 dgst_size = DGST_SIZE_4_4;
6921 parse_func = hmacmd5_parse_hash;
6922 sort_by_digest = sort_by_digest_4_4;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_NOT_ITERATED;
6925 dgst_pos0 = 0;
6926 dgst_pos1 = 3;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 100: hash_type = HASH_TYPE_SHA1;
6932 salt_type = SALT_TYPE_NONE;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_BE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS15;
6937 kern_type = KERN_TYPE_SHA1;
6938 dgst_size = DGST_SIZE_4_5;
6939 parse_func = sha1_parse_hash;
6940 sort_by_digest = sort_by_digest_4_5;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_EARLY_SKIP
6945 | OPTI_TYPE_NOT_ITERATED
6946 | OPTI_TYPE_NOT_SALTED
6947 | OPTI_TYPE_RAW_HASH;
6948 dgst_pos0 = 3;
6949 dgst_pos1 = 4;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 101: hash_type = HASH_TYPE_SHA1;
6955 salt_type = SALT_TYPE_NONE;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_BE
6958 | OPTS_TYPE_PT_ADD80
6959 | OPTS_TYPE_PT_ADDBITS15;
6960 kern_type = KERN_TYPE_SHA1;
6961 dgst_size = DGST_SIZE_4_5;
6962 parse_func = sha1b64_parse_hash;
6963 sort_by_digest = sort_by_digest_4_5;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_NOT_SALTED
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 3;
6972 dgst_pos1 = 4;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 110: hash_type = HASH_TYPE_SHA1;
6978 salt_type = SALT_TYPE_INTERN;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_BE
6981 | OPTS_TYPE_ST_ADD80
6982 | OPTS_TYPE_ST_ADDBITS15;
6983 kern_type = KERN_TYPE_SHA1_PWSLT;
6984 dgst_size = DGST_SIZE_4_5;
6985 parse_func = sha1s_parse_hash;
6986 sort_by_digest = sort_by_digest_4_5;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_APPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 3;
6995 dgst_pos1 = 4;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 111: hash_type = HASH_TYPE_SHA1;
7001 salt_type = SALT_TYPE_EMBEDDED;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_BE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS15;
7006 kern_type = KERN_TYPE_SHA1_PWSLT;
7007 dgst_size = DGST_SIZE_4_5;
7008 parse_func = sha1b64s_parse_hash;
7009 sort_by_digest = sort_by_digest_4_5;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_PRECOMPUTE_INIT
7012 | OPTI_TYPE_PRECOMPUTE_MERKLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_APPENDED_SALT
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 3;
7018 dgst_pos1 = 4;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 112: hash_type = HASH_TYPE_SHA1;
7024 salt_type = SALT_TYPE_INTERN;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_BE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS15
7029 | OPTS_TYPE_ST_HEX;
7030 kern_type = KERN_TYPE_SHA1_PWSLT;
7031 dgst_size = DGST_SIZE_4_5;
7032 parse_func = oracles_parse_hash;
7033 sort_by_digest = sort_by_digest_4_5;
7034 opti_type = OPTI_TYPE_ZERO_BYTE
7035 | OPTI_TYPE_PRECOMPUTE_INIT
7036 | OPTI_TYPE_PRECOMPUTE_MERKLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_APPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 3;
7042 dgst_pos1 = 4;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 120: hash_type = HASH_TYPE_SHA1;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_BE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS15;
7053 kern_type = KERN_TYPE_SHA1_SLTPW;
7054 dgst_size = DGST_SIZE_4_5;
7055 parse_func = sha1s_parse_hash;
7056 sort_by_digest = sort_by_digest_4_5;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_EARLY_SKIP
7061 | OPTI_TYPE_NOT_ITERATED
7062 | OPTI_TYPE_PREPENDED_SALT
7063 | OPTI_TYPE_RAW_HASH;
7064 dgst_pos0 = 3;
7065 dgst_pos1 = 4;
7066 dgst_pos2 = 2;
7067 dgst_pos3 = 1;
7068 break;
7069
7070 case 121: hash_type = HASH_TYPE_SHA1;
7071 salt_type = SALT_TYPE_INTERN;
7072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7073 opts_type = OPTS_TYPE_PT_GENERATE_BE
7074 | OPTS_TYPE_PT_ADD80
7075 | OPTS_TYPE_PT_ADDBITS15
7076 | OPTS_TYPE_ST_LOWER;
7077 kern_type = KERN_TYPE_SHA1_SLTPW;
7078 dgst_size = DGST_SIZE_4_5;
7079 parse_func = smf_parse_hash;
7080 sort_by_digest = sort_by_digest_4_5;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_EARLY_SKIP
7085 | OPTI_TYPE_NOT_ITERATED
7086 | OPTI_TYPE_PREPENDED_SALT
7087 | OPTI_TYPE_RAW_HASH;
7088 dgst_pos0 = 3;
7089 dgst_pos1 = 4;
7090 dgst_pos2 = 2;
7091 dgst_pos3 = 1;
7092 break;
7093
7094 case 122: hash_type = HASH_TYPE_SHA1;
7095 salt_type = SALT_TYPE_EMBEDDED;
7096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7097 opts_type = OPTS_TYPE_PT_GENERATE_BE
7098 | OPTS_TYPE_PT_ADD80
7099 | OPTS_TYPE_PT_ADDBITS15
7100 | OPTS_TYPE_ST_HEX;
7101 kern_type = KERN_TYPE_SHA1_SLTPW;
7102 dgst_size = DGST_SIZE_4_5;
7103 parse_func = osx1_parse_hash;
7104 sort_by_digest = sort_by_digest_4_5;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_PREPENDED_SALT
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 3;
7113 dgst_pos1 = 4;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 124: hash_type = HASH_TYPE_SHA1;
7119 salt_type = SALT_TYPE_EMBEDDED;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_BE
7122 | OPTS_TYPE_PT_ADD80
7123 | OPTS_TYPE_PT_ADDBITS15;
7124 kern_type = KERN_TYPE_SHA1_SLTPW;
7125 dgst_size = DGST_SIZE_4_5;
7126 parse_func = djangosha1_parse_hash;
7127 sort_by_digest = sort_by_digest_4_5;
7128 opti_type = OPTI_TYPE_ZERO_BYTE
7129 | OPTI_TYPE_PRECOMPUTE_INIT
7130 | OPTI_TYPE_PRECOMPUTE_MERKLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_PREPENDED_SALT
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 3;
7136 dgst_pos1 = 4;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 130: hash_type = HASH_TYPE_SHA1;
7142 salt_type = SALT_TYPE_INTERN;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_BE
7145 | OPTS_TYPE_PT_UNICODE
7146 | OPTS_TYPE_ST_ADD80
7147 | OPTS_TYPE_ST_ADDBITS15;
7148 kern_type = KERN_TYPE_SHA1_PWUSLT;
7149 dgst_size = DGST_SIZE_4_5;
7150 parse_func = sha1s_parse_hash;
7151 sort_by_digest = sort_by_digest_4_5;
7152 opti_type = OPTI_TYPE_ZERO_BYTE
7153 | OPTI_TYPE_PRECOMPUTE_INIT
7154 | OPTI_TYPE_PRECOMPUTE_MERKLE
7155 | OPTI_TYPE_EARLY_SKIP
7156 | OPTI_TYPE_NOT_ITERATED
7157 | OPTI_TYPE_APPENDED_SALT
7158 | OPTI_TYPE_RAW_HASH;
7159 dgst_pos0 = 3;
7160 dgst_pos1 = 4;
7161 dgst_pos2 = 2;
7162 dgst_pos3 = 1;
7163 break;
7164
7165 case 131: hash_type = HASH_TYPE_SHA1;
7166 salt_type = SALT_TYPE_EMBEDDED;
7167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7168 opts_type = OPTS_TYPE_PT_GENERATE_BE
7169 | OPTS_TYPE_PT_UNICODE
7170 | OPTS_TYPE_PT_UPPER
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15
7173 | OPTS_TYPE_ST_HEX;
7174 kern_type = KERN_TYPE_SHA1_PWUSLT;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = mssql2000_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_APPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 132: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_EMBEDDED;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_PT_UNICODE
7196 | OPTS_TYPE_ST_ADD80
7197 | OPTS_TYPE_ST_ADDBITS15
7198 | OPTS_TYPE_ST_HEX;
7199 kern_type = KERN_TYPE_SHA1_PWUSLT;
7200 dgst_size = DGST_SIZE_4_5;
7201 parse_func = mssql2005_parse_hash;
7202 sort_by_digest = sort_by_digest_4_5;
7203 opti_type = OPTI_TYPE_ZERO_BYTE
7204 | OPTI_TYPE_PRECOMPUTE_INIT
7205 | OPTI_TYPE_PRECOMPUTE_MERKLE
7206 | OPTI_TYPE_EARLY_SKIP
7207 | OPTI_TYPE_NOT_ITERATED
7208 | OPTI_TYPE_APPENDED_SALT
7209 | OPTI_TYPE_RAW_HASH;
7210 dgst_pos0 = 3;
7211 dgst_pos1 = 4;
7212 dgst_pos2 = 2;
7213 dgst_pos3 = 1;
7214 break;
7215
7216 case 133: hash_type = HASH_TYPE_SHA1;
7217 salt_type = SALT_TYPE_EMBEDDED;
7218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7219 opts_type = OPTS_TYPE_PT_GENERATE_BE
7220 | OPTS_TYPE_PT_UNICODE
7221 | OPTS_TYPE_ST_ADD80
7222 | OPTS_TYPE_ST_ADDBITS15;
7223 kern_type = KERN_TYPE_SHA1_PWUSLT;
7224 dgst_size = DGST_SIZE_4_5;
7225 parse_func = peoplesoft_parse_hash;
7226 sort_by_digest = sort_by_digest_4_5;
7227 opti_type = OPTI_TYPE_ZERO_BYTE
7228 | OPTI_TYPE_PRECOMPUTE_INIT
7229 | OPTI_TYPE_PRECOMPUTE_MERKLE
7230 | OPTI_TYPE_EARLY_SKIP
7231 | OPTI_TYPE_NOT_ITERATED
7232 | OPTI_TYPE_APPENDED_SALT
7233 | OPTI_TYPE_RAW_HASH;
7234 dgst_pos0 = 3;
7235 dgst_pos1 = 4;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 1;
7238 break;
7239
7240 case 140: hash_type = HASH_TYPE_SHA1;
7241 salt_type = SALT_TYPE_INTERN;
7242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_BE
7244 | OPTS_TYPE_PT_ADD80
7245 | OPTS_TYPE_PT_ADDBITS15
7246 | OPTS_TYPE_PT_UNICODE;
7247 kern_type = KERN_TYPE_SHA1_SLTPWU;
7248 dgst_size = DGST_SIZE_4_5;
7249 parse_func = sha1s_parse_hash;
7250 sort_by_digest = sort_by_digest_4_5;
7251 opti_type = OPTI_TYPE_ZERO_BYTE
7252 | OPTI_TYPE_PRECOMPUTE_INIT
7253 | OPTI_TYPE_PRECOMPUTE_MERKLE
7254 | OPTI_TYPE_EARLY_SKIP
7255 | OPTI_TYPE_NOT_ITERATED
7256 | OPTI_TYPE_PREPENDED_SALT
7257 | OPTI_TYPE_RAW_HASH;
7258 dgst_pos0 = 3;
7259 dgst_pos1 = 4;
7260 dgst_pos2 = 2;
7261 dgst_pos3 = 1;
7262 break;
7263
7264 case 141: hash_type = HASH_TYPE_SHA1;
7265 salt_type = SALT_TYPE_EMBEDDED;
7266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7267 opts_type = OPTS_TYPE_PT_GENERATE_BE
7268 | OPTS_TYPE_PT_ADD80
7269 | OPTS_TYPE_PT_ADDBITS15
7270 | OPTS_TYPE_PT_UNICODE
7271 | OPTS_TYPE_ST_BASE64;
7272 kern_type = KERN_TYPE_SHA1_SLTPWU;
7273 dgst_size = DGST_SIZE_4_5;
7274 parse_func = episerver_parse_hash;
7275 sort_by_digest = sort_by_digest_4_5;
7276 opti_type = OPTI_TYPE_ZERO_BYTE
7277 | OPTI_TYPE_PRECOMPUTE_INIT
7278 | OPTI_TYPE_PRECOMPUTE_MERKLE
7279 | OPTI_TYPE_EARLY_SKIP
7280 | OPTI_TYPE_NOT_ITERATED
7281 | OPTI_TYPE_PREPENDED_SALT
7282 | OPTI_TYPE_RAW_HASH;
7283 dgst_pos0 = 3;
7284 dgst_pos1 = 4;
7285 dgst_pos2 = 2;
7286 dgst_pos3 = 1;
7287 break;
7288
7289 case 150: hash_type = HASH_TYPE_SHA1;
7290 salt_type = SALT_TYPE_INTERN;
7291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7292 opts_type = OPTS_TYPE_PT_GENERATE_BE
7293 | OPTS_TYPE_ST_ADD80
7294 | OPTS_TYPE_ST_ADDBITS15;
7295 kern_type = KERN_TYPE_HMACSHA1_PW;
7296 dgst_size = DGST_SIZE_4_5;
7297 parse_func = hmacsha1_parse_hash;
7298 sort_by_digest = sort_by_digest_4_5;
7299 opti_type = OPTI_TYPE_ZERO_BYTE
7300 | OPTI_TYPE_NOT_ITERATED;
7301 dgst_pos0 = 3;
7302 dgst_pos1 = 4;
7303 dgst_pos2 = 2;
7304 dgst_pos3 = 1;
7305 break;
7306
7307 case 160: hash_type = HASH_TYPE_SHA1;
7308 salt_type = SALT_TYPE_INTERN;
7309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7310 opts_type = OPTS_TYPE_PT_GENERATE_BE
7311 | OPTS_TYPE_PT_ADD80
7312 | OPTS_TYPE_PT_ADDBITS15;
7313 kern_type = KERN_TYPE_HMACSHA1_SLT;
7314 dgst_size = DGST_SIZE_4_5;
7315 parse_func = hmacsha1_parse_hash;
7316 sort_by_digest = sort_by_digest_4_5;
7317 opti_type = OPTI_TYPE_ZERO_BYTE
7318 | OPTI_TYPE_NOT_ITERATED;
7319 dgst_pos0 = 3;
7320 dgst_pos1 = 4;
7321 dgst_pos2 = 2;
7322 dgst_pos3 = 1;
7323 break;
7324
7325 case 190: hash_type = HASH_TYPE_SHA1;
7326 salt_type = SALT_TYPE_NONE;
7327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7328 opts_type = OPTS_TYPE_PT_GENERATE_BE
7329 | OPTS_TYPE_PT_ADD80
7330 | OPTS_TYPE_PT_ADDBITS15;
7331 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7332 dgst_size = DGST_SIZE_4_5;
7333 parse_func = sha1linkedin_parse_hash;
7334 sort_by_digest = sort_by_digest_4_5;
7335 opti_type = OPTI_TYPE_ZERO_BYTE
7336 | OPTI_TYPE_PRECOMPUTE_INIT
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_NOT_SALTED;
7340 dgst_pos0 = 0;
7341 dgst_pos1 = 4;
7342 dgst_pos2 = 3;
7343 dgst_pos3 = 2;
7344 break;
7345
7346 case 200: hash_type = HASH_TYPE_MYSQL;
7347 salt_type = SALT_TYPE_NONE;
7348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7349 opts_type = 0;
7350 kern_type = KERN_TYPE_MYSQL;
7351 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7352 parse_func = mysql323_parse_hash;
7353 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7354 opti_type = OPTI_TYPE_ZERO_BYTE;
7355 dgst_pos0 = 0;
7356 dgst_pos1 = 1;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 3;
7359 break;
7360
7361 case 300: hash_type = HASH_TYPE_SHA1;
7362 salt_type = SALT_TYPE_NONE;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_BE
7365 | OPTS_TYPE_PT_ADD80
7366 | OPTS_TYPE_PT_ADDBITS15;
7367 kern_type = KERN_TYPE_MYSQL41;
7368 dgst_size = DGST_SIZE_4_5;
7369 parse_func = sha1_parse_hash;
7370 sort_by_digest = sort_by_digest_4_5;
7371 opti_type = OPTI_TYPE_ZERO_BYTE
7372 | OPTI_TYPE_PRECOMPUTE_INIT
7373 | OPTI_TYPE_PRECOMPUTE_MERKLE
7374 | OPTI_TYPE_EARLY_SKIP
7375 | OPTI_TYPE_NOT_ITERATED
7376 | OPTI_TYPE_NOT_SALTED;
7377 dgst_pos0 = 3;
7378 dgst_pos1 = 4;
7379 dgst_pos2 = 2;
7380 dgst_pos3 = 1;
7381 break;
7382
7383 case 400: hash_type = HASH_TYPE_MD5;
7384 salt_type = SALT_TYPE_EMBEDDED;
7385 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7386 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7387 kern_type = KERN_TYPE_PHPASS;
7388 dgst_size = DGST_SIZE_4_4;
7389 parse_func = phpass_parse_hash;
7390 sort_by_digest = sort_by_digest_4_4;
7391 opti_type = OPTI_TYPE_ZERO_BYTE;
7392 dgst_pos0 = 0;
7393 dgst_pos1 = 1;
7394 dgst_pos2 = 2;
7395 dgst_pos3 = 3;
7396 break;
7397
7398 case 500: hash_type = HASH_TYPE_MD5;
7399 salt_type = SALT_TYPE_EMBEDDED;
7400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7402 kern_type = KERN_TYPE_MD5CRYPT;
7403 dgst_size = DGST_SIZE_4_4;
7404 parse_func = md5crypt_parse_hash;
7405 sort_by_digest = sort_by_digest_4_4;
7406 opti_type = OPTI_TYPE_ZERO_BYTE;
7407 dgst_pos0 = 0;
7408 dgst_pos1 = 1;
7409 dgst_pos2 = 2;
7410 dgst_pos3 = 3;
7411 break;
7412
7413 case 501: hash_type = HASH_TYPE_MD5;
7414 salt_type = SALT_TYPE_EMBEDDED;
7415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7416 opts_type = OPTS_TYPE_PT_GENERATE_LE
7417 | OPTS_TYPE_HASH_COPY;
7418 kern_type = KERN_TYPE_MD5CRYPT;
7419 dgst_size = DGST_SIZE_4_4;
7420 parse_func = juniper_parse_hash;
7421 sort_by_digest = sort_by_digest_4_4;
7422 opti_type = OPTI_TYPE_ZERO_BYTE;
7423 dgst_pos0 = 0;
7424 dgst_pos1 = 1;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 3;
7427 break;
7428
7429 case 900: hash_type = HASH_TYPE_MD4;
7430 salt_type = SALT_TYPE_NONE;
7431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_LE
7433 | OPTS_TYPE_PT_ADD80
7434 | OPTS_TYPE_PT_ADDBITS14;
7435 kern_type = KERN_TYPE_MD4;
7436 dgst_size = DGST_SIZE_4_4;
7437 parse_func = md4_parse_hash;
7438 sort_by_digest = sort_by_digest_4_4;
7439 opti_type = OPTI_TYPE_ZERO_BYTE
7440 | OPTI_TYPE_PRECOMPUTE_INIT
7441 | OPTI_TYPE_PRECOMPUTE_MERKLE
7442 | OPTI_TYPE_MEET_IN_MIDDLE
7443 | OPTI_TYPE_EARLY_SKIP
7444 | OPTI_TYPE_NOT_ITERATED
7445 | OPTI_TYPE_NOT_SALTED
7446 | OPTI_TYPE_RAW_HASH;
7447 dgst_pos0 = 0;
7448 dgst_pos1 = 3;
7449 dgst_pos2 = 2;
7450 dgst_pos3 = 1;
7451 break;
7452
7453 case 1000: hash_type = HASH_TYPE_MD4;
7454 salt_type = SALT_TYPE_NONE;
7455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7456 opts_type = OPTS_TYPE_PT_GENERATE_LE
7457 | OPTS_TYPE_PT_ADD80
7458 | OPTS_TYPE_PT_ADDBITS14
7459 | OPTS_TYPE_PT_UNICODE;
7460 kern_type = KERN_TYPE_MD4_PWU;
7461 dgst_size = DGST_SIZE_4_4;
7462 parse_func = md4_parse_hash;
7463 sort_by_digest = sort_by_digest_4_4;
7464 opti_type = OPTI_TYPE_ZERO_BYTE
7465 | OPTI_TYPE_PRECOMPUTE_INIT
7466 | OPTI_TYPE_PRECOMPUTE_MERKLE
7467 | OPTI_TYPE_MEET_IN_MIDDLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_NOT_SALTED
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 0;
7473 dgst_pos1 = 3;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 1100: hash_type = HASH_TYPE_MD4;
7479 salt_type = SALT_TYPE_INTERN;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_LE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS14
7484 | OPTS_TYPE_PT_UNICODE
7485 | OPTS_TYPE_ST_ADD80
7486 | OPTS_TYPE_ST_UNICODE
7487 | OPTS_TYPE_ST_LOWER;
7488 kern_type = KERN_TYPE_MD44_PWUSLT;
7489 dgst_size = DGST_SIZE_4_4;
7490 parse_func = dcc_parse_hash;
7491 sort_by_digest = sort_by_digest_4_4;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_PRECOMPUTE_INIT
7494 | OPTI_TYPE_PRECOMPUTE_MERKLE
7495 | OPTI_TYPE_EARLY_SKIP
7496 | OPTI_TYPE_NOT_ITERATED;
7497 dgst_pos0 = 0;
7498 dgst_pos1 = 3;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 1;
7501 break;
7502
7503 case 1400: hash_type = HASH_TYPE_SHA256;
7504 salt_type = SALT_TYPE_NONE;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_PT_ADD80
7508 | OPTS_TYPE_PT_ADDBITS15;
7509 kern_type = KERN_TYPE_SHA256;
7510 dgst_size = DGST_SIZE_4_8;
7511 parse_func = sha256_parse_hash;
7512 sort_by_digest = sort_by_digest_4_8;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_PRECOMPUTE_INIT
7515 | OPTI_TYPE_PRECOMPUTE_MERKLE
7516 | OPTI_TYPE_EARLY_SKIP
7517 | OPTI_TYPE_NOT_ITERATED
7518 | OPTI_TYPE_NOT_SALTED
7519 | OPTI_TYPE_RAW_HASH;
7520 dgst_pos0 = 3;
7521 dgst_pos1 = 7;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 6;
7524 break;
7525
7526 case 1410: hash_type = HASH_TYPE_SHA256;
7527 salt_type = SALT_TYPE_INTERN;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_BE
7530 | OPTS_TYPE_ST_ADD80
7531 | OPTS_TYPE_ST_ADDBITS15;
7532 kern_type = KERN_TYPE_SHA256_PWSLT;
7533 dgst_size = DGST_SIZE_4_8;
7534 parse_func = sha256s_parse_hash;
7535 sort_by_digest = sort_by_digest_4_8;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_EARLY_SKIP
7540 | OPTI_TYPE_NOT_ITERATED
7541 | OPTI_TYPE_APPENDED_SALT
7542 | OPTI_TYPE_RAW_HASH;
7543 dgst_pos0 = 3;
7544 dgst_pos1 = 7;
7545 dgst_pos2 = 2;
7546 dgst_pos3 = 6;
7547 break;
7548
7549 case 1420: hash_type = HASH_TYPE_SHA256;
7550 salt_type = SALT_TYPE_INTERN;
7551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7552 opts_type = OPTS_TYPE_PT_GENERATE_BE
7553 | OPTS_TYPE_PT_ADD80
7554 | OPTS_TYPE_PT_ADDBITS15;
7555 kern_type = KERN_TYPE_SHA256_SLTPW;
7556 dgst_size = DGST_SIZE_4_8;
7557 parse_func = sha256s_parse_hash;
7558 sort_by_digest = sort_by_digest_4_8;
7559 opti_type = OPTI_TYPE_ZERO_BYTE
7560 | OPTI_TYPE_PRECOMPUTE_INIT
7561 | OPTI_TYPE_PRECOMPUTE_MERKLE
7562 | OPTI_TYPE_EARLY_SKIP
7563 | OPTI_TYPE_NOT_ITERATED
7564 | OPTI_TYPE_PREPENDED_SALT
7565 | OPTI_TYPE_RAW_HASH;
7566 dgst_pos0 = 3;
7567 dgst_pos1 = 7;
7568 dgst_pos2 = 2;
7569 dgst_pos3 = 6;
7570 break;
7571
7572 case 1421: hash_type = HASH_TYPE_SHA256;
7573 salt_type = SALT_TYPE_EMBEDDED;
7574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7575 opts_type = OPTS_TYPE_PT_GENERATE_BE
7576 | OPTS_TYPE_PT_ADD80
7577 | OPTS_TYPE_PT_ADDBITS15;
7578 kern_type = KERN_TYPE_SHA256_SLTPW;
7579 dgst_size = DGST_SIZE_4_8;
7580 parse_func = hmailserver_parse_hash;
7581 sort_by_digest = sort_by_digest_4_8;
7582 opti_type = OPTI_TYPE_ZERO_BYTE
7583 | OPTI_TYPE_PRECOMPUTE_INIT
7584 | OPTI_TYPE_PRECOMPUTE_MERKLE
7585 | OPTI_TYPE_EARLY_SKIP
7586 | OPTI_TYPE_NOT_ITERATED
7587 | OPTI_TYPE_PREPENDED_SALT
7588 | OPTI_TYPE_RAW_HASH;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 7;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 6;
7593 break;
7594
7595 case 1430: hash_type = HASH_TYPE_SHA256;
7596 salt_type = SALT_TYPE_INTERN;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_UNICODE
7600 | OPTS_TYPE_ST_ADD80
7601 | OPTS_TYPE_ST_ADDBITS15;
7602 kern_type = KERN_TYPE_SHA256_PWUSLT;
7603 dgst_size = DGST_SIZE_4_8;
7604 parse_func = sha256s_parse_hash;
7605 sort_by_digest = sort_by_digest_4_8;
7606 opti_type = OPTI_TYPE_ZERO_BYTE
7607 | OPTI_TYPE_PRECOMPUTE_INIT
7608 | OPTI_TYPE_PRECOMPUTE_MERKLE
7609 | OPTI_TYPE_EARLY_SKIP
7610 | OPTI_TYPE_NOT_ITERATED
7611 | OPTI_TYPE_APPENDED_SALT
7612 | OPTI_TYPE_RAW_HASH;
7613 dgst_pos0 = 3;
7614 dgst_pos1 = 7;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 6;
7617 break;
7618
7619 case 1440: hash_type = HASH_TYPE_SHA256;
7620 salt_type = SALT_TYPE_INTERN;
7621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_BE
7623 | OPTS_TYPE_PT_ADD80
7624 | OPTS_TYPE_PT_ADDBITS15
7625 | OPTS_TYPE_PT_UNICODE;
7626 kern_type = KERN_TYPE_SHA256_SLTPWU;
7627 dgst_size = DGST_SIZE_4_8;
7628 parse_func = sha256s_parse_hash;
7629 sort_by_digest = sort_by_digest_4_8;
7630 opti_type = OPTI_TYPE_ZERO_BYTE
7631 | OPTI_TYPE_PRECOMPUTE_INIT
7632 | OPTI_TYPE_PRECOMPUTE_MERKLE
7633 | OPTI_TYPE_EARLY_SKIP
7634 | OPTI_TYPE_NOT_ITERATED
7635 | OPTI_TYPE_PREPENDED_SALT
7636 | OPTI_TYPE_RAW_HASH;
7637 dgst_pos0 = 3;
7638 dgst_pos1 = 7;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 6;
7641 break;
7642
7643 case 1441: hash_type = HASH_TYPE_SHA256;
7644 salt_type = SALT_TYPE_EMBEDDED;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_BE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS15
7649 | OPTS_TYPE_PT_UNICODE
7650 | OPTS_TYPE_ST_BASE64;
7651 kern_type = KERN_TYPE_SHA256_SLTPWU;
7652 dgst_size = DGST_SIZE_4_8;
7653 parse_func = episerver4_parse_hash;
7654 sort_by_digest = sort_by_digest_4_8;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_PRECOMPUTE_INIT
7657 | OPTI_TYPE_PRECOMPUTE_MERKLE
7658 | OPTI_TYPE_EARLY_SKIP
7659 | OPTI_TYPE_NOT_ITERATED
7660 | OPTI_TYPE_PREPENDED_SALT
7661 | OPTI_TYPE_RAW_HASH;
7662 dgst_pos0 = 3;
7663 dgst_pos1 = 7;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 6;
7666 break;
7667
7668 case 1450: hash_type = HASH_TYPE_SHA256;
7669 salt_type = SALT_TYPE_INTERN;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_BE
7672 | OPTS_TYPE_ST_ADD80;
7673 kern_type = KERN_TYPE_HMACSHA256_PW;
7674 dgst_size = DGST_SIZE_4_8;
7675 parse_func = hmacsha256_parse_hash;
7676 sort_by_digest = sort_by_digest_4_8;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_NOT_ITERATED;
7679 dgst_pos0 = 3;
7680 dgst_pos1 = 7;
7681 dgst_pos2 = 2;
7682 dgst_pos3 = 6;
7683 break;
7684
7685 case 1460: hash_type = HASH_TYPE_SHA256;
7686 salt_type = SALT_TYPE_INTERN;
7687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7688 opts_type = OPTS_TYPE_PT_GENERATE_BE
7689 | OPTS_TYPE_PT_ADD80
7690 | OPTS_TYPE_PT_ADDBITS15;
7691 kern_type = KERN_TYPE_HMACSHA256_SLT;
7692 dgst_size = DGST_SIZE_4_8;
7693 parse_func = hmacsha256_parse_hash;
7694 sort_by_digest = sort_by_digest_4_8;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_NOT_ITERATED;
7697 dgst_pos0 = 3;
7698 dgst_pos1 = 7;
7699 dgst_pos2 = 2;
7700 dgst_pos3 = 6;
7701 break;
7702
7703 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7704 salt_type = SALT_TYPE_EMBEDDED;
7705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7706 opts_type = OPTS_TYPE_PT_GENERATE_LE
7707 | OPTS_TYPE_PT_BITSLICE;
7708 kern_type = KERN_TYPE_DESCRYPT;
7709 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7710 parse_func = descrypt_parse_hash;
7711 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7714 dgst_pos0 = 0;
7715 dgst_pos1 = 1;
7716 dgst_pos2 = 2;
7717 dgst_pos3 = 3;
7718 break;
7719
7720 case 1600: hash_type = HASH_TYPE_MD5;
7721 salt_type = SALT_TYPE_EMBEDDED;
7722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7724 kern_type = KERN_TYPE_APR1CRYPT;
7725 dgst_size = DGST_SIZE_4_4;
7726 parse_func = md5apr1_parse_hash;
7727 sort_by_digest = sort_by_digest_4_4;
7728 opti_type = OPTI_TYPE_ZERO_BYTE;
7729 dgst_pos0 = 0;
7730 dgst_pos1 = 1;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 3;
7733 break;
7734
7735 case 1700: hash_type = HASH_TYPE_SHA512;
7736 salt_type = SALT_TYPE_NONE;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_BE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS15;
7741 kern_type = KERN_TYPE_SHA512;
7742 dgst_size = DGST_SIZE_8_8;
7743 parse_func = sha512_parse_hash;
7744 sort_by_digest = sort_by_digest_8_8;
7745 opti_type = OPTI_TYPE_ZERO_BYTE
7746 | OPTI_TYPE_PRECOMPUTE_INIT
7747 | OPTI_TYPE_PRECOMPUTE_MERKLE
7748 | OPTI_TYPE_EARLY_SKIP
7749 | OPTI_TYPE_NOT_ITERATED
7750 | OPTI_TYPE_NOT_SALTED
7751 | OPTI_TYPE_USES_BITS_64
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 14;
7754 dgst_pos1 = 15;
7755 dgst_pos2 = 6;
7756 dgst_pos3 = 7;
7757 break;
7758
7759 case 1710: hash_type = HASH_TYPE_SHA512;
7760 salt_type = SALT_TYPE_INTERN;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_ST_ADD80
7764 | OPTS_TYPE_ST_ADDBITS15;
7765 kern_type = KERN_TYPE_SHA512_PWSLT;
7766 dgst_size = DGST_SIZE_8_8;
7767 parse_func = sha512s_parse_hash;
7768 sort_by_digest = sort_by_digest_8_8;
7769 opti_type = OPTI_TYPE_ZERO_BYTE
7770 | OPTI_TYPE_PRECOMPUTE_INIT
7771 | OPTI_TYPE_PRECOMPUTE_MERKLE
7772 | OPTI_TYPE_EARLY_SKIP
7773 | OPTI_TYPE_NOT_ITERATED
7774 | OPTI_TYPE_APPENDED_SALT
7775 | OPTI_TYPE_USES_BITS_64
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1711: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_EMBEDDED;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_ST_ADD80
7788 | OPTS_TYPE_ST_ADDBITS15;
7789 kern_type = KERN_TYPE_SHA512_PWSLT;
7790 dgst_size = DGST_SIZE_8_8;
7791 parse_func = sha512b64s_parse_hash;
7792 sort_by_digest = sort_by_digest_8_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_EARLY_SKIP
7797 | OPTI_TYPE_NOT_ITERATED
7798 | OPTI_TYPE_APPENDED_SALT
7799 | OPTI_TYPE_USES_BITS_64
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 14;
7802 dgst_pos1 = 15;
7803 dgst_pos2 = 6;
7804 dgst_pos3 = 7;
7805 break;
7806
7807 case 1720: hash_type = HASH_TYPE_SHA512;
7808 salt_type = SALT_TYPE_INTERN;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_PT_ADD80
7812 | OPTS_TYPE_PT_ADDBITS15;
7813 kern_type = KERN_TYPE_SHA512_SLTPW;
7814 dgst_size = DGST_SIZE_8_8;
7815 parse_func = sha512s_parse_hash;
7816 sort_by_digest = sort_by_digest_8_8;
7817 opti_type = OPTI_TYPE_ZERO_BYTE
7818 | OPTI_TYPE_PRECOMPUTE_INIT
7819 | OPTI_TYPE_PRECOMPUTE_MERKLE
7820 | OPTI_TYPE_EARLY_SKIP
7821 | OPTI_TYPE_NOT_ITERATED
7822 | OPTI_TYPE_PREPENDED_SALT
7823 | OPTI_TYPE_USES_BITS_64
7824 | OPTI_TYPE_RAW_HASH;
7825 dgst_pos0 = 14;
7826 dgst_pos1 = 15;
7827 dgst_pos2 = 6;
7828 dgst_pos3 = 7;
7829 break;
7830
7831 case 1722: hash_type = HASH_TYPE_SHA512;
7832 salt_type = SALT_TYPE_EMBEDDED;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_BE
7835 | OPTS_TYPE_PT_ADD80
7836 | OPTS_TYPE_PT_ADDBITS15
7837 | OPTS_TYPE_ST_HEX;
7838 kern_type = KERN_TYPE_SHA512_SLTPW;
7839 dgst_size = DGST_SIZE_8_8;
7840 parse_func = osx512_parse_hash;
7841 sort_by_digest = sort_by_digest_8_8;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED
7847 | OPTI_TYPE_PREPENDED_SALT
7848 | OPTI_TYPE_USES_BITS_64
7849 | OPTI_TYPE_RAW_HASH;
7850 dgst_pos0 = 14;
7851 dgst_pos1 = 15;
7852 dgst_pos2 = 6;
7853 dgst_pos3 = 7;
7854 break;
7855
7856 case 1730: hash_type = HASH_TYPE_SHA512;
7857 salt_type = SALT_TYPE_INTERN;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_BE
7860 | OPTS_TYPE_PT_UNICODE
7861 | OPTS_TYPE_ST_ADD80
7862 | OPTS_TYPE_ST_ADDBITS15;
7863 kern_type = KERN_TYPE_SHA512_PWSLTU;
7864 dgst_size = DGST_SIZE_8_8;
7865 parse_func = sha512s_parse_hash;
7866 sort_by_digest = sort_by_digest_8_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_APPENDED_SALT
7873 | OPTI_TYPE_USES_BITS_64
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 14;
7876 dgst_pos1 = 15;
7877 dgst_pos2 = 6;
7878 dgst_pos3 = 7;
7879 break;
7880
7881 case 1731: hash_type = HASH_TYPE_SHA512;
7882 salt_type = SALT_TYPE_EMBEDDED;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_BE
7885 | OPTS_TYPE_PT_UNICODE
7886 | OPTS_TYPE_ST_ADD80
7887 | OPTS_TYPE_ST_ADDBITS15
7888 | OPTS_TYPE_ST_HEX;
7889 kern_type = KERN_TYPE_SHA512_PWSLTU;
7890 dgst_size = DGST_SIZE_8_8;
7891 parse_func = mssql2012_parse_hash;
7892 sort_by_digest = sort_by_digest_8_8;
7893 opti_type = OPTI_TYPE_ZERO_BYTE
7894 | OPTI_TYPE_PRECOMPUTE_INIT
7895 | OPTI_TYPE_PRECOMPUTE_MERKLE
7896 | OPTI_TYPE_EARLY_SKIP
7897 | OPTI_TYPE_NOT_ITERATED
7898 | OPTI_TYPE_APPENDED_SALT
7899 | OPTI_TYPE_USES_BITS_64
7900 | OPTI_TYPE_RAW_HASH;
7901 dgst_pos0 = 14;
7902 dgst_pos1 = 15;
7903 dgst_pos2 = 6;
7904 dgst_pos3 = 7;
7905 break;
7906
7907 case 1740: hash_type = HASH_TYPE_SHA512;
7908 salt_type = SALT_TYPE_INTERN;
7909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7910 opts_type = OPTS_TYPE_PT_GENERATE_BE
7911 | OPTS_TYPE_PT_ADD80
7912 | OPTS_TYPE_PT_ADDBITS15
7913 | OPTS_TYPE_PT_UNICODE;
7914 kern_type = KERN_TYPE_SHA512_SLTPWU;
7915 dgst_size = DGST_SIZE_8_8;
7916 parse_func = sha512s_parse_hash;
7917 sort_by_digest = sort_by_digest_8_8;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_PRECOMPUTE_INIT
7920 | OPTI_TYPE_PRECOMPUTE_MERKLE
7921 | OPTI_TYPE_EARLY_SKIP
7922 | OPTI_TYPE_NOT_ITERATED
7923 | OPTI_TYPE_PREPENDED_SALT
7924 | OPTI_TYPE_USES_BITS_64
7925 | OPTI_TYPE_RAW_HASH;
7926 dgst_pos0 = 14;
7927 dgst_pos1 = 15;
7928 dgst_pos2 = 6;
7929 dgst_pos3 = 7;
7930 break;
7931
7932 case 1750: hash_type = HASH_TYPE_SHA512;
7933 salt_type = SALT_TYPE_INTERN;
7934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7935 opts_type = OPTS_TYPE_PT_GENERATE_BE
7936 | OPTS_TYPE_ST_ADD80;
7937 kern_type = KERN_TYPE_HMACSHA512_PW;
7938 dgst_size = DGST_SIZE_8_8;
7939 parse_func = hmacsha512_parse_hash;
7940 sort_by_digest = sort_by_digest_8_8;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_USES_BITS_64
7943 | OPTI_TYPE_NOT_ITERATED;
7944 dgst_pos0 = 14;
7945 dgst_pos1 = 15;
7946 dgst_pos2 = 6;
7947 dgst_pos3 = 7;
7948 break;
7949
7950 case 1760: hash_type = HASH_TYPE_SHA512;
7951 salt_type = SALT_TYPE_INTERN;
7952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7953 opts_type = OPTS_TYPE_PT_GENERATE_BE
7954 | OPTS_TYPE_PT_ADD80
7955 | OPTS_TYPE_PT_ADDBITS15;
7956 kern_type = KERN_TYPE_HMACSHA512_SLT;
7957 dgst_size = DGST_SIZE_8_8;
7958 parse_func = hmacsha512_parse_hash;
7959 sort_by_digest = sort_by_digest_8_8;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_USES_BITS_64
7962 | OPTI_TYPE_NOT_ITERATED;
7963 dgst_pos0 = 14;
7964 dgst_pos1 = 15;
7965 dgst_pos2 = 6;
7966 dgst_pos3 = 7;
7967 break;
7968
7969 case 1800: hash_type = HASH_TYPE_SHA512;
7970 salt_type = SALT_TYPE_EMBEDDED;
7971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7973 kern_type = KERN_TYPE_SHA512CRYPT;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = sha512crypt_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_USES_BITS_64;
7979 dgst_pos0 = 0;
7980 dgst_pos1 = 1;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 3;
7983 break;
7984
7985 case 2100: hash_type = HASH_TYPE_DCC2;
7986 salt_type = SALT_TYPE_EMBEDDED;
7987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_ST_LOWER
7990 | OPTS_TYPE_ST_UNICODE;
7991 kern_type = KERN_TYPE_DCC2;
7992 dgst_size = DGST_SIZE_4_4;
7993 parse_func = dcc2_parse_hash;
7994 sort_by_digest = sort_by_digest_4_4;
7995 opti_type = OPTI_TYPE_ZERO_BYTE;
7996 dgst_pos0 = 0;
7997 dgst_pos1 = 1;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 3;
8000 break;
8001
8002 case 2400: hash_type = HASH_TYPE_MD5;
8003 salt_type = SALT_TYPE_NONE;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8006 kern_type = KERN_TYPE_MD5PIX;
8007 dgst_size = DGST_SIZE_4_4;
8008 parse_func = md5pix_parse_hash;
8009 sort_by_digest = sort_by_digest_4_4;
8010 opti_type = OPTI_TYPE_ZERO_BYTE
8011 | OPTI_TYPE_PRECOMPUTE_INIT
8012 | OPTI_TYPE_PRECOMPUTE_MERKLE
8013 | OPTI_TYPE_EARLY_SKIP
8014 | OPTI_TYPE_NOT_ITERATED
8015 | OPTI_TYPE_NOT_SALTED;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 3;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 1;
8020 break;
8021
8022 case 2410: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8026 kern_type = KERN_TYPE_MD5ASA;
8027 dgst_size = DGST_SIZE_4_4;
8028 parse_func = md5asa_parse_hash;
8029 sort_by_digest = sort_by_digest_4_4;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP
8034 | OPTI_TYPE_NOT_ITERATED;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 3;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 1;
8039 break;
8040
8041 case 2500: hash_type = HASH_TYPE_WPA;
8042 salt_type = SALT_TYPE_EMBEDDED;
8043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8045 kern_type = KERN_TYPE_WPA;
8046 dgst_size = DGST_SIZE_4_4;
8047 parse_func = wpa_parse_hash;
8048 sort_by_digest = sort_by_digest_4_4;
8049 opti_type = OPTI_TYPE_ZERO_BYTE;
8050 dgst_pos0 = 0;
8051 dgst_pos1 = 1;
8052 dgst_pos2 = 2;
8053 dgst_pos3 = 3;
8054 break;
8055
8056 case 2600: hash_type = HASH_TYPE_MD5;
8057 salt_type = SALT_TYPE_VIRTUAL;
8058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8059 opts_type = OPTS_TYPE_PT_GENERATE_LE
8060 | OPTS_TYPE_PT_ADD80
8061 | OPTS_TYPE_PT_ADDBITS14
8062 | OPTS_TYPE_ST_ADD80;
8063 kern_type = KERN_TYPE_MD55_PWSLT1;
8064 dgst_size = DGST_SIZE_4_4;
8065 parse_func = md5md5_parse_hash;
8066 sort_by_digest = sort_by_digest_4_4;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_INIT
8069 | OPTI_TYPE_PRECOMPUTE_MERKLE
8070 | OPTI_TYPE_EARLY_SKIP;
8071 dgst_pos0 = 0;
8072 dgst_pos1 = 3;
8073 dgst_pos2 = 2;
8074 dgst_pos3 = 1;
8075 break;
8076
8077 case 2611: hash_type = HASH_TYPE_MD5;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_LE
8081 | OPTS_TYPE_PT_ADD80
8082 | OPTS_TYPE_PT_ADDBITS14
8083 | OPTS_TYPE_ST_ADD80;
8084 kern_type = KERN_TYPE_MD55_PWSLT1;
8085 dgst_size = DGST_SIZE_4_4;
8086 parse_func = vb3_parse_hash;
8087 sort_by_digest = sort_by_digest_4_4;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP;
8092 dgst_pos0 = 0;
8093 dgst_pos1 = 3;
8094 dgst_pos2 = 2;
8095 dgst_pos3 = 1;
8096 break;
8097
8098 case 2612: hash_type = HASH_TYPE_MD5;
8099 salt_type = SALT_TYPE_EMBEDDED;
8100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8101 opts_type = OPTS_TYPE_PT_GENERATE_LE
8102 | OPTS_TYPE_PT_ADD80
8103 | OPTS_TYPE_PT_ADDBITS14
8104 | OPTS_TYPE_ST_ADD80
8105 | OPTS_TYPE_ST_HEX;
8106 kern_type = KERN_TYPE_MD55_PWSLT1;
8107 dgst_size = DGST_SIZE_4_4;
8108 parse_func = phps_parse_hash;
8109 sort_by_digest = sort_by_digest_4_4;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 3;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 1;
8118 break;
8119
8120 case 2711: hash_type = HASH_TYPE_MD5;
8121 salt_type = SALT_TYPE_INTERN;
8122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE
8124 | OPTS_TYPE_PT_ADD80
8125 | OPTS_TYPE_PT_ADDBITS14
8126 | OPTS_TYPE_ST_ADD80;
8127 kern_type = KERN_TYPE_MD55_PWSLT2;
8128 dgst_size = DGST_SIZE_4_4;
8129 parse_func = vb30_parse_hash;
8130 sort_by_digest = sort_by_digest_4_4;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_PRECOMPUTE_INIT
8133 | OPTI_TYPE_EARLY_SKIP;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 3;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 1;
8138 break;
8139
8140 case 2811: hash_type = HASH_TYPE_MD5;
8141 salt_type = SALT_TYPE_INTERN;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_LE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS14;
8146 kern_type = KERN_TYPE_MD55_SLTPW;
8147 dgst_size = DGST_SIZE_4_4;
8148 parse_func = ipb2_parse_hash;
8149 sort_by_digest = sort_by_digest_4_4;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_EARLY_SKIP;
8153 dgst_pos0 = 0;
8154 dgst_pos1 = 3;
8155 dgst_pos2 = 2;
8156 dgst_pos3 = 1;
8157 break;
8158
8159 case 3000: hash_type = HASH_TYPE_LM;
8160 salt_type = SALT_TYPE_NONE;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_LE
8163 | OPTS_TYPE_PT_UPPER
8164 | OPTS_TYPE_PT_BITSLICE;
8165 kern_type = KERN_TYPE_LM;
8166 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8167 parse_func = lm_parse_hash;
8168 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8171 dgst_pos0 = 0;
8172 dgst_pos1 = 1;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 3;
8175 break;
8176
8177 case 3100: hash_type = HASH_TYPE_ORACLEH;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE
8181 | OPTS_TYPE_PT_UPPER
8182 | OPTS_TYPE_ST_UPPER;
8183 kern_type = KERN_TYPE_ORACLEH;
8184 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8185 parse_func = oracleh_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8187 opti_type = OPTI_TYPE_ZERO_BYTE;
8188 dgst_pos0 = 0;
8189 dgst_pos1 = 1;
8190 dgst_pos2 = 2;
8191 dgst_pos3 = 3;
8192 break;
8193
8194 case 3200: hash_type = HASH_TYPE_BCRYPT;
8195 salt_type = SALT_TYPE_EMBEDDED;
8196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8197 opts_type = OPTS_TYPE_PT_GENERATE_LE
8198 | OPTS_TYPE_ST_GENERATE_LE;
8199 kern_type = KERN_TYPE_BCRYPT;
8200 dgst_size = DGST_SIZE_4_6;
8201 parse_func = bcrypt_parse_hash;
8202 sort_by_digest = sort_by_digest_4_6;
8203 opti_type = OPTI_TYPE_ZERO_BYTE;
8204 dgst_pos0 = 0;
8205 dgst_pos1 = 1;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 3;
8208 break;
8209
8210 case 3710: hash_type = HASH_TYPE_MD5;
8211 salt_type = SALT_TYPE_INTERN;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE
8214 | OPTS_TYPE_PT_ADD80
8215 | OPTS_TYPE_PT_ADDBITS14;
8216 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8217 dgst_size = DGST_SIZE_4_4;
8218 parse_func = md5s_parse_hash;
8219 sort_by_digest = sort_by_digest_4_4;
8220 opti_type = OPTI_TYPE_ZERO_BYTE
8221 | OPTI_TYPE_PRECOMPUTE_INIT
8222 | OPTI_TYPE_PRECOMPUTE_MERKLE
8223 | OPTI_TYPE_EARLY_SKIP;
8224 dgst_pos0 = 0;
8225 dgst_pos1 = 3;
8226 dgst_pos2 = 2;
8227 dgst_pos3 = 1;
8228 break;
8229
8230 case 3711: hash_type = HASH_TYPE_MD5;
8231 salt_type = SALT_TYPE_EMBEDDED;
8232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE
8234 | OPTS_TYPE_PT_ADD80
8235 | OPTS_TYPE_PT_ADDBITS14;
8236 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8237 dgst_size = DGST_SIZE_4_4;
8238 parse_func = mediawiki_b_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_PRECOMPUTE_INIT
8242 | OPTI_TYPE_PRECOMPUTE_MERKLE
8243 | OPTI_TYPE_EARLY_SKIP;
8244 dgst_pos0 = 0;
8245 dgst_pos1 = 3;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 1;
8248 break;
8249
8250 case 3800: hash_type = HASH_TYPE_MD5;
8251 salt_type = SALT_TYPE_INTERN;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_ST_ADDBITS14;
8255 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8256 dgst_size = DGST_SIZE_4_4;
8257 parse_func = md5s_parse_hash;
8258 sort_by_digest = sort_by_digest_4_4;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP
8263 | OPTI_TYPE_NOT_ITERATED
8264 | OPTI_TYPE_RAW_HASH;
8265 dgst_pos0 = 0;
8266 dgst_pos1 = 3;
8267 dgst_pos2 = 2;
8268 dgst_pos3 = 1;
8269 break;
8270
8271 case 4300: hash_type = HASH_TYPE_MD5;
8272 salt_type = SALT_TYPE_VIRTUAL;
8273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8274 opts_type = OPTS_TYPE_PT_GENERATE_LE
8275 | OPTS_TYPE_PT_ADD80
8276 | OPTS_TYPE_PT_ADDBITS14
8277 | OPTS_TYPE_ST_ADD80;
8278 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8279 dgst_size = DGST_SIZE_4_4;
8280 parse_func = md5md5_parse_hash;
8281 sort_by_digest = sort_by_digest_4_4;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_PRECOMPUTE_INIT
8284 | OPTI_TYPE_PRECOMPUTE_MERKLE
8285 | OPTI_TYPE_EARLY_SKIP;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292
8293 case 4400: hash_type = HASH_TYPE_MD5;
8294 salt_type = SALT_TYPE_NONE;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_BE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS15;
8299 kern_type = KERN_TYPE_MD5_SHA1;
8300 dgst_size = DGST_SIZE_4_4;
8301 parse_func = md5_parse_hash;
8302 sort_by_digest = sort_by_digest_4_4;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_EARLY_SKIP
8307 | OPTI_TYPE_NOT_ITERATED
8308 | OPTI_TYPE_NOT_SALTED
8309 | OPTI_TYPE_RAW_HASH;
8310 dgst_pos0 = 0;
8311 dgst_pos1 = 3;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 1;
8314 break;
8315
8316 case 4500: hash_type = HASH_TYPE_SHA1;
8317 salt_type = SALT_TYPE_NONE;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_BE
8320 | OPTS_TYPE_PT_ADD80
8321 | OPTS_TYPE_PT_ADDBITS15;
8322 kern_type = KERN_TYPE_SHA11;
8323 dgst_size = DGST_SIZE_4_5;
8324 parse_func = sha1_parse_hash;
8325 sort_by_digest = sort_by_digest_4_5;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_SALTED;
8331 dgst_pos0 = 3;
8332 dgst_pos1 = 4;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 1;
8335 break;
8336
8337 case 4700: hash_type = HASH_TYPE_SHA1;
8338 salt_type = SALT_TYPE_NONE;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_LE
8341 | OPTS_TYPE_PT_ADD80
8342 | OPTS_TYPE_PT_ADDBITS14;
8343 kern_type = KERN_TYPE_SHA1_MD5;
8344 dgst_size = DGST_SIZE_4_5;
8345 parse_func = sha1_parse_hash;
8346 sort_by_digest = sort_by_digest_4_5;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_PRECOMPUTE_INIT
8349 | OPTI_TYPE_PRECOMPUTE_MERKLE
8350 | OPTI_TYPE_EARLY_SKIP
8351 | OPTI_TYPE_NOT_ITERATED
8352 | OPTI_TYPE_NOT_SALTED
8353 | OPTI_TYPE_RAW_HASH;
8354 dgst_pos0 = 3;
8355 dgst_pos1 = 4;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 1;
8358 break;
8359
8360 case 4800: hash_type = HASH_TYPE_MD5;
8361 salt_type = SALT_TYPE_EMBEDDED;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_LE
8364 | OPTS_TYPE_PT_ADDBITS14;
8365 kern_type = KERN_TYPE_MD5_CHAP;
8366 dgst_size = DGST_SIZE_4_4;
8367 parse_func = chap_parse_hash;
8368 sort_by_digest = sort_by_digest_4_4;
8369 opti_type = OPTI_TYPE_ZERO_BYTE
8370 | OPTI_TYPE_PRECOMPUTE_INIT
8371 | OPTI_TYPE_PRECOMPUTE_MERKLE
8372 | OPTI_TYPE_MEET_IN_MIDDLE
8373 | OPTI_TYPE_EARLY_SKIP
8374 | OPTI_TYPE_NOT_ITERATED
8375 | OPTI_TYPE_RAW_HASH;
8376 dgst_pos0 = 0;
8377 dgst_pos1 = 3;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 1;
8380 break;
8381
8382 case 4900: hash_type = HASH_TYPE_SHA1;
8383 salt_type = SALT_TYPE_INTERN;
8384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8386 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8387 dgst_size = DGST_SIZE_4_5;
8388 parse_func = sha1s_parse_hash;
8389 sort_by_digest = sort_by_digest_4_5;
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_INIT
8392 | OPTI_TYPE_PRECOMPUTE_MERKLE
8393 | OPTI_TYPE_EARLY_SKIP;
8394 dgst_pos0 = 3;
8395 dgst_pos1 = 4;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 1;
8398 break;
8399
8400 case 5000: hash_type = HASH_TYPE_KECCAK;
8401 salt_type = SALT_TYPE_EMBEDDED;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_ADD01;
8405 kern_type = KERN_TYPE_KECCAK;
8406 dgst_size = DGST_SIZE_8_25;
8407 parse_func = keccak_parse_hash;
8408 sort_by_digest = sort_by_digest_8_25;
8409 opti_type = OPTI_TYPE_ZERO_BYTE
8410 | OPTI_TYPE_USES_BITS_64
8411 | OPTI_TYPE_RAW_HASH;
8412 dgst_pos0 = 2;
8413 dgst_pos1 = 3;
8414 dgst_pos2 = 4;
8415 dgst_pos3 = 5;
8416 break;
8417
8418 case 5100: hash_type = HASH_TYPE_MD5H;
8419 salt_type = SALT_TYPE_NONE;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE
8422 | OPTS_TYPE_PT_ADD80
8423 | OPTS_TYPE_PT_ADDBITS14;
8424 kern_type = KERN_TYPE_MD5H;
8425 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8426 parse_func = md5half_parse_hash;
8427 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8428 opti_type = OPTI_TYPE_ZERO_BYTE
8429 | OPTI_TYPE_RAW_HASH;
8430 dgst_pos0 = 0;
8431 dgst_pos1 = 1;
8432 dgst_pos2 = 2;
8433 dgst_pos3 = 3;
8434 break;
8435
8436 case 5200: hash_type = HASH_TYPE_SHA256;
8437 salt_type = SALT_TYPE_EMBEDDED;
8438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8439 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8440 kern_type = KERN_TYPE_PSAFE3;
8441 dgst_size = DGST_SIZE_4_8;
8442 parse_func = psafe3_parse_hash;
8443 sort_by_digest = sort_by_digest_4_8;
8444 opti_type = OPTI_TYPE_ZERO_BYTE;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 1;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 3;
8449 break;
8450
8451 case 5300: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_ST_ADD80;
8456 kern_type = KERN_TYPE_IKEPSK_MD5;
8457 dgst_size = DGST_SIZE_4_4;
8458 parse_func = ikepsk_md5_parse_hash;
8459 sort_by_digest = sort_by_digest_4_4;
8460 opti_type = OPTI_TYPE_ZERO_BYTE;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 5400: hash_type = HASH_TYPE_SHA1;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_BE
8471 | OPTS_TYPE_ST_ADD80;
8472 kern_type = KERN_TYPE_IKEPSK_SHA1;
8473 dgst_size = DGST_SIZE_4_5;
8474 parse_func = ikepsk_sha1_parse_hash;
8475 sort_by_digest = sort_by_digest_4_5;
8476 opti_type = OPTI_TYPE_ZERO_BYTE;
8477 dgst_pos0 = 3;
8478 dgst_pos1 = 4;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 1;
8481 break;
8482
8483 case 5500: hash_type = HASH_TYPE_NETNTLM;
8484 salt_type = SALT_TYPE_EMBEDDED;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS14
8489 | OPTS_TYPE_PT_UNICODE
8490 | OPTS_TYPE_ST_HEX;
8491 kern_type = KERN_TYPE_NETNTLMv1;
8492 dgst_size = DGST_SIZE_4_4;
8493 parse_func = netntlmv1_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 5600: hash_type = HASH_TYPE_MD5;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE
8507 | OPTS_TYPE_PT_ADD80
8508 | OPTS_TYPE_PT_ADDBITS14
8509 | OPTS_TYPE_PT_UNICODE;
8510 kern_type = KERN_TYPE_NETNTLMv2;
8511 dgst_size = DGST_SIZE_4_4;
8512 parse_func = netntlmv2_parse_hash;
8513 sort_by_digest = sort_by_digest_4_4;
8514 opti_type = OPTI_TYPE_ZERO_BYTE;
8515 dgst_pos0 = 0;
8516 dgst_pos1 = 3;
8517 dgst_pos2 = 2;
8518 dgst_pos3 = 1;
8519 break;
8520
8521 case 5700: hash_type = HASH_TYPE_SHA256;
8522 salt_type = SALT_TYPE_NONE;
8523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8524 opts_type = OPTS_TYPE_PT_GENERATE_BE
8525 | OPTS_TYPE_PT_ADD80
8526 | OPTS_TYPE_PT_ADDBITS15;
8527 kern_type = KERN_TYPE_SHA256;
8528 dgst_size = DGST_SIZE_4_8;
8529 parse_func = cisco4_parse_hash;
8530 sort_by_digest = sort_by_digest_4_8;
8531 opti_type = OPTI_TYPE_ZERO_BYTE
8532 | OPTI_TYPE_PRECOMPUTE_INIT
8533 | OPTI_TYPE_PRECOMPUTE_MERKLE
8534 | OPTI_TYPE_EARLY_SKIP
8535 | OPTI_TYPE_NOT_ITERATED
8536 | OPTI_TYPE_NOT_SALTED
8537 | OPTI_TYPE_RAW_HASH;
8538 dgst_pos0 = 3;
8539 dgst_pos1 = 7;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 6;
8542 break;
8543
8544 case 5800: hash_type = HASH_TYPE_SHA1;
8545 salt_type = SALT_TYPE_INTERN;
8546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8548 | OPTS_TYPE_ST_ADD80;
8549 kern_type = KERN_TYPE_ANDROIDPIN;
8550 dgst_size = DGST_SIZE_4_5;
8551 parse_func = androidpin_parse_hash;
8552 sort_by_digest = sort_by_digest_4_5;
8553 opti_type = OPTI_TYPE_ZERO_BYTE;
8554 dgst_pos0 = 0;
8555 dgst_pos1 = 1;
8556 dgst_pos2 = 2;
8557 dgst_pos3 = 3;
8558 break;
8559
8560 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8561 salt_type = SALT_TYPE_NONE;
8562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8563 opts_type = OPTS_TYPE_PT_GENERATE_LE
8564 | OPTS_TYPE_PT_ADD80;
8565 kern_type = KERN_TYPE_RIPEMD160;
8566 dgst_size = DGST_SIZE_4_5;
8567 parse_func = ripemd160_parse_hash;
8568 sort_by_digest = sort_by_digest_4_5;
8569 opti_type = OPTI_TYPE_ZERO_BYTE;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 1;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 3;
8574 break;
8575
8576 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8577 salt_type = SALT_TYPE_NONE;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_BE
8580 | OPTS_TYPE_PT_ADD80;
8581 kern_type = KERN_TYPE_WHIRLPOOL;
8582 dgst_size = DGST_SIZE_4_16;
8583 parse_func = whirlpool_parse_hash;
8584 sort_by_digest = sort_by_digest_4_16;
8585 opti_type = OPTI_TYPE_ZERO_BYTE;
8586 dgst_pos0 = 0;
8587 dgst_pos1 = 1;
8588 dgst_pos2 = 2;
8589 dgst_pos3 = 3;
8590 break;
8591
8592 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8593 salt_type = SALT_TYPE_EMBEDDED;
8594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8596 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8597 dgst_size = DGST_SIZE_4_5;
8598 parse_func = truecrypt_parse_hash_2k;
8599 sort_by_digest = sort_by_digest_4_5;
8600 opti_type = OPTI_TYPE_ZERO_BYTE;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 1;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 3;
8605 break;
8606
8607 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8608 salt_type = SALT_TYPE_EMBEDDED;
8609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8611 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8612 dgst_size = DGST_SIZE_4_5;
8613 parse_func = truecrypt_parse_hash_2k;
8614 sort_by_digest = sort_by_digest_4_5;
8615 opti_type = OPTI_TYPE_ZERO_BYTE;
8616 dgst_pos0 = 0;
8617 dgst_pos1 = 1;
8618 dgst_pos2 = 2;
8619 dgst_pos3 = 3;
8620 break;
8621
8622 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8623 salt_type = SALT_TYPE_EMBEDDED;
8624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8626 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8627 dgst_size = DGST_SIZE_4_5;
8628 parse_func = truecrypt_parse_hash_2k;
8629 sort_by_digest = sort_by_digest_4_5;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 6221: hash_type = HASH_TYPE_SHA512;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8641 kern_type = KERN_TYPE_TCSHA512_XTS512;
8642 dgst_size = DGST_SIZE_8_8;
8643 parse_func = truecrypt_parse_hash_1k;
8644 sort_by_digest = sort_by_digest_8_8;
8645 opti_type = OPTI_TYPE_ZERO_BYTE
8646 | OPTI_TYPE_USES_BITS_64;
8647 dgst_pos0 = 0;
8648 dgst_pos1 = 1;
8649 dgst_pos2 = 2;
8650 dgst_pos3 = 3;
8651 break;
8652
8653 case 6222: hash_type = HASH_TYPE_SHA512;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8657 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8658 dgst_size = DGST_SIZE_8_8;
8659 parse_func = truecrypt_parse_hash_1k;
8660 sort_by_digest = sort_by_digest_8_8;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_USES_BITS_64;
8663 dgst_pos0 = 0;
8664 dgst_pos1 = 1;
8665 dgst_pos2 = 2;
8666 dgst_pos3 = 3;
8667 break;
8668
8669 case 6223: hash_type = HASH_TYPE_SHA512;
8670 salt_type = SALT_TYPE_EMBEDDED;
8671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8672 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8673 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8674 dgst_size = DGST_SIZE_8_8;
8675 parse_func = truecrypt_parse_hash_1k;
8676 sort_by_digest = sort_by_digest_8_8;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_USES_BITS_64;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 1;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 3;
8683 break;
8684
8685 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8686 salt_type = SALT_TYPE_EMBEDDED;
8687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8689 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8690 dgst_size = DGST_SIZE_4_8;
8691 parse_func = truecrypt_parse_hash_1k;
8692 sort_by_digest = sort_by_digest_4_8;
8693 opti_type = OPTI_TYPE_ZERO_BYTE;
8694 dgst_pos0 = 0;
8695 dgst_pos1 = 1;
8696 dgst_pos2 = 2;
8697 dgst_pos3 = 3;
8698 break;
8699
8700 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8701 salt_type = SALT_TYPE_EMBEDDED;
8702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8704 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8705 dgst_size = DGST_SIZE_4_8;
8706 parse_func = truecrypt_parse_hash_1k;
8707 sort_by_digest = sort_by_digest_4_8;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 1;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 3;
8713 break;
8714
8715 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8716 salt_type = SALT_TYPE_EMBEDDED;
8717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8719 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8720 dgst_size = DGST_SIZE_4_8;
8721 parse_func = truecrypt_parse_hash_1k;
8722 sort_by_digest = sort_by_digest_4_8;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 1;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 3;
8728 break;
8729
8730 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8734 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8735 dgst_size = DGST_SIZE_4_5;
8736 parse_func = truecrypt_parse_hash_1k;
8737 sort_by_digest = sort_by_digest_4_5;
8738 opti_type = OPTI_TYPE_ZERO_BYTE;
8739 dgst_pos0 = 0;
8740 dgst_pos1 = 1;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 3;
8743 break;
8744
8745 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8746 salt_type = SALT_TYPE_EMBEDDED;
8747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8749 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8750 dgst_size = DGST_SIZE_4_5;
8751 parse_func = truecrypt_parse_hash_1k;
8752 sort_by_digest = sort_by_digest_4_5;
8753 opti_type = OPTI_TYPE_ZERO_BYTE;
8754 dgst_pos0 = 0;
8755 dgst_pos1 = 1;
8756 dgst_pos2 = 2;
8757 dgst_pos3 = 3;
8758 break;
8759
8760 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8761 salt_type = SALT_TYPE_EMBEDDED;
8762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8764 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8765 dgst_size = DGST_SIZE_4_5;
8766 parse_func = truecrypt_parse_hash_1k;
8767 sort_by_digest = sort_by_digest_4_5;
8768 opti_type = OPTI_TYPE_ZERO_BYTE;
8769 dgst_pos0 = 0;
8770 dgst_pos1 = 1;
8771 dgst_pos2 = 2;
8772 dgst_pos3 = 3;
8773 break;
8774
8775 case 6300: hash_type = HASH_TYPE_MD5;
8776 salt_type = SALT_TYPE_EMBEDDED;
8777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8778 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8779 kern_type = KERN_TYPE_MD5AIX;
8780 dgst_size = DGST_SIZE_4_4;
8781 parse_func = md5aix_parse_hash;
8782 sort_by_digest = sort_by_digest_4_4;
8783 opti_type = OPTI_TYPE_ZERO_BYTE;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6400: hash_type = HASH_TYPE_SHA256;
8791 salt_type = SALT_TYPE_EMBEDDED;
8792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8794 kern_type = KERN_TYPE_SHA256AIX;
8795 dgst_size = DGST_SIZE_4_8;
8796 parse_func = sha256aix_parse_hash;
8797 sort_by_digest = sort_by_digest_4_8;
8798 opti_type = OPTI_TYPE_ZERO_BYTE;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 6500: hash_type = HASH_TYPE_SHA512;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8809 kern_type = KERN_TYPE_SHA512AIX;
8810 dgst_size = DGST_SIZE_8_8;
8811 parse_func = sha512aix_parse_hash;
8812 sort_by_digest = sort_by_digest_8_8;
8813 opti_type = OPTI_TYPE_ZERO_BYTE
8814 | OPTI_TYPE_USES_BITS_64;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 6600: hash_type = HASH_TYPE_AES;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8825 kern_type = KERN_TYPE_AGILEKEY;
8826 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8827 parse_func = agilekey_parse_hash;
8828 sort_by_digest = sort_by_digest_4_5;
8829 opti_type = OPTI_TYPE_ZERO_BYTE;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 6700: hash_type = HASH_TYPE_SHA1;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8840 kern_type = KERN_TYPE_SHA1AIX;
8841 dgst_size = DGST_SIZE_4_5;
8842 parse_func = sha1aix_parse_hash;
8843 sort_by_digest = sort_by_digest_4_5;
8844 opti_type = OPTI_TYPE_ZERO_BYTE;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 1;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 3;
8849 break;
8850
8851 case 6800: hash_type = HASH_TYPE_AES;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8855 kern_type = KERN_TYPE_LASTPASS;
8856 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8857 parse_func = lastpass_parse_hash;
8858 sort_by_digest = sort_by_digest_4_8;
8859 opti_type = OPTI_TYPE_ZERO_BYTE;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 1;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 3;
8864 break;
8865
8866 case 6900: hash_type = HASH_TYPE_GOST;
8867 salt_type = SALT_TYPE_NONE;
8868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8870 kern_type = KERN_TYPE_GOST;
8871 dgst_size = DGST_SIZE_4_8;
8872 parse_func = gost_parse_hash;
8873 sort_by_digest = sort_by_digest_4_8;
8874 opti_type = OPTI_TYPE_ZERO_BYTE;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 1;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 3;
8879 break;
8880
8881 case 7100: hash_type = HASH_TYPE_SHA512;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8885 kern_type = KERN_TYPE_PBKDF2_SHA512;
8886 dgst_size = DGST_SIZE_8_16;
8887 parse_func = sha512osx_parse_hash;
8888 sort_by_digest = sort_by_digest_8_16;
8889 opti_type = OPTI_TYPE_ZERO_BYTE
8890 | OPTI_TYPE_USES_BITS_64;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 7200: hash_type = HASH_TYPE_SHA512;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8901 kern_type = KERN_TYPE_PBKDF2_SHA512;
8902 dgst_size = DGST_SIZE_8_16;
8903 parse_func = sha512grub_parse_hash;
8904 sort_by_digest = sort_by_digest_8_16;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_USES_BITS_64;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 7300: hash_type = HASH_TYPE_SHA1;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_BE
8917 | OPTS_TYPE_ST_ADD80
8918 | OPTS_TYPE_ST_ADDBITS15;
8919 kern_type = KERN_TYPE_RAKP;
8920 dgst_size = DGST_SIZE_4_5;
8921 parse_func = rakp_parse_hash;
8922 sort_by_digest = sort_by_digest_4_5;
8923 opti_type = OPTI_TYPE_ZERO_BYTE
8924 | OPTI_TYPE_NOT_ITERATED;
8925 dgst_pos0 = 3;
8926 dgst_pos1 = 4;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 1;
8929 break;
8930
8931 case 7400: hash_type = HASH_TYPE_SHA256;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8935 kern_type = KERN_TYPE_SHA256CRYPT;
8936 dgst_size = DGST_SIZE_4_8;
8937 parse_func = sha256crypt_parse_hash;
8938 sort_by_digest = sort_by_digest_4_8;
8939 opti_type = OPTI_TYPE_ZERO_BYTE;
8940 dgst_pos0 = 0;
8941 dgst_pos1 = 1;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 3;
8944 break;
8945
8946 case 7500: hash_type = HASH_TYPE_KRB5PA;
8947 salt_type = SALT_TYPE_EMBEDDED;
8948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8950 kern_type = KERN_TYPE_KRB5PA;
8951 dgst_size = DGST_SIZE_4_4;
8952 parse_func = krb5pa_parse_hash;
8953 sort_by_digest = sort_by_digest_4_4;
8954 opti_type = OPTI_TYPE_ZERO_BYTE
8955 | OPTI_TYPE_NOT_ITERATED;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 7600: hash_type = HASH_TYPE_SHA1;
8963 salt_type = SALT_TYPE_INTERN;
8964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_BE
8966 | OPTS_TYPE_PT_ADD80
8967 | OPTS_TYPE_PT_ADDBITS15;
8968 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = redmine_parse_hash;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE
8973 | OPTI_TYPE_PRECOMPUTE_INIT
8974 | OPTI_TYPE_EARLY_SKIP
8975 | OPTI_TYPE_NOT_ITERATED
8976 | OPTI_TYPE_PREPENDED_SALT;
8977 dgst_pos0 = 3;
8978 dgst_pos1 = 4;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 1;
8981 break;
8982
8983 case 7700: hash_type = HASH_TYPE_SAPB;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE
8987 | OPTS_TYPE_PT_UPPER
8988 | OPTS_TYPE_ST_UPPER;
8989 kern_type = KERN_TYPE_SAPB;
8990 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8991 parse_func = sapb_parse_hash;
8992 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8993 opti_type = OPTI_TYPE_ZERO_BYTE
8994 | OPTI_TYPE_PRECOMPUTE_INIT
8995 | OPTI_TYPE_NOT_ITERATED;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 7800: hash_type = HASH_TYPE_SAPG;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_BE
9006 | OPTS_TYPE_ST_ADD80
9007 | OPTS_TYPE_ST_UPPER;
9008 kern_type = KERN_TYPE_SAPG;
9009 dgst_size = DGST_SIZE_4_5;
9010 parse_func = sapg_parse_hash;
9011 sort_by_digest = sort_by_digest_4_5;
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_PRECOMPUTE_INIT
9014 | OPTI_TYPE_NOT_ITERATED;
9015 dgst_pos0 = 3;
9016 dgst_pos1 = 4;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 1;
9019 break;
9020
9021 case 7900: hash_type = HASH_TYPE_SHA512;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9025 kern_type = KERN_TYPE_DRUPAL7;
9026 dgst_size = DGST_SIZE_8_8;
9027 parse_func = drupal7_parse_hash;
9028 sort_by_digest = sort_by_digest_8_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE
9030 | OPTI_TYPE_USES_BITS_64;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 8000: hash_type = HASH_TYPE_SHA256;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_BE
9041 | OPTS_TYPE_PT_UNICODE
9042 | OPTS_TYPE_ST_ADD80
9043 | OPTS_TYPE_ST_HEX;
9044 kern_type = KERN_TYPE_SYBASEASE;
9045 dgst_size = DGST_SIZE_4_8;
9046 parse_func = sybasease_parse_hash;
9047 sort_by_digest = sort_by_digest_4_8;
9048 opti_type = OPTI_TYPE_ZERO_BYTE
9049 | OPTI_TYPE_PRECOMPUTE_INIT
9050 | OPTI_TYPE_EARLY_SKIP
9051 | OPTI_TYPE_NOT_ITERATED
9052 | OPTI_TYPE_RAW_HASH;
9053 dgst_pos0 = 3;
9054 dgst_pos1 = 7;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 6;
9057 break;
9058
9059 case 8100: hash_type = HASH_TYPE_SHA1;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9063 kern_type = KERN_TYPE_NETSCALER;
9064 dgst_size = DGST_SIZE_4_5;
9065 parse_func = netscaler_parse_hash;
9066 sort_by_digest = sort_by_digest_4_5;
9067 opti_type = OPTI_TYPE_ZERO_BYTE
9068 | OPTI_TYPE_PRECOMPUTE_INIT
9069 | OPTI_TYPE_PRECOMPUTE_MERKLE
9070 | OPTI_TYPE_EARLY_SKIP
9071 | OPTI_TYPE_NOT_ITERATED
9072 | OPTI_TYPE_PREPENDED_SALT
9073 | OPTI_TYPE_RAW_HASH;
9074 dgst_pos0 = 3;
9075 dgst_pos1 = 4;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 1;
9078 break;
9079
9080 case 8200: hash_type = HASH_TYPE_SHA256;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9084 kern_type = KERN_TYPE_CLOUDKEY;
9085 dgst_size = DGST_SIZE_4_8;
9086 parse_func = cloudkey_parse_hash;
9087 sort_by_digest = sort_by_digest_4_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 8300: hash_type = HASH_TYPE_SHA1;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE
9099 | OPTS_TYPE_ST_HEX
9100 | OPTS_TYPE_ST_ADD80;
9101 kern_type = KERN_TYPE_NSEC3;
9102 dgst_size = DGST_SIZE_4_5;
9103 parse_func = nsec3_parse_hash;
9104 sort_by_digest = sort_by_digest_4_5;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 3;
9107 dgst_pos1 = 4;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 1;
9110 break;
9111
9112 case 8400: hash_type = HASH_TYPE_SHA1;
9113 salt_type = SALT_TYPE_INTERN;
9114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_BE
9116 | OPTS_TYPE_PT_ADD80
9117 | OPTS_TYPE_PT_ADDBITS15;
9118 kern_type = KERN_TYPE_WBB3;
9119 dgst_size = DGST_SIZE_4_5;
9120 parse_func = wbb3_parse_hash;
9121 sort_by_digest = sort_by_digest_4_5;
9122 opti_type = OPTI_TYPE_ZERO_BYTE
9123 | OPTI_TYPE_PRECOMPUTE_INIT
9124 | OPTI_TYPE_NOT_ITERATED;
9125 dgst_pos0 = 3;
9126 dgst_pos1 = 4;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 1;
9129 break;
9130
9131 case 8500: hash_type = HASH_TYPE_DESRACF;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE
9135 | OPTS_TYPE_ST_UPPER;
9136 kern_type = KERN_TYPE_RACF;
9137 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9138 parse_func = racf_parse_hash;
9139 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 8600: hash_type = HASH_TYPE_LOTUS5;
9149 salt_type = SALT_TYPE_NONE;
9150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9152 kern_type = KERN_TYPE_LOTUS5;
9153 dgst_size = DGST_SIZE_4_4;
9154 parse_func = lotus5_parse_hash;
9155 sort_by_digest = sort_by_digest_4_4;
9156 opti_type = OPTI_TYPE_EARLY_SKIP
9157 | OPTI_TYPE_NOT_ITERATED
9158 | OPTI_TYPE_NOT_SALTED
9159 | OPTI_TYPE_RAW_HASH;
9160 dgst_pos0 = 0;
9161 dgst_pos1 = 1;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 3;
9164 break;
9165
9166 case 8700: hash_type = HASH_TYPE_LOTUS6;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9170 kern_type = KERN_TYPE_LOTUS6;
9171 dgst_size = DGST_SIZE_4_4;
9172 parse_func = lotus6_parse_hash;
9173 sort_by_digest = sort_by_digest_4_4;
9174 opti_type = OPTI_TYPE_EARLY_SKIP
9175 | OPTI_TYPE_NOT_ITERATED
9176 | OPTI_TYPE_RAW_HASH;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9184 salt_type = SALT_TYPE_EMBEDDED;
9185 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9187 kern_type = KERN_TYPE_ANDROIDFDE;
9188 dgst_size = DGST_SIZE_4_4;
9189 parse_func = androidfde_parse_hash;
9190 sort_by_digest = sort_by_digest_4_4;
9191 opti_type = OPTI_TYPE_ZERO_BYTE;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 1;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 3;
9196 break;
9197
9198 case 8900: hash_type = HASH_TYPE_SCRYPT;
9199 salt_type = SALT_TYPE_EMBEDDED;
9200 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9202 kern_type = KERN_TYPE_SCRYPT;
9203 dgst_size = DGST_SIZE_4_8;
9204 parse_func = scrypt_parse_hash;
9205 sort_by_digest = sort_by_digest_4_8;
9206 opti_type = OPTI_TYPE_ZERO_BYTE;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 9000: hash_type = HASH_TYPE_SHA1;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_LE
9217 | OPTS_TYPE_ST_GENERATE_LE;
9218 kern_type = KERN_TYPE_PSAFE2;
9219 dgst_size = DGST_SIZE_4_5;
9220 parse_func = psafe2_parse_hash;
9221 sort_by_digest = sort_by_digest_4_5;
9222 opti_type = OPTI_TYPE_ZERO_BYTE;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 9100: hash_type = HASH_TYPE_LOTUS8;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9233 kern_type = KERN_TYPE_LOTUS8;
9234 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9235 parse_func = lotus8_parse_hash;
9236 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9237 opti_type = OPTI_TYPE_ZERO_BYTE;
9238 dgst_pos0 = 0;
9239 dgst_pos1 = 1;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 3;
9242 break;
9243
9244 case 9200: hash_type = HASH_TYPE_SHA256;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9248 kern_type = KERN_TYPE_PBKDF2_SHA256;
9249 dgst_size = DGST_SIZE_4_32;
9250 parse_func = cisco8_parse_hash;
9251 sort_by_digest = sort_by_digest_4_32;
9252 opti_type = OPTI_TYPE_ZERO_BYTE;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 9300: hash_type = HASH_TYPE_SCRYPT;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9263 kern_type = KERN_TYPE_SCRYPT;
9264 dgst_size = DGST_SIZE_4_8;
9265 parse_func = cisco9_parse_hash;
9266 sort_by_digest = sort_by_digest_4_8;
9267 opti_type = OPTI_TYPE_ZERO_BYTE;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9278 kern_type = KERN_TYPE_OFFICE2007;
9279 dgst_size = DGST_SIZE_4_4;
9280 parse_func = office2007_parse_hash;
9281 sort_by_digest = sort_by_digest_4_4;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_OFFICE2010;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = office2010_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9308 kern_type = KERN_TYPE_OFFICE2013;
9309 dgst_size = DGST_SIZE_4_4;
9310 parse_func = office2013_parse_hash;
9311 sort_by_digest = sort_by_digest_4_4;
9312 opti_type = OPTI_TYPE_ZERO_BYTE;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE
9323 | OPTS_TYPE_PT_ADD80
9324 | OPTS_TYPE_PT_UNICODE;
9325 kern_type = KERN_TYPE_OLDOFFICE01;
9326 dgst_size = DGST_SIZE_4_4;
9327 parse_func = oldoffice01_parse_hash;
9328 sort_by_digest = sort_by_digest_4_4;
9329 opti_type = OPTI_TYPE_ZERO_BYTE
9330 | OPTI_TYPE_PRECOMPUTE_INIT
9331 | OPTI_TYPE_NOT_ITERATED;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_LE
9342 | OPTS_TYPE_PT_ADD80;
9343 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = oldoffice01cm1_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_PRECOMPUTE_INIT
9349 | OPTI_TYPE_NOT_ITERATED;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE
9360 | OPTS_TYPE_PT_ADD80
9361 | OPTS_TYPE_PT_UNICODE
9362 | OPTS_TYPE_PT_NEVERCRACK;
9363 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = oldoffice01cm2_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_PRECOMPUTE_INIT
9369 | OPTI_TYPE_NOT_ITERATED;
9370 dgst_pos0 = 0;
9371 dgst_pos1 = 1;
9372 dgst_pos2 = 2;
9373 dgst_pos3 = 3;
9374 break;
9375
9376 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9377 salt_type = SALT_TYPE_EMBEDDED;
9378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9379 opts_type = OPTS_TYPE_PT_GENERATE_BE
9380 | OPTS_TYPE_PT_ADD80
9381 | OPTS_TYPE_PT_UNICODE;
9382 kern_type = KERN_TYPE_OLDOFFICE34;
9383 dgst_size = DGST_SIZE_4_4;
9384 parse_func = oldoffice34_parse_hash;
9385 sort_by_digest = sort_by_digest_4_4;
9386 opti_type = OPTI_TYPE_ZERO_BYTE
9387 | OPTI_TYPE_PRECOMPUTE_INIT
9388 | OPTI_TYPE_NOT_ITERATED;
9389 dgst_pos0 = 0;
9390 dgst_pos1 = 1;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 3;
9393 break;
9394
9395 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9399 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9400 dgst_size = DGST_SIZE_4_4;
9401 parse_func = oldoffice34cm1_parse_hash;
9402 sort_by_digest = sort_by_digest_4_4;
9403 opti_type = OPTI_TYPE_ZERO_BYTE
9404 | OPTI_TYPE_PRECOMPUTE_INIT
9405 | OPTI_TYPE_NOT_ITERATED;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_BE
9416 | OPTS_TYPE_PT_ADD80
9417 | OPTS_TYPE_PT_UNICODE
9418 | OPTS_TYPE_PT_NEVERCRACK;
9419 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9420 dgst_size = DGST_SIZE_4_4;
9421 parse_func = oldoffice34cm2_parse_hash;
9422 sort_by_digest = sort_by_digest_4_4;
9423 opti_type = OPTI_TYPE_ZERO_BYTE
9424 | OPTI_TYPE_PRECOMPUTE_INIT
9425 | OPTI_TYPE_NOT_ITERATED;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 9900: hash_type = HASH_TYPE_MD5;
9433 salt_type = SALT_TYPE_NONE;
9434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_RADMIN2;
9437 dgst_size = DGST_SIZE_4_4;
9438 parse_func = radmin2_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4;
9440 opti_type = OPTI_TYPE_ZERO_BYTE
9441 | OPTI_TYPE_PRECOMPUTE_INIT
9442 | OPTI_TYPE_EARLY_SKIP
9443 | OPTI_TYPE_NOT_ITERATED
9444 | OPTI_TYPE_NOT_SALTED;
9445 dgst_pos0 = 0;
9446 dgst_pos1 = 3;
9447 dgst_pos2 = 2;
9448 dgst_pos3 = 1;
9449 break;
9450
9451 case 10000: hash_type = HASH_TYPE_SHA256;
9452 salt_type = SALT_TYPE_EMBEDDED;
9453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9454 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9455 kern_type = KERN_TYPE_PBKDF2_SHA256;
9456 dgst_size = DGST_SIZE_4_32;
9457 parse_func = djangopbkdf2_parse_hash;
9458 sort_by_digest = sort_by_digest_4_32;
9459 opti_type = OPTI_TYPE_ZERO_BYTE;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 10100: hash_type = HASH_TYPE_SIPHASH;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9470 kern_type = KERN_TYPE_SIPHASH;
9471 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9472 parse_func = siphash_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_NOT_ITERATED
9476 | OPTI_TYPE_RAW_HASH;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 10200: hash_type = HASH_TYPE_MD5;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE
9487 | OPTS_TYPE_ST_ADD80
9488 | OPTS_TYPE_ST_ADDBITS14;
9489 kern_type = KERN_TYPE_HMACMD5_PW;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = crammd5_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_NOT_ITERATED;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 3;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 1;
9499 break;
9500
9501 case 10300: hash_type = HASH_TYPE_SHA1;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9505 kern_type = KERN_TYPE_SAPH_SHA1;
9506 dgst_size = DGST_SIZE_4_5;
9507 parse_func = saph_sha1_parse_hash;
9508 sort_by_digest = sort_by_digest_4_5;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 10400: hash_type = HASH_TYPE_PDFU16;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_PDF11;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = pdf11_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_ZERO_BYTE
9525 | OPTI_TYPE_NOT_ITERATED;
9526 dgst_pos0 = 0;
9527 dgst_pos1 = 1;
9528 dgst_pos2 = 2;
9529 dgst_pos3 = 3;
9530 break;
9531
9532 case 10410: hash_type = HASH_TYPE_PDFU16;
9533 salt_type = SALT_TYPE_EMBEDDED;
9534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9535 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9536 kern_type = KERN_TYPE_PDF11CM1;
9537 dgst_size = DGST_SIZE_4_4;
9538 parse_func = pdf11cm1_parse_hash;
9539 sort_by_digest = sort_by_digest_4_4;
9540 opti_type = OPTI_TYPE_ZERO_BYTE
9541 | OPTI_TYPE_NOT_ITERATED;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 10420: hash_type = HASH_TYPE_PDFU16;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_PDF11CM2;
9553 dgst_size = DGST_SIZE_4_4;
9554 parse_func = pdf11cm2_parse_hash;
9555 sort_by_digest = sort_by_digest_4_4;
9556 opti_type = OPTI_TYPE_ZERO_BYTE
9557 | OPTI_TYPE_NOT_ITERATED;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 10500: hash_type = HASH_TYPE_PDFU16;
9565 salt_type = SALT_TYPE_EMBEDDED;
9566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9568 kern_type = KERN_TYPE_PDF14;
9569 dgst_size = DGST_SIZE_4_4;
9570 parse_func = pdf14_parse_hash;
9571 sort_by_digest = sort_by_digest_4_4;
9572 opti_type = OPTI_TYPE_ZERO_BYTE
9573 | OPTI_TYPE_NOT_ITERATED;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 10600: hash_type = HASH_TYPE_SHA256;
9581 salt_type = SALT_TYPE_EMBEDDED;
9582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_BE
9584 | OPTS_TYPE_ST_ADD80
9585 | OPTS_TYPE_ST_ADDBITS15
9586 | OPTS_TYPE_HASH_COPY;
9587 kern_type = KERN_TYPE_SHA256_PWSLT;
9588 dgst_size = DGST_SIZE_4_8;
9589 parse_func = pdf17l3_parse_hash;
9590 sort_by_digest = sort_by_digest_4_8;
9591 opti_type = OPTI_TYPE_ZERO_BYTE
9592 | OPTI_TYPE_PRECOMPUTE_INIT
9593 | OPTI_TYPE_PRECOMPUTE_MERKLE
9594 | OPTI_TYPE_EARLY_SKIP
9595 | OPTI_TYPE_NOT_ITERATED
9596 | OPTI_TYPE_APPENDED_SALT
9597 | OPTI_TYPE_RAW_HASH;
9598 dgst_pos0 = 3;
9599 dgst_pos1 = 7;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 6;
9602 break;
9603
9604 case 10700: hash_type = HASH_TYPE_PDFU32;
9605 salt_type = SALT_TYPE_EMBEDDED;
9606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_LE
9608 | OPTS_TYPE_HASH_COPY;
9609 kern_type = KERN_TYPE_PDF17L8;
9610 dgst_size = DGST_SIZE_4_8;
9611 parse_func = pdf17l8_parse_hash;
9612 sort_by_digest = sort_by_digest_4_8;
9613 opti_type = OPTI_TYPE_ZERO_BYTE
9614 | OPTI_TYPE_NOT_ITERATED;
9615 dgst_pos0 = 0;
9616 dgst_pos1 = 1;
9617 dgst_pos2 = 2;
9618 dgst_pos3 = 3;
9619 break;
9620
9621 case 10800: hash_type = HASH_TYPE_SHA384;
9622 salt_type = SALT_TYPE_NONE;
9623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9624 opts_type = OPTS_TYPE_PT_GENERATE_BE
9625 | OPTS_TYPE_PT_ADD80
9626 | OPTS_TYPE_PT_ADDBITS15;
9627 kern_type = KERN_TYPE_SHA384;
9628 dgst_size = DGST_SIZE_8_8;
9629 parse_func = sha384_parse_hash;
9630 sort_by_digest = sort_by_digest_8_8;
9631 opti_type = OPTI_TYPE_ZERO_BYTE
9632 | OPTI_TYPE_PRECOMPUTE_INIT
9633 | OPTI_TYPE_PRECOMPUTE_MERKLE
9634 | OPTI_TYPE_EARLY_SKIP
9635 | OPTI_TYPE_NOT_ITERATED
9636 | OPTI_TYPE_NOT_SALTED
9637 | OPTI_TYPE_USES_BITS_64
9638 | OPTI_TYPE_RAW_HASH;
9639 dgst_pos0 = 6;
9640 dgst_pos1 = 7;
9641 dgst_pos2 = 4;
9642 dgst_pos3 = 5;
9643 break;
9644
9645 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE
9649 | OPTS_TYPE_ST_BASE64
9650 | OPTS_TYPE_HASH_COPY;
9651 kern_type = KERN_TYPE_PBKDF2_SHA256;
9652 dgst_size = DGST_SIZE_4_32;
9653 parse_func = pbkdf2_sha256_parse_hash;
9654 sort_by_digest = sort_by_digest_4_32;
9655 opti_type = OPTI_TYPE_ZERO_BYTE;
9656 dgst_pos0 = 0;
9657 dgst_pos1 = 1;
9658 dgst_pos2 = 2;
9659 dgst_pos3 = 3;
9660 break;
9661
9662 case 11000: hash_type = HASH_TYPE_MD5;
9663 salt_type = SALT_TYPE_INTERN;
9664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9665 opts_type = OPTS_TYPE_PT_GENERATE_LE
9666 | OPTS_TYPE_PT_ADD80;
9667 kern_type = KERN_TYPE_PRESTASHOP;
9668 dgst_size = DGST_SIZE_4_4;
9669 parse_func = prestashop_parse_hash;
9670 sort_by_digest = sort_by_digest_4_4;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_PRECOMPUTE_INIT
9673 | OPTI_TYPE_NOT_ITERATED
9674 | OPTI_TYPE_PREPENDED_SALT;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 3;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 1;
9679 break;
9680
9681 case 11100: hash_type = HASH_TYPE_MD5;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE
9685 | OPTS_TYPE_ST_ADD80;
9686 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9687 dgst_size = DGST_SIZE_4_4;
9688 parse_func = postgresql_auth_parse_hash;
9689 sort_by_digest = sort_by_digest_4_4;
9690 opti_type = OPTI_TYPE_ZERO_BYTE
9691 | OPTI_TYPE_PRECOMPUTE_INIT
9692 | OPTI_TYPE_PRECOMPUTE_MERKLE
9693 | OPTI_TYPE_EARLY_SKIP;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 3;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 1;
9698 break;
9699
9700 case 11200: hash_type = HASH_TYPE_SHA1;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_BE
9704 | OPTS_TYPE_PT_ADD80
9705 | OPTS_TYPE_ST_HEX;
9706 kern_type = KERN_TYPE_MYSQL_AUTH;
9707 dgst_size = DGST_SIZE_4_5;
9708 parse_func = mysql_auth_parse_hash;
9709 sort_by_digest = sort_by_digest_4_5;
9710 opti_type = OPTI_TYPE_ZERO_BYTE
9711 | OPTI_TYPE_EARLY_SKIP;
9712 dgst_pos0 = 3;
9713 dgst_pos1 = 4;
9714 dgst_pos2 = 2;
9715 dgst_pos3 = 1;
9716 break;
9717
9718 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9719 salt_type = SALT_TYPE_EMBEDDED;
9720 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9721 opts_type = OPTS_TYPE_PT_GENERATE_LE
9722 | OPTS_TYPE_ST_HEX
9723 | OPTS_TYPE_ST_ADD80;
9724 kern_type = KERN_TYPE_BITCOIN_WALLET;
9725 dgst_size = DGST_SIZE_4_4;
9726 parse_func = bitcoin_wallet_parse_hash;
9727 sort_by_digest = sort_by_digest_4_4;
9728 opti_type = OPTI_TYPE_ZERO_BYTE;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 1;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 3;
9733 break;
9734
9735 case 11400: hash_type = HASH_TYPE_MD5;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE
9739 | OPTS_TYPE_PT_ADD80
9740 | OPTS_TYPE_HASH_COPY;
9741 kern_type = KERN_TYPE_SIP_AUTH;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = sip_auth_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE;
9746 dgst_pos0 = 0;
9747 dgst_pos1 = 3;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 1;
9750 break;
9751
9752 case 11500: hash_type = HASH_TYPE_CRC32;
9753 salt_type = SALT_TYPE_INTERN;
9754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_LE
9756 | OPTS_TYPE_ST_GENERATE_LE
9757 | OPTS_TYPE_ST_HEX;
9758 kern_type = KERN_TYPE_CRC32;
9759 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9760 parse_func = crc32_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9762 opti_type = OPTI_TYPE_ZERO_BYTE;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 11600: hash_type = HASH_TYPE_AES;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE
9773 | OPTS_TYPE_PT_NEVERCRACK;
9774 kern_type = KERN_TYPE_SEVEN_ZIP;
9775 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9776 parse_func = seven_zip_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9778 opti_type = OPTI_TYPE_ZERO_BYTE;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9786 salt_type = SALT_TYPE_NONE;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE
9789 | OPTS_TYPE_PT_ADD01;
9790 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = gost2012sbog_256_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9802 salt_type = SALT_TYPE_NONE;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_LE
9805 | OPTS_TYPE_PT_ADD01;
9806 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9807 dgst_size = DGST_SIZE_4_16;
9808 parse_func = gost2012sbog_512_parse_hash;
9809 sort_by_digest = sort_by_digest_4_16;
9810 opti_type = OPTI_TYPE_ZERO_BYTE;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_LE
9821 | OPTS_TYPE_ST_BASE64
9822 | OPTS_TYPE_HASH_COPY;
9823 kern_type = KERN_TYPE_PBKDF2_MD5;
9824 dgst_size = DGST_SIZE_4_32;
9825 parse_func = pbkdf2_md5_parse_hash;
9826 sort_by_digest = sort_by_digest_4_32;
9827 opti_type = OPTI_TYPE_ZERO_BYTE;
9828 dgst_pos0 = 0;
9829 dgst_pos1 = 1;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 3;
9832 break;
9833
9834 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE
9838 | OPTS_TYPE_ST_BASE64
9839 | OPTS_TYPE_HASH_COPY;
9840 kern_type = KERN_TYPE_PBKDF2_SHA1;
9841 dgst_size = DGST_SIZE_4_32;
9842 parse_func = pbkdf2_sha1_parse_hash;
9843 sort_by_digest = sort_by_digest_4_32;
9844 opti_type = OPTI_TYPE_ZERO_BYTE;
9845 dgst_pos0 = 0;
9846 dgst_pos1 = 1;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 3;
9849 break;
9850
9851 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE
9855 | OPTS_TYPE_ST_BASE64
9856 | OPTS_TYPE_HASH_COPY;
9857 kern_type = KERN_TYPE_PBKDF2_SHA512;
9858 dgst_size = DGST_SIZE_8_16;
9859 parse_func = pbkdf2_sha512_parse_hash;
9860 sort_by_digest = sort_by_digest_8_16;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_USES_BITS_64;
9863 dgst_pos0 = 0;
9864 dgst_pos1 = 1;
9865 dgst_pos2 = 2;
9866 dgst_pos3 = 3;
9867 break;
9868
9869 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9870 salt_type = SALT_TYPE_EMBEDDED;
9871 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9873 kern_type = KERN_TYPE_ECRYPTFS;
9874 dgst_size = DGST_SIZE_8_8;
9875 parse_func = ecryptfs_parse_hash;
9876 sort_by_digest = sort_by_digest_8_8;
9877 opti_type = OPTI_TYPE_ZERO_BYTE
9878 | OPTI_TYPE_USES_BITS_64;
9879 dgst_pos0 = 0;
9880 dgst_pos1 = 1;
9881 dgst_pos2 = 2;
9882 dgst_pos3 = 3;
9883 break;
9884
9885 case 12300: hash_type = HASH_TYPE_ORACLET;
9886 salt_type = SALT_TYPE_EMBEDDED;
9887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9889 kern_type = KERN_TYPE_ORACLET;
9890 dgst_size = DGST_SIZE_8_16;
9891 parse_func = oraclet_parse_hash;
9892 sort_by_digest = sort_by_digest_8_16;
9893 opti_type = OPTI_TYPE_ZERO_BYTE
9894 | OPTI_TYPE_USES_BITS_64;
9895 dgst_pos0 = 0;
9896 dgst_pos1 = 1;
9897 dgst_pos2 = 2;
9898 dgst_pos3 = 3;
9899 break;
9900
9901 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9902 salt_type = SALT_TYPE_EMBEDDED;
9903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9905 kern_type = KERN_TYPE_BSDICRYPT;
9906 dgst_size = DGST_SIZE_4_4;
9907 parse_func = bsdicrypt_parse_hash;
9908 sort_by_digest = sort_by_digest_4_4;
9909 opti_type = OPTI_TYPE_ZERO_BYTE
9910 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9911 dgst_pos0 = 0;
9912 dgst_pos1 = 1;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 3;
9915 break;
9916
9917 case 12500: hash_type = HASH_TYPE_RAR3HP;
9918 salt_type = SALT_TYPE_EMBEDDED;
9919 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9921 kern_type = KERN_TYPE_RAR3;
9922 dgst_size = DGST_SIZE_4_4;
9923 parse_func = rar3hp_parse_hash;
9924 sort_by_digest = sort_by_digest_4_4;
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 12600: hash_type = HASH_TYPE_SHA256;
9933 salt_type = SALT_TYPE_INTERN;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_BE
9936 | OPTS_TYPE_PT_ADD80;
9937 kern_type = KERN_TYPE_CF10;
9938 dgst_size = DGST_SIZE_4_8;
9939 parse_func = cf10_parse_hash;
9940 sort_by_digest = sort_by_digest_4_8;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_PRECOMPUTE_INIT
9943 | OPTI_TYPE_EARLY_SKIP
9944 | OPTI_TYPE_NOT_ITERATED;
9945 dgst_pos0 = 3;
9946 dgst_pos1 = 7;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 6;
9949 break;
9950
9951 case 12700: hash_type = HASH_TYPE_AES;
9952 salt_type = SALT_TYPE_EMBEDDED;
9953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE
9955 | OPTS_TYPE_HASH_COPY;
9956 kern_type = KERN_TYPE_MYWALLET;
9957 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9958 parse_func = mywallet_parse_hash;
9959 sort_by_digest = sort_by_digest_4_5;
9960 opti_type = OPTI_TYPE_ZERO_BYTE;
9961 dgst_pos0 = 0;
9962 dgst_pos1 = 1;
9963 dgst_pos2 = 2;
9964 dgst_pos3 = 3;
9965 break;
9966
9967 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9968 salt_type = SALT_TYPE_EMBEDDED;
9969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9971 kern_type = KERN_TYPE_MS_DRSR;
9972 dgst_size = DGST_SIZE_4_8;
9973 parse_func = ms_drsr_parse_hash;
9974 sort_by_digest = sort_by_digest_4_8;
9975 opti_type = OPTI_TYPE_ZERO_BYTE;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9987 dgst_size = DGST_SIZE_4_8;
9988 parse_func = androidfde_samsung_parse_hash;
9989 sort_by_digest = sort_by_digest_4_8;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_RAR5;
10002 dgst_size = DGST_SIZE_4_4;
10003 parse_func = rar5_parse_hash;
10004 sort_by_digest = sort_by_digest_4_4;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 default: usage_mini_print (PROGNAME); return (-1);
10013 }
10014
10015 /**
10016 * transpose
10017 */
10018
10019 data.parse_func = parse_func;
10020
10021 /**
10022 * misc stuff
10023 */
10024
10025 if (hex_salt)
10026 {
10027 if (salt_type == SALT_TYPE_INTERN)
10028 {
10029 opts_type |= OPTS_TYPE_ST_HEX;
10030 }
10031 else
10032 {
10033 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10034
10035 return (-1);
10036 }
10037 }
10038
10039 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10040 | (salt_type == SALT_TYPE_EXTERN)
10041 | (salt_type == SALT_TYPE_EMBEDDED)
10042 | (salt_type == SALT_TYPE_VIRTUAL));
10043
10044 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10045
10046 data.hash_type = hash_type;
10047 data.attack_mode = attack_mode;
10048 data.attack_kern = attack_kern;
10049 data.attack_exec = attack_exec;
10050 data.kern_type = kern_type;
10051 data.opts_type = opts_type;
10052 data.dgst_size = dgst_size;
10053 data.salt_type = salt_type;
10054 data.isSalted = isSalted;
10055 data.sort_by_digest = sort_by_digest;
10056 data.dgst_pos0 = dgst_pos0;
10057 data.dgst_pos1 = dgst_pos1;
10058 data.dgst_pos2 = dgst_pos2;
10059 data.dgst_pos3 = dgst_pos3;
10060
10061 esalt_size = 0;
10062
10063 switch (hash_mode)
10064 {
10065 case 2500: esalt_size = sizeof (wpa_t); break;
10066 case 5300: esalt_size = sizeof (ikepsk_t); break;
10067 case 5400: esalt_size = sizeof (ikepsk_t); break;
10068 case 5500: esalt_size = sizeof (netntlm_t); break;
10069 case 5600: esalt_size = sizeof (netntlm_t); break;
10070 case 6211:
10071 case 6212:
10072 case 6213:
10073 case 6221:
10074 case 6222:
10075 case 6223:
10076 case 6231:
10077 case 6232:
10078 case 6233:
10079 case 6241:
10080 case 6242:
10081 case 6243: esalt_size = sizeof (tc_t); break;
10082 case 6600: esalt_size = sizeof (agilekey_t); break;
10083 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10084 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10085 case 7300: esalt_size = sizeof (rakp_t); break;
10086 case 7500: esalt_size = sizeof (krb5pa_t); break;
10087 case 8200: esalt_size = sizeof (cloudkey_t); break;
10088 case 8800: esalt_size = sizeof (androidfde_t); break;
10089 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10090 case 9400: esalt_size = sizeof (office2007_t); break;
10091 case 9500: esalt_size = sizeof (office2010_t); break;
10092 case 9600: esalt_size = sizeof (office2013_t); break;
10093 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10094 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10095 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10096 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10097 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10098 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10099 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10100 case 10200: esalt_size = sizeof (cram_md5_t); break;
10101 case 10400: esalt_size = sizeof (pdf_t); break;
10102 case 10410: esalt_size = sizeof (pdf_t); break;
10103 case 10420: esalt_size = sizeof (pdf_t); break;
10104 case 10500: esalt_size = sizeof (pdf_t); break;
10105 case 10600: esalt_size = sizeof (pdf_t); break;
10106 case 10700: esalt_size = sizeof (pdf_t); break;
10107 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10108 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10109 case 11400: esalt_size = sizeof (sip_t); break;
10110 case 11600: esalt_size = sizeof (seven_zip_t); break;
10111 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10112 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10113 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10114 case 13000: esalt_size = sizeof (rar5_t); break;
10115 }
10116
10117 data.esalt_size = esalt_size;
10118
10119 /**
10120 * choose dictionary parser
10121 */
10122
10123 if (hash_type == HASH_TYPE_LM)
10124 {
10125 get_next_word_func = get_next_word_lm;
10126 }
10127 else if (opts_type & OPTS_TYPE_PT_UPPER)
10128 {
10129 get_next_word_func = get_next_word_uc;
10130 }
10131 else
10132 {
10133 get_next_word_func = get_next_word_std;
10134 }
10135
10136 /**
10137 * dictstat
10138 */
10139
10140 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10141
10142 #ifdef _POSIX
10143 size_t dictstat_nmemb = 0;
10144 #endif
10145
10146 #ifdef _WIN
10147 uint dictstat_nmemb = 0;
10148 #endif
10149
10150 char dictstat[256] = { 0 };
10151
10152 FILE *dictstat_fp = NULL;
10153
10154 if (keyspace == 0)
10155 {
10156 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10157
10158 dictstat_fp = fopen (dictstat, "rb");
10159
10160 if (dictstat_fp)
10161 {
10162 #ifdef _POSIX
10163 struct stat tmpstat;
10164
10165 fstat (fileno (dictstat_fp), &tmpstat);
10166 #endif
10167
10168 #ifdef _WIN
10169 struct stat64 tmpstat;
10170
10171 _fstat64 (fileno (dictstat_fp), &tmpstat);
10172 #endif
10173
10174 if (tmpstat.st_mtime < COMPTIME)
10175 {
10176 /* with v0.15 the format changed so we have to ensure user is using a good version
10177 since there is no version-header in the dictstat file */
10178
10179 fclose (dictstat_fp);
10180
10181 unlink (dictstat);
10182 }
10183 else
10184 {
10185 while (!feof (dictstat_fp))
10186 {
10187 dictstat_t d;
10188
10189 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10190
10191 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10192
10193 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10194 {
10195 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10196
10197 return -1;
10198 }
10199 }
10200
10201 fclose (dictstat_fp);
10202 }
10203 }
10204 }
10205
10206 /**
10207 * potfile
10208 */
10209
10210 char potfile[256] = { 0 };
10211
10212 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10213
10214 data.pot_fp = NULL;
10215
10216 FILE *out_fp = NULL;
10217 FILE *pot_fp = NULL;
10218
10219 if (show == 1 || left == 1)
10220 {
10221 pot_fp = fopen (potfile, "rb");
10222
10223 if (pot_fp == NULL)
10224 {
10225 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10226
10227 return (-1);
10228 }
10229
10230 if (outfile != NULL)
10231 {
10232 if ((out_fp = fopen (outfile, "ab")) == NULL)
10233 {
10234 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10235
10236 fclose (pot_fp);
10237
10238 return (-1);
10239 }
10240 }
10241 else
10242 {
10243 out_fp = stdout;
10244 }
10245 }
10246 else
10247 {
10248 if (potfile_disable == 0)
10249 {
10250 pot_fp = fopen (potfile, "ab");
10251
10252 if (pot_fp == NULL)
10253 {
10254 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10255
10256 return (-1);
10257 }
10258
10259 data.pot_fp = pot_fp;
10260 }
10261 }
10262
10263 pot_t *pot = NULL;
10264
10265 uint pot_cnt = 0;
10266 uint pot_avail = 0;
10267
10268 if (show == 1 || left == 1)
10269 {
10270 SUPPRESS_OUTPUT = 1;
10271
10272 pot_avail = count_lines (pot_fp);
10273
10274 rewind (pot_fp);
10275
10276 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10277
10278 uint pot_hashes_avail = 0;
10279
10280 uint line_num = 0;
10281
10282 while (!feof (pot_fp))
10283 {
10284 line_num++;
10285
10286 char line_buf[BUFSIZ] = { 0 };
10287
10288 int line_len = fgetl (pot_fp, line_buf);
10289
10290 if (line_len == 0) continue;
10291
10292 char *plain_buf = line_buf + line_len;
10293
10294 pot_t *pot_ptr = &pot[pot_cnt];
10295
10296 hash_t *hashes_buf = &pot_ptr->hash;
10297
10298 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10299 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10300
10301 if (pot_cnt == pot_hashes_avail)
10302 {
10303 uint pos = 0;
10304
10305 for (pos = 0; pos < INCR_POT; pos++)
10306 {
10307 if ((pot_cnt + pos) >= pot_avail) break;
10308
10309 pot_t *tmp_pot = &pot[pot_cnt + pos];
10310
10311 hash_t *tmp_hash = &tmp_pot->hash;
10312
10313 tmp_hash->digest = mymalloc (dgst_size);
10314
10315 if (isSalted)
10316 {
10317 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10318 }
10319
10320 if (esalt_size)
10321 {
10322 tmp_hash->esalt = mymalloc (esalt_size);
10323 }
10324
10325 pot_hashes_avail++;
10326 }
10327 }
10328
10329 int plain_len = 0;
10330
10331 int parser_status;
10332
10333 int iter = MAX_CUT_TRIES;
10334
10335 do
10336 {
10337 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10338 {
10339 if (line_buf[i] == ':')
10340 {
10341 line_len--;
10342
10343 break;
10344 }
10345 }
10346
10347 if (data.hash_mode != 2500)
10348 {
10349 parser_status = parse_func (line_buf, line_len, hashes_buf);
10350 }
10351 else
10352 {
10353 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10354
10355 if (line_len > max_salt_size)
10356 {
10357 parser_status = PARSER_GLOBAL_LENGTH;
10358 }
10359 else
10360 {
10361 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10362
10363 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10364
10365 hashes_buf->salt->salt_len = line_len;
10366
10367 parser_status = PARSER_OK;
10368 }
10369 }
10370
10371 // if NOT parsed without error, we add the ":" to the plain
10372
10373 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10374 {
10375 plain_len++;
10376 plain_buf--;
10377 }
10378
10379 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10380
10381 if (parser_status < PARSER_GLOBAL_ZERO)
10382 {
10383 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10384
10385 continue;
10386 }
10387
10388 if (plain_len >= 255) continue;
10389
10390 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10391
10392 pot_ptr->plain_len = plain_len;
10393
10394 pot_cnt++;
10395 }
10396
10397 fclose (pot_fp);
10398
10399 SUPPRESS_OUTPUT = 0;
10400
10401 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10402 }
10403
10404 /**
10405 * kernel accel and loops auto adjustment
10406 */
10407
10408 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10409 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10410
10411 if (workload_profile == 1)
10412 {
10413 kernel_loops /= 8;
10414 kernel_accel /= 4;
10415
10416 if (kernel_loops == 0) kernel_loops = 8;
10417 if (kernel_accel == 0) kernel_accel = 2;
10418 }
10419 else if (workload_profile == 3)
10420 {
10421 kernel_loops *= 8;
10422 kernel_accel *= 4;
10423
10424 if (kernel_loops > 1024) kernel_loops = 1024;
10425 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10426 }
10427
10428 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10429
10430 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10431 {
10432 kernel_loops = 1024;
10433 }
10434
10435 if (hash_mode == 12500)
10436 {
10437 kernel_loops = ROUNDS_RAR3 / 16;
10438 }
10439
10440 data.kernel_accel = kernel_accel;
10441 data.kernel_loops = kernel_loops;
10442
10443 /**
10444 * word len
10445 */
10446
10447 uint pw_min = PW_MIN;
10448 uint pw_max = PW_MAX;
10449
10450 switch (hash_mode)
10451 {
10452 case 400: if (pw_max > 40) pw_max = 40;
10453 break;
10454 case 500: if (pw_max > 16) pw_max = 16;
10455 break;
10456 case 1500: if (pw_max > 8) pw_max = 8;
10457 break;
10458 case 1600: if (pw_max > 16) pw_max = 16;
10459 break;
10460 case 1800: if (pw_max > 16) pw_max = 16;
10461 break;
10462 case 2100: if (pw_max > 16) pw_max = 16;
10463 break;
10464 case 2500: if (pw_min < 8) pw_min = 8;
10465 break;
10466 case 3000: if (pw_max > 7) pw_max = 7;
10467 break;
10468 case 5200: if (pw_max > 24) pw_max = 24;
10469 break;
10470 case 5800: if (pw_max > 16) pw_max = 16;
10471 break;
10472 case 6300: if (pw_max > 16) pw_max = 16;
10473 break;
10474 case 7400: if (pw_max > 16) pw_max = 16;
10475 break;
10476 case 7900: if (pw_max > 48) pw_max = 48;
10477 break;
10478 case 8500: if (pw_max > 8) pw_max = 8;
10479 break;
10480 case 8600: if (pw_max > 16) pw_max = 16;
10481 break;
10482 case 9710: pw_min = 5;
10483 pw_max = 5;
10484 break;
10485 case 9810: pw_min = 5;
10486 pw_max = 5;
10487 break;
10488 case 10410: pw_min = 5;
10489 pw_max = 5;
10490 break;
10491 case 10300: if (pw_max < 3) pw_min = 3;
10492 if (pw_max > 40) pw_max = 40;
10493 break;
10494 case 10500: if (pw_max < 3) pw_min = 3;
10495 if (pw_max > 40) pw_max = 40;
10496 break;
10497 case 10700: if (pw_max > 16) pw_max = 16;
10498 break;
10499 case 11300: if (pw_max > 40) pw_max = 40;
10500 break;
10501 case 12500: if (pw_max > 20) pw_max = 20;
10502 break;
10503 case 12800: if (pw_max > 24) pw_max = 24;
10504 break;
10505 }
10506
10507 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10508 {
10509 switch (attack_kern)
10510 {
10511 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10512 break;
10513 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10514 break;
10515 }
10516 }
10517
10518 /**
10519 * charsets : keep them together for more easy maintainnce
10520 */
10521
10522 cs_t mp_sys[6] = { { { 0 }, 0 } };
10523 cs_t mp_usr[4] = { { { 0 }, 0 } };
10524
10525 mp_setup_sys (mp_sys);
10526
10527 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10528 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10529 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10530 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10531
10532 /**
10533 * load hashes, part I: find input mode, count hashes
10534 */
10535
10536 uint hashlist_mode = 0;
10537 uint hashlist_format = HLFMT_HASHCAT;
10538
10539 uint hashes_avail = 0;
10540
10541 if (benchmark == 0)
10542 {
10543 struct stat f;
10544
10545 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10546
10547 if ((hash_mode == 2500) ||
10548 (hash_mode == 5200) ||
10549 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10550 (hash_mode == 9000))
10551 {
10552 hashlist_mode = HL_MODE_ARG;
10553
10554 char *hashfile = myargv[optind];
10555
10556 data.hashfile = hashfile;
10557
10558 logfile_top_var_string ("target", hashfile);
10559 }
10560
10561 if (hashlist_mode == HL_MODE_ARG)
10562 {
10563 if (hash_mode == 2500)
10564 {
10565 struct stat st;
10566
10567 if (stat (data.hashfile, &st) == -1)
10568 {
10569 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10570
10571 return (-1);
10572 }
10573
10574 hashes_avail = st.st_size / sizeof (hccap_t);
10575 }
10576 else
10577 {
10578 hashes_avail = 1;
10579 }
10580 }
10581 else if (hashlist_mode == HL_MODE_FILE)
10582 {
10583 char *hashfile = myargv[optind];
10584
10585 data.hashfile = hashfile;
10586
10587 logfile_top_var_string ("target", hashfile);
10588
10589 FILE *fp = NULL;
10590
10591 if ((fp = fopen (hashfile, "rb")) == NULL)
10592 {
10593 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10594
10595 return (-1);
10596 }
10597
10598 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10599
10600 hashes_avail = count_lines (fp);
10601
10602 rewind (fp);
10603
10604 if (hashes_avail == 0)
10605 {
10606 log_error ("ERROR: hashfile is empty or corrupt");
10607
10608 fclose (fp);
10609
10610 return (-1);
10611 }
10612
10613 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10614
10615 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10616 {
10617 log_error ("ERROR: remove not supported in native hashfile-format mode");
10618
10619 fclose (fp);
10620
10621 return (-1);
10622 }
10623
10624 fclose (fp);
10625 }
10626 }
10627 else
10628 {
10629 hashlist_mode = HL_MODE_ARG;
10630
10631 hashes_avail = 1;
10632 }
10633
10634 if (hash_mode == 3000) hashes_avail *= 2;
10635
10636 data.hashlist_mode = hashlist_mode;
10637 data.hashlist_format = hashlist_format;
10638
10639 logfile_top_uint (hashlist_mode);
10640 logfile_top_uint (hashlist_format);
10641
10642 /**
10643 * load hashes, part II: allocate required memory, set pointers
10644 */
10645
10646 hash_t *hashes_buf = NULL;
10647 void *digests_buf = NULL;
10648 salt_t *salts_buf = NULL;
10649 void *esalts_buf = NULL;
10650
10651 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10652
10653 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10654
10655 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10656 {
10657 u32 hash_pos;
10658
10659 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10660 {
10661 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10662
10663 hashes_buf[hash_pos].hash_info = hash_info;
10664
10665 if (username && (remove || show || left))
10666 {
10667 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10668 }
10669
10670 if (benchmark)
10671 {
10672 hash_info->orighash = (char *) mymalloc (256);
10673 }
10674 }
10675 }
10676
10677 if (isSalted)
10678 {
10679 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10680
10681 if (esalt_size)
10682 {
10683 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10684 }
10685 }
10686 else
10687 {
10688 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10689 }
10690
10691 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10692 {
10693 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10694
10695 if (isSalted)
10696 {
10697 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10698
10699 if (esalt_size)
10700 {
10701 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10702 }
10703 }
10704 else
10705 {
10706 hashes_buf[hash_pos].salt = &salts_buf[0];
10707 }
10708 }
10709
10710 /**
10711 * load hashes, part III: parse hashes or generate them if benchmark
10712 */
10713
10714 uint hashes_cnt = 0;
10715
10716 if (benchmark == 0)
10717 {
10718 if (keyspace == 1)
10719 {
10720 // useless to read hash file for keyspace, cheat a little bit w/ optind
10721 }
10722 else if (hashes_avail == 0)
10723 {
10724 }
10725 else if (hashlist_mode == HL_MODE_ARG)
10726 {
10727 char *input_buf = myargv[optind];
10728
10729 uint input_len = strlen (input_buf);
10730
10731 logfile_top_var_string ("target", input_buf);
10732
10733 char *hash_buf = NULL;
10734 int hash_len = 0;
10735
10736 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10737
10738 if (hash_len)
10739 {
10740 if (opts_type & OPTS_TYPE_HASH_COPY)
10741 {
10742 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10743
10744 hash_info_tmp->orighash = mystrdup (hash_buf);
10745 }
10746
10747 if (isSalted)
10748 {
10749 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10750 }
10751
10752 int parser_status = PARSER_OK;
10753
10754 if (hash_mode == 2500)
10755 {
10756 if (hash_len == 0)
10757 {
10758 log_error ("ERROR: hccap file not specified");
10759
10760 return (-1);
10761 }
10762
10763 hashlist_mode = HL_MODE_FILE;
10764
10765 data.hashlist_mode = hashlist_mode;
10766
10767 FILE *fp = fopen (hash_buf, "rb");
10768
10769 if (fp == NULL)
10770 {
10771 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10772
10773 return (-1);
10774 }
10775
10776 if (hashes_avail < 1)
10777 {
10778 log_error ("ERROR: hccap file is empty or corrupt");
10779
10780 fclose (fp);
10781
10782 return (-1);
10783 }
10784
10785 uint hccap_size = sizeof (hccap_t);
10786
10787 char *in = (char *) mymalloc (hccap_size);
10788
10789 while (!feof (fp))
10790 {
10791 int n = fread (in, hccap_size, 1, fp);
10792
10793 if (n != 1)
10794 {
10795 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10796
10797 break;
10798 }
10799
10800 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10801
10802 if (parser_status != PARSER_OK)
10803 {
10804 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10805
10806 continue;
10807 }
10808
10809 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10810
10811 if ((show == 1) || (left == 1))
10812 {
10813 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10814
10815 char *salt_ptr = (char *) tmp_salt->salt_buf;
10816
10817 int cur_pos = tmp_salt->salt_len;
10818 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10819
10820 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10821
10822 u8 *pke_ptr = (u8 *) wpa->pke;
10823
10824 // do the appending task
10825
10826 snprintf (salt_ptr + cur_pos,
10827 rem_len,
10828 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10829 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10830 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10831
10832
10833 // memset () the remaining part of the salt
10834
10835 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10836 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10837
10838 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10839
10840 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10841 }
10842
10843 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10844 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10845
10846 hashes_cnt++;
10847 }
10848
10849 fclose (fp);
10850
10851 myfree (in);
10852 }
10853 else if (hash_mode == 3000)
10854 {
10855 if (hash_len == 32)
10856 {
10857 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10858
10859 hash_t *lm_hash_left = NULL;
10860
10861 if (parser_status == PARSER_OK)
10862 {
10863 lm_hash_left = &hashes_buf[hashes_cnt];
10864
10865 hashes_cnt++;
10866 }
10867 else
10868 {
10869 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10870 }
10871
10872 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10873
10874 hash_t *lm_hash_right = NULL;
10875
10876 if (parser_status == PARSER_OK)
10877 {
10878 lm_hash_right = &hashes_buf[hashes_cnt];
10879
10880 hashes_cnt++;
10881 }
10882 else
10883 {
10884 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10885 }
10886
10887 // show / left
10888
10889 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10890 {
10891 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10892 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10893 }
10894 }
10895 else
10896 {
10897 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10898
10899 if (parser_status == PARSER_OK)
10900 {
10901 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10902 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10903 }
10904
10905 if (parser_status == PARSER_OK)
10906 {
10907 hashes_cnt++;
10908 }
10909 else
10910 {
10911 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10912 }
10913 }
10914 }
10915 else
10916 {
10917 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10918
10919 if (parser_status == PARSER_OK)
10920 {
10921 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10922 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10923 }
10924
10925 if (parser_status == PARSER_OK)
10926 {
10927 hashes_cnt++;
10928 }
10929 else
10930 {
10931 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10932 }
10933 }
10934 }
10935 }
10936 else if (hashlist_mode == HL_MODE_FILE)
10937 {
10938 char *hashfile = data.hashfile;
10939
10940 FILE *fp;
10941
10942 if ((fp = fopen (hashfile, "rb")) == NULL)
10943 {
10944 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10945
10946 return (-1);
10947 }
10948
10949 uint line_num = 0;
10950
10951 while (!feof (fp))
10952 {
10953 line_num++;
10954
10955 char line_buf[BUFSIZ] = { 0 };
10956
10957 int line_len = fgetl (fp, line_buf);
10958
10959 if (line_len == 0) continue;
10960
10961 char *hash_buf = NULL;
10962 int hash_len = 0;
10963
10964 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10965
10966 if (username)
10967 {
10968 char *user_buf = NULL;
10969 int user_len = 0;
10970
10971 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10972
10973 if (remove || show)
10974 {
10975 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10976
10977 *user = (user_t *) mymalloc (sizeof (user_t));
10978
10979 user_t *user_ptr = *user;
10980
10981 if (user_buf != NULL)
10982 {
10983 user_ptr->user_name = mystrdup (user_buf);
10984 }
10985 else
10986 {
10987 user_ptr->user_name = mystrdup ("");
10988 }
10989
10990 user_ptr->user_len = user_len;
10991 }
10992 }
10993
10994 if (opts_type & OPTS_TYPE_HASH_COPY)
10995 {
10996 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10997
10998 hash_info_tmp->orighash = mystrdup (hash_buf);
10999 }
11000
11001 if (isSalted)
11002 {
11003 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11004 }
11005
11006 if (hash_mode == 3000)
11007 {
11008 if (hash_len == 32)
11009 {
11010 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11011
11012 if (parser_status < PARSER_GLOBAL_ZERO)
11013 {
11014 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11015
11016 continue;
11017 }
11018
11019 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11020
11021 hashes_cnt++;
11022
11023 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11024
11025 if (parser_status < PARSER_GLOBAL_ZERO)
11026 {
11027 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11028
11029 continue;
11030 }
11031
11032 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11033
11034 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11035
11036 hashes_cnt++;
11037
11038 // show / left
11039
11040 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11041 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11042 }
11043 else
11044 {
11045 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11046
11047 if (parser_status < PARSER_GLOBAL_ZERO)
11048 {
11049 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11050
11051 continue;
11052 }
11053
11054 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11055
11056 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11057 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11058
11059 hashes_cnt++;
11060 }
11061 }
11062 else
11063 {
11064 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11065
11066 if (parser_status < PARSER_GLOBAL_ZERO)
11067 {
11068 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11069
11070 continue;
11071 }
11072
11073 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11074
11075 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11076 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11077
11078 hashes_cnt++;
11079 }
11080 }
11081
11082 fclose (fp);
11083
11084 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11085
11086 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11087 }
11088 }
11089 else
11090 {
11091 if (isSalted)
11092 {
11093 hashes_buf[0].salt->salt_len = 8;
11094
11095 // special salt handling
11096
11097 switch (hash_mode)
11098 {
11099 case 1500: hashes_buf[0].salt->salt_len = 2;
11100 break;
11101 case 1731: hashes_buf[0].salt->salt_len = 4;
11102 break;
11103 case 2410: hashes_buf[0].salt->salt_len = 4;
11104 break;
11105 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11106 break;
11107 case 3100: hashes_buf[0].salt->salt_len = 1;
11108 break;
11109 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11110 break;
11111 case 5800: hashes_buf[0].salt->salt_len = 16;
11112 break;
11113 case 6800: hashes_buf[0].salt->salt_len = 32;
11114 break;
11115 case 8400: hashes_buf[0].salt->salt_len = 40;
11116 break;
11117 case 8800: hashes_buf[0].salt->salt_len = 16;
11118 break;
11119 case 8900: hashes_buf[0].salt->salt_len = 16;
11120 hashes_buf[0].salt->scrypt_N = 1024;
11121 hashes_buf[0].salt->scrypt_r = 1;
11122 hashes_buf[0].salt->scrypt_p = 1;
11123 break;
11124 case 9100: hashes_buf[0].salt->salt_len = 16;
11125 break;
11126 case 9300: hashes_buf[0].salt->salt_len = 14;
11127 hashes_buf[0].salt->scrypt_N = 16384;
11128 hashes_buf[0].salt->scrypt_r = 1;
11129 hashes_buf[0].salt->scrypt_p = 1;
11130 break;
11131 case 9400: hashes_buf[0].salt->salt_len = 16;
11132 break;
11133 case 9500: hashes_buf[0].salt->salt_len = 16;
11134 break;
11135 case 9600: hashes_buf[0].salt->salt_len = 16;
11136 break;
11137 case 9700: hashes_buf[0].salt->salt_len = 16;
11138 break;
11139 case 9710: hashes_buf[0].salt->salt_len = 16;
11140 break;
11141 case 9720: hashes_buf[0].salt->salt_len = 16;
11142 break;
11143 case 9800: hashes_buf[0].salt->salt_len = 16;
11144 break;
11145 case 9810: hashes_buf[0].salt->salt_len = 16;
11146 break;
11147 case 9820: hashes_buf[0].salt->salt_len = 16;
11148 break;
11149 case 10300: hashes_buf[0].salt->salt_len = 12;
11150 break;
11151 case 11500: hashes_buf[0].salt->salt_len = 4;
11152 break;
11153 case 11600: hashes_buf[0].salt->salt_len = 4;
11154 break;
11155 case 12400: hashes_buf[0].salt->salt_len = 4;
11156 break;
11157 case 12500: hashes_buf[0].salt->salt_len = 8;
11158 break;
11159 case 12600: hashes_buf[0].salt->salt_len = 64;
11160 break;
11161 }
11162
11163 // special esalt handling
11164
11165 switch (hash_mode)
11166 {
11167 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11168 break;
11169 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11170 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11171 break;
11172 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11173 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11174 break;
11175 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11176 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11177 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11178 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11179 break;
11180 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11181 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11182 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11183 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11184 break;
11185 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11186 break;
11187 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11188 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11189 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11190 break;
11191 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11192 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11193 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11194 break;
11195 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11196 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11197 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11198 break;
11199 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11200 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11201 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11202 break;
11203 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11204 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11205 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11206 break;
11207 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11208 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11209 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11210 break;
11211 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11212 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11213 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11214 break;
11215 }
11216 }
11217
11218 // set hashfile
11219
11220 switch (hash_mode)
11221 {
11222 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11223 break;
11224 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11225 break;
11226 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11227 break;
11228 case 6211:
11229 case 6212:
11230 case 6213:
11231 case 6221:
11232 case 6222:
11233 case 6223:
11234 case 6231:
11235 case 6232:
11236 case 6233:
11237 case 6241:
11238 case 6242:
11239 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11240 break;
11241 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11242 break;
11243 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11244 break;
11245 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11246 break;
11247 }
11248
11249 // set default iterations
11250
11251 switch (hash_mode)
11252 {
11253 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11254 break;
11255 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11256 break;
11257 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11258 break;
11259 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11260 break;
11261 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11262 break;
11263 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11264 break;
11265 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11266 break;
11267 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11268 break;
11269 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11270 break;
11271 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11272 break;
11273 case 6211:
11274 case 6212:
11275 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11276 break;
11277 case 6221:
11278 case 6222:
11279 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11280 break;
11281 case 6231:
11282 case 6232:
11283 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11284 break;
11285 case 6241:
11286 case 6242:
11287 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11288 break;
11289 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11290 break;
11291 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11292 break;
11293 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11294 break;
11295 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11296 break;
11297 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11298 break;
11299 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11300 break;
11301 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11302 break;
11303 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11304 break;
11305 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11306 break;
11307 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11308 break;
11309 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11310 break;
11311 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11312 break;
11313 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11314 break;
11315 case 8900: hashes_buf[0].salt->salt_iter = 1;
11316 break;
11317 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11318 break;
11319 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11320 break;
11321 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11322 break;
11323 case 9300: hashes_buf[0].salt->salt_iter = 1;
11324 break;
11325 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11326 break;
11327 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11328 break;
11329 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11330 break;
11331 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11332 break;
11333 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11334 break;
11335 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11336 break;
11337 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11338 break;
11339 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11340 break;
11341 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11342 break;
11343 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11344 break;
11345 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11346 break;
11347 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11348 break;
11349 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11350 break;
11351 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11352 break;
11353 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11354 break;
11355 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11356 break;
11357 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11358 break;
11359 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11360 break;
11361 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11362 break;
11363 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11364 break;
11365 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11366 break;
11367 }
11368
11369 // set special tuning for benchmark-mode 1
11370
11371 if (benchmark_mode == 1)
11372 {
11373 kernel_loops *= 8;
11374 kernel_accel *= 4;
11375
11376 switch (hash_mode)
11377 {
11378 case 400: kernel_loops = ROUNDS_PHPASS;
11379 kernel_accel = 32;
11380 break;
11381 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11382 kernel_accel = 32;
11383 break;
11384 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11385 kernel_accel = 32;
11386 break;
11387 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11388 kernel_accel = 32;
11389 break;
11390 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11391 kernel_accel = 16;
11392 break;
11393 case 2100: kernel_loops = ROUNDS_DCC2;
11394 kernel_accel = 16;
11395 break;
11396 case 2500: kernel_loops = ROUNDS_WPA2;
11397 kernel_accel = 32;
11398 break;
11399 case 3200: kernel_loops = ROUNDS_BCRYPT;
11400 kernel_accel = 8;
11401 break;
11402 case 5200: kernel_loops = ROUNDS_PSAFE3;
11403 kernel_accel = 16;
11404 break;
11405 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11406 kernel_accel = 16;
11407 break;
11408 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11409 #ifndef OSX
11410 kernel_accel = 64;
11411 #endif
11412 break;
11413 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11414 kernel_accel = 32;
11415 break;
11416 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11417 kernel_accel = 32;
11418 break;
11419 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11420 kernel_accel = 8;
11421 break;
11422 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11423 kernel_accel = 8;
11424 break;
11425 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11426 kernel_accel = 8;
11427 break;
11428 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11429 kernel_accel = 8;
11430 break;
11431 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11432 kernel_accel = 8;
11433 break;
11434 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11435 kernel_accel = 8;
11436 break;
11437 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11438 #ifndef OSX
11439 kernel_accel = 128;
11440 #endif
11441 break;
11442 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11443 kernel_accel = 64;
11444 break;
11445 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11446 kernel_accel = 64;
11447 break;
11448 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11449 kernel_accel = 32;
11450 break;
11451 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11452 kernel_accel = 128;
11453 break;
11454 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11455 kernel_accel = 128;
11456 break;
11457 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11458 kernel_accel = 32;
11459 break;
11460 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11461 kernel_accel = 64;
11462 break;
11463 case 6800: kernel_loops = ROUNDS_LASTPASS;
11464 kernel_accel = 64;
11465 break;
11466 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11467 kernel_accel = 8;
11468 break;
11469 case 7200: kernel_loops = ROUNDS_GRUB;
11470 #ifndef OSX
11471 kernel_accel = 16;
11472 #endif
11473 break;
11474 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11475 kernel_accel = 8;
11476 break;
11477 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11478 kernel_accel = 8;
11479 break;
11480 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11481 kernel_accel = 8;
11482 break;
11483 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11484 kernel_accel = 32;
11485 break;
11486 case 8900: kernel_loops = 1;
11487 kernel_accel = 64;
11488 break;
11489 case 9000: kernel_loops = ROUNDS_PSAFE2;
11490 kernel_accel = 16;
11491 break;
11492 case 9100: kernel_loops = ROUNDS_LOTUS8;
11493 kernel_accel = 64;
11494 break;
11495 case 9200: kernel_loops = ROUNDS_CISCO8;
11496 kernel_accel = 8;
11497 break;
11498 case 9300: kernel_loops = 1;
11499 kernel_accel = 4;
11500 break;
11501 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11502 kernel_accel = 32;
11503 break;
11504 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11505 kernel_accel = 32;
11506 break;
11507 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11508 kernel_accel = 8;
11509 break;
11510 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11511 kernel_accel = 8;
11512 break;
11513 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11514 kernel_accel = 16;
11515 break;
11516 case 10500: kernel_loops = ROUNDS_PDF14;
11517 kernel_accel = 256;
11518 break;
11519 case 10700: kernel_loops = ROUNDS_PDF17L8;
11520 kernel_accel = 8;
11521 break;
11522 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11523 kernel_accel = 8;
11524 break;
11525 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11526 kernel_accel = 8;
11527 break;
11528 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11529 kernel_accel = 8;
11530 break;
11531 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11532 kernel_accel = 8;
11533 break;
11534 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11535 kernel_accel = 8;
11536 break;
11537 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11538 kernel_accel = 8;
11539 break;
11540 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11541 kernel_accel = 8;
11542 break;
11543 case 12300: kernel_loops = ROUNDS_ORACLET;
11544 kernel_accel = 8;
11545 break;
11546 case 12500: kernel_loops = ROUNDS_RAR3;
11547 kernel_accel = 32;
11548 break;
11549 case 12700: kernel_loops = ROUNDS_MYWALLET;
11550 kernel_accel = 512;
11551 break;
11552 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11553 kernel_accel = 512;
11554 break;
11555 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11556 kernel_accel = 8;
11557 break;
11558 case 13000: kernel_loops = ROUNDS_RAR5;
11559 kernel_accel = 8;
11560 break;
11561 }
11562
11563 // some algorithm collide too fast, make that impossible
11564
11565 switch (hash_mode)
11566 {
11567 case 11500: ((uint *) digests_buf)[1] = 1;
11568 break;
11569 }
11570
11571 if (kernel_loops > 1024) kernel_loops = 1024;
11572 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11573 }
11574
11575 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11576 {
11577 kernel_loops = 1024;
11578 }
11579
11580 if (hash_mode == 12500)
11581 {
11582 kernel_loops = ROUNDS_RAR3 / 16;
11583 }
11584
11585 data.kernel_accel = kernel_accel;
11586 data.kernel_loops = kernel_loops;
11587
11588 hashes_cnt = 1;
11589 }
11590
11591 if (show == 1 || left == 1)
11592 {
11593 for (uint i = 0; i < pot_cnt; i++)
11594 {
11595 pot_t *pot_ptr = &pot[i];
11596
11597 hash_t *hashes_buf = &pot_ptr->hash;
11598
11599 local_free (hashes_buf->digest);
11600
11601 if (isSalted)
11602 {
11603 local_free (hashes_buf->salt);
11604 }
11605 }
11606
11607 local_free (pot);
11608
11609 if (data.quiet == 0) log_info_nn ("");
11610
11611 return (0);
11612 }
11613
11614 if (keyspace == 0)
11615 {
11616 if (hashes_cnt == 0)
11617 {
11618 log_error ("ERROR: No hashes loaded");
11619
11620 return (-1);
11621 }
11622 }
11623
11624 /**
11625 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11626 */
11627
11628 if (data.outfile != NULL)
11629 {
11630 if (data.hashfile != NULL)
11631 {
11632 #ifdef _POSIX
11633 struct stat tmpstat_outfile;
11634 struct stat tmpstat_hashfile;
11635 #endif
11636
11637 #ifdef _WIN
11638 struct stat64 tmpstat_outfile;
11639 struct stat64 tmpstat_hashfile;
11640 #endif
11641
11642 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11643
11644 if (tmp_outfile_fp)
11645 {
11646 #ifdef _POSIX
11647 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11648 #endif
11649
11650 #ifdef _WIN
11651 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11652 #endif
11653
11654 fclose (tmp_outfile_fp);
11655 }
11656
11657 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11658
11659 if (tmp_hashfile_fp)
11660 {
11661 #ifdef _POSIX
11662 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11663 #endif
11664
11665 #ifdef _WIN
11666 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11667 #endif
11668
11669 fclose (tmp_hashfile_fp);
11670 }
11671
11672 if (tmp_outfile_fp && tmp_outfile_fp)
11673 {
11674 tmpstat_outfile.st_mode = 0;
11675 tmpstat_outfile.st_nlink = 0;
11676 tmpstat_outfile.st_uid = 0;
11677 tmpstat_outfile.st_gid = 0;
11678 tmpstat_outfile.st_rdev = 0;
11679 tmpstat_outfile.st_atime = 0;
11680
11681 tmpstat_hashfile.st_mode = 0;
11682 tmpstat_hashfile.st_nlink = 0;
11683 tmpstat_hashfile.st_uid = 0;
11684 tmpstat_hashfile.st_gid = 0;
11685 tmpstat_hashfile.st_rdev = 0;
11686 tmpstat_hashfile.st_atime = 0;
11687
11688 #ifdef _POSIX
11689 tmpstat_outfile.st_blksize = 0;
11690 tmpstat_outfile.st_blocks = 0;
11691
11692 tmpstat_hashfile.st_blksize = 0;
11693 tmpstat_hashfile.st_blocks = 0;
11694 #endif
11695
11696 #ifdef _POSIX
11697 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11698 {
11699 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11700
11701 return (-1);
11702 }
11703 #endif
11704
11705 #ifdef _WIN
11706 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11707 {
11708 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11709
11710 return (-1);
11711 }
11712 #endif
11713 }
11714 }
11715 }
11716
11717 /**
11718 * Remove duplicates
11719 */
11720
11721 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11722
11723 if (isSalted)
11724 {
11725 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11726 }
11727 else
11728 {
11729 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11730 }
11731
11732 uint hashes_cnt_orig = hashes_cnt;
11733
11734 hashes_cnt = 1;
11735
11736 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11737 {
11738 if (isSalted)
11739 {
11740 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11741 {
11742 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11743 }
11744 }
11745 else
11746 {
11747 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11748 }
11749
11750 if (hashes_pos > hashes_cnt)
11751 {
11752 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11753 }
11754
11755 hashes_cnt++;
11756 }
11757
11758 /**
11759 * Potfile removes
11760 */
11761
11762 uint potfile_remove_cracks = 0;
11763
11764 if (potfile_disable == 0)
11765 {
11766 hash_t hash_buf;
11767
11768 hash_buf.digest = mymalloc (dgst_size);
11769 hash_buf.salt = NULL;
11770 hash_buf.esalt = NULL;
11771 hash_buf.hash_info = NULL;
11772 hash_buf.cracked = 0;
11773
11774 if (isSalted)
11775 {
11776 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11777 }
11778
11779 if (esalt_size)
11780 {
11781 hash_buf.esalt = mymalloc (esalt_size);
11782 }
11783
11784 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11785
11786 // no solution for these special hash types (for instane because they use hashfile in output etc)
11787 if ((hash_mode != 5200) &&
11788 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11789 (hash_mode != 9000))
11790 {
11791 FILE *fp = fopen (potfile, "rb");
11792
11793 if (fp != NULL)
11794 {
11795 while (!feof (fp))
11796 {
11797 char line_buf[BUFSIZ] = { 0 };
11798
11799 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11800
11801 if (ptr == NULL) break;
11802
11803 int line_len = strlen (line_buf);
11804
11805 if (line_len == 0) continue;
11806
11807 int iter = MAX_CUT_TRIES;
11808
11809 for (int i = line_len - 1; i && iter; i--, line_len--)
11810 {
11811 if (line_buf[i] != ':') continue;
11812
11813 if (isSalted)
11814 {
11815 memset (hash_buf.salt, 0, sizeof (salt_t));
11816 }
11817
11818 hash_t *found = NULL;
11819
11820 if (hash_mode == 6800)
11821 {
11822 if (i < 48) // 48 = 12 * uint in salt_buf[]
11823 {
11824 // manipulate salt_buf
11825 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11826
11827 hash_buf.salt->salt_len = i;
11828
11829 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11830 }
11831 }
11832 else if (hash_mode == 2500)
11833 {
11834 if (i < 48) // 48 = 12 * uint in salt_buf[]
11835 {
11836 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11837 // manipulate salt_buf
11838
11839 // to be safe work with a copy (because of line_len loop, i etc)
11840
11841 char line_buf_cpy[BUFSIZ] = { 0 };
11842
11843 memcpy (line_buf_cpy, line_buf, i);
11844
11845 char *mac2_pos = strrchr (line_buf_cpy, ':');
11846
11847 if (mac2_pos == NULL) continue;
11848
11849 mac2_pos[0] = 0;
11850 mac2_pos++;
11851
11852 if (strlen (mac2_pos) != 12) continue;
11853
11854 char *mac1_pos = strrchr (line_buf_cpy, ':');
11855
11856 if (mac1_pos == NULL) continue;
11857
11858 mac1_pos[0] = 0;
11859 mac1_pos++;
11860
11861 if (strlen (mac1_pos) != 12) continue;
11862
11863 uint essid_length = mac1_pos - line_buf_cpy - 1;
11864
11865 // here we need the ESSID
11866 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11867
11868 hash_buf.salt->salt_len = essid_length;
11869
11870 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11871
11872 if (found)
11873 {
11874 wpa_t *wpa = (wpa_t *) found->esalt;
11875
11876 uint pke[25] = { 0 };
11877
11878 char *pke_ptr = (char *) pke;
11879
11880 for (uint i = 0; i < 25; i++)
11881 {
11882 pke[i] = byte_swap_32 (wpa->pke[i]);
11883 }
11884
11885 u8 mac1[6] = { 0 };
11886 u8 mac2[6] = { 0 };
11887
11888 memcpy (mac1, pke_ptr + 23, 6);
11889 memcpy (mac2, pke_ptr + 29, 6);
11890
11891 // compare hex string(s) vs binary MAC address(es)
11892
11893 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11894 {
11895 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11896 {
11897 found = NULL;
11898 break;
11899 }
11900 }
11901
11902 // early skip ;)
11903 if (!found) continue;
11904
11905 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11906 {
11907 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11908 {
11909 found = NULL;
11910 break;
11911 }
11912 }
11913 }
11914 }
11915 }
11916 else
11917 {
11918 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11919
11920 if (parser_status == PARSER_OK)
11921 {
11922 if (isSalted)
11923 {
11924 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11925 }
11926 else
11927 {
11928 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11929 }
11930 }
11931 }
11932
11933 if (found == NULL) continue;
11934
11935 if (!found->cracked) potfile_remove_cracks++;
11936
11937 found->cracked = 1;
11938
11939 if (found) break;
11940
11941 iter--;
11942 }
11943 }
11944
11945 fclose (fp);
11946 }
11947 }
11948
11949 if (esalt_size)
11950 {
11951 local_free (hash_buf.esalt);
11952 }
11953
11954 if (isSalted)
11955 {
11956 local_free (hash_buf.salt);
11957 }
11958
11959 local_free (hash_buf.digest);
11960 }
11961
11962 /**
11963 * Now generate all the buffers required for later
11964 */
11965
11966 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11967
11968 salt_t *salts_buf_new = NULL;
11969 void *esalts_buf_new = NULL;
11970
11971 if (isSalted)
11972 {
11973 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11974
11975 if (esalt_size)
11976 {
11977 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11978 }
11979 }
11980 else
11981 {
11982 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11983 }
11984
11985 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11986
11987 uint digests_cnt = hashes_cnt;
11988 uint digests_done = 0;
11989
11990 uint size_digests = digests_cnt * dgst_size;
11991 uint size_shown = digests_cnt * sizeof (uint);
11992
11993 uint *digests_shown = (uint *) mymalloc (size_shown);
11994 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11995
11996 uint salts_cnt = 0;
11997 uint salts_done = 0;
11998
11999 hashinfo_t **hash_info = NULL;
12000
12001 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12002 {
12003 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12004
12005 if (username && (remove || show))
12006 {
12007 uint user_pos;
12008
12009 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12010 {
12011 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12012
12013 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12014 }
12015 }
12016 }
12017
12018 uint *salts_shown = (uint *) mymalloc (size_shown);
12019
12020 salt_t *salt_buf;
12021
12022 {
12023 // copied from inner loop
12024
12025 salt_buf = &salts_buf_new[salts_cnt];
12026
12027 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12028
12029 if (esalt_size)
12030 {
12031 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12032 }
12033
12034 salt_buf->digests_cnt = 0;
12035 salt_buf->digests_done = 0;
12036 salt_buf->digests_offset = 0;
12037
12038 salts_cnt++;
12039 }
12040
12041 if (hashes_buf[0].cracked == 1)
12042 {
12043 digests_shown[0] = 1;
12044
12045 digests_done++;
12046
12047 salt_buf->digests_done++;
12048 }
12049
12050 salt_buf->digests_cnt++;
12051
12052 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12053
12054 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12055 {
12056 hash_info[0] = hashes_buf[0].hash_info;
12057 }
12058
12059 // copy from inner loop
12060
12061 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12062 {
12063 if (isSalted)
12064 {
12065 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12066 {
12067 salt_buf = &salts_buf_new[salts_cnt];
12068
12069 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12070
12071 if (esalt_size)
12072 {
12073 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12074 }
12075
12076 salt_buf->digests_cnt = 0;
12077 salt_buf->digests_done = 0;
12078 salt_buf->digests_offset = hashes_pos;
12079
12080 salts_cnt++;
12081 }
12082 }
12083
12084 if (hashes_buf[hashes_pos].cracked == 1)
12085 {
12086 digests_shown[hashes_pos] = 1;
12087
12088 digests_done++;
12089
12090 salt_buf->digests_done++;
12091 }
12092
12093 salt_buf->digests_cnt++;
12094
12095 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12096
12097 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12098 {
12099 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12100 }
12101 }
12102
12103 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12104 {
12105 salt_t *salt_buf = &salts_buf_new[salt_pos];
12106
12107 if (salt_buf->digests_done == salt_buf->digests_cnt)
12108 {
12109 salts_shown[salt_pos] = 1;
12110
12111 salts_done++;
12112 }
12113
12114 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12115 }
12116
12117 local_free (digests_buf);
12118 local_free (salts_buf);
12119 local_free (esalts_buf);
12120
12121 digests_buf = digests_buf_new;
12122 salts_buf = salts_buf_new;
12123 esalts_buf = esalts_buf_new;
12124
12125 local_free (hashes_buf);
12126
12127 /**
12128 * special modification not set from parser
12129 */
12130
12131 switch (hash_mode)
12132 {
12133 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12134 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12135 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12136 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12137 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12138 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12139 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12140 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12141 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12142 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12143 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12144 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12145 }
12146
12147 if (truecrypt_keyfiles)
12148 {
12149 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12150
12151 char *keyfiles = strdup (truecrypt_keyfiles);
12152
12153 char *keyfile = strtok (keyfiles, ",");
12154
12155 do
12156 {
12157 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12158
12159 } while ((keyfile = strtok (NULL, ",")) != NULL);
12160
12161 free (keyfiles);
12162 }
12163
12164 data.digests_cnt = digests_cnt;
12165 data.digests_done = digests_done;
12166 data.digests_buf = digests_buf;
12167 data.digests_shown = digests_shown;
12168 data.digests_shown_tmp = digests_shown_tmp;
12169
12170 data.salts_cnt = salts_cnt;
12171 data.salts_done = salts_done;
12172 data.salts_buf = salts_buf;
12173 data.salts_shown = salts_shown;
12174
12175 data.esalts_buf = esalts_buf;
12176 data.hash_info = hash_info;
12177
12178 /**
12179 * Automatic Optimizers
12180 */
12181
12182 if (salts_cnt == 1)
12183 opti_type |= OPTI_TYPE_SINGLE_SALT;
12184
12185 if (digests_cnt == 1)
12186 opti_type |= OPTI_TYPE_SINGLE_HASH;
12187
12188 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12189 opti_type |= OPTI_TYPE_NOT_ITERATED;
12190
12191 if (attack_mode == ATTACK_MODE_BF)
12192 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12193
12194 data.opti_type = opti_type;
12195
12196 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12197 {
12198 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12199 {
12200 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12201 {
12202 if (opts_type & OPTS_TYPE_ST_ADD80)
12203 {
12204 opts_type &= ~OPTS_TYPE_ST_ADD80;
12205 opts_type |= OPTS_TYPE_PT_ADD80;
12206 }
12207
12208 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12209 {
12210 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12211 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12212 }
12213
12214 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12215 {
12216 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12217 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12218 }
12219 }
12220 }
12221 }
12222
12223 /**
12224 * Some algorithm, like descrypt, can benefit from JIT compilation
12225 */
12226
12227 int force_jit_compilation = -1;
12228
12229 if (hash_mode == 8900)
12230 {
12231 force_jit_compilation = 8900;
12232 }
12233 else if (hash_mode == 9300)
12234 {
12235 force_jit_compilation = 8900;
12236 }
12237 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12238 {
12239 force_jit_compilation = 1500;
12240 }
12241
12242 /**
12243 * generate bitmap tables
12244 */
12245
12246 const uint bitmap_shift1 = 5;
12247 const uint bitmap_shift2 = 13;
12248
12249 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12250
12251 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12252 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12253 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12254 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12255 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12256 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12257 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12258 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12259
12260 uint bitmap_bits;
12261 uint bitmap_nums;
12262 uint bitmap_mask;
12263 uint bitmap_size;
12264
12265 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12266 {
12267 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12268
12269 bitmap_nums = 1 << bitmap_bits;
12270
12271 bitmap_mask = bitmap_nums - 1;
12272
12273 bitmap_size = bitmap_nums * sizeof (uint);
12274
12275 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12276
12277 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12278 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12279
12280 break;
12281 }
12282
12283 bitmap_nums = 1 << bitmap_bits;
12284
12285 bitmap_mask = bitmap_nums - 1;
12286
12287 bitmap_size = bitmap_nums * sizeof (uint);
12288
12289 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
12290 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
12291
12292 /**
12293 * prepare quick rule
12294 */
12295
12296 data.rule_buf_l = rule_buf_l;
12297 data.rule_buf_r = rule_buf_r;
12298
12299 int rule_len_l = (int) strlen (rule_buf_l);
12300 int rule_len_r = (int) strlen (rule_buf_r);
12301
12302 data.rule_len_l = rule_len_l;
12303 data.rule_len_r = rule_len_r;
12304
12305 /**
12306 * load rules
12307 */
12308
12309 uint *all_kernel_rules_cnt = NULL;
12310
12311 kernel_rule_t **all_kernel_rules_buf = NULL;
12312
12313 if (rp_files_cnt)
12314 {
12315 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12316
12317 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12318 }
12319
12320 char rule_buf[BUFSIZ] = { 0 };
12321
12322 int rule_len = 0;
12323
12324 for (uint i = 0; i < rp_files_cnt; i++)
12325 {
12326 uint kernel_rules_avail = 0;
12327
12328 uint kernel_rules_cnt = 0;
12329
12330 kernel_rule_t *kernel_rules_buf = NULL;
12331
12332 char *rp_file = rp_files[i];
12333
12334 char in[BLOCK_SIZE] = { 0 };
12335 char out[BLOCK_SIZE] = { 0 };
12336
12337 FILE *fp = NULL;
12338
12339 uint rule_line = 0;
12340
12341 if ((fp = fopen (rp_file, "rb")) == NULL)
12342 {
12343 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12344
12345 return (-1);
12346 }
12347
12348 while (!feof (fp))
12349 {
12350 memset (rule_buf, 0, BUFSIZ);
12351
12352 rule_len = fgetl (fp, rule_buf);
12353
12354 rule_line++;
12355
12356 if (rule_len == 0) continue;
12357
12358 if (rule_buf[0] == '#') continue;
12359
12360 if (kernel_rules_avail == kernel_rules_cnt)
12361 {
12362 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12363
12364 kernel_rules_avail += INCR_RULES;
12365 }
12366
12367 memset (in, 0, BLOCK_SIZE);
12368 memset (out, 0, BLOCK_SIZE);
12369
12370 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12371
12372 if (result == -1)
12373 {
12374 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12375
12376 continue;
12377 }
12378
12379 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12380 {
12381 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12382
12383 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12384
12385 continue;
12386 }
12387
12388 /* its so slow
12389 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12390 {
12391 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12392
12393 continue;
12394 }
12395 */
12396
12397 kernel_rules_cnt++;
12398 }
12399
12400 fclose (fp);
12401
12402 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12403
12404 all_kernel_rules_buf[i] = kernel_rules_buf;
12405 }
12406
12407 /**
12408 * merge rules or automatic rule generator
12409 */
12410
12411 uint kernel_rules_cnt = 0;
12412
12413 kernel_rule_t *kernel_rules_buf = NULL;
12414
12415 if (attack_mode == ATTACK_MODE_STRAIGHT)
12416 {
12417 if (rp_files_cnt)
12418 {
12419 kernel_rules_cnt = 1;
12420
12421 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12422
12423 repeats[0] = kernel_rules_cnt;
12424
12425 for (uint i = 0; i < rp_files_cnt; i++)
12426 {
12427 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12428
12429 repeats[i + 1] = kernel_rules_cnt;
12430 }
12431
12432 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12433
12434 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12435
12436 for (uint i = 0; i < kernel_rules_cnt; i++)
12437 {
12438 uint out_pos = 0;
12439
12440 kernel_rule_t *out = &kernel_rules_buf[i];
12441
12442 for (uint j = 0; j < rp_files_cnt; j++)
12443 {
12444 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12445 uint in_pos;
12446
12447 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12448
12449 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12450 {
12451 if (out_pos == RULES_MAX - 1)
12452 {
12453 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12454
12455 break;
12456 }
12457
12458 out->cmds[out_pos] = in->cmds[in_pos];
12459 }
12460 }
12461 }
12462
12463 local_free (repeats);
12464 }
12465 else if (rp_gen)
12466 {
12467 uint kernel_rules_avail = 0;
12468
12469 while (kernel_rules_cnt < rp_gen)
12470 {
12471 if (kernel_rules_avail == kernel_rules_cnt)
12472 {
12473 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12474
12475 kernel_rules_avail += INCR_RULES;
12476 }
12477
12478 memset (rule_buf, 0, BLOCK_SIZE);
12479
12480 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12481
12482 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12483
12484 kernel_rules_cnt++;
12485 }
12486 }
12487 }
12488
12489 /**
12490 * generate NOP rules
12491 */
12492
12493 if (kernel_rules_cnt == 0)
12494 {
12495 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12496
12497 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12498
12499 kernel_rules_cnt++;
12500 }
12501
12502 data.kernel_rules_cnt = kernel_rules_cnt;
12503 data.kernel_rules_buf = kernel_rules_buf;
12504
12505 /**
12506 * OpenCL platforms: detect
12507 */
12508
12509 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12510
12511 cl_uint platforms_cnt = 0;
12512
12513 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12514
12515 cl_uint platform_devices_cnt;
12516
12517 if (keyspace == 0)
12518 {
12519 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12520
12521 if (platforms_cnt == 0)
12522 {
12523 log_error ("ERROR: No OpenCL compatible platform found");
12524
12525 return (-1);
12526 }
12527 }
12528
12529 /**
12530 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12531 */
12532
12533 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12534 {
12535 cl_platform_id platform = platforms[platform_id];
12536
12537 char platform_vendor[INFOSZ] = { 0 };
12538
12539 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12540
12541 #ifdef HAVE_HWMON
12542 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12543 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12544 {
12545 // make sure that we do not directly control the fan for NVidia
12546
12547 gpu_temp_retain = 0;
12548
12549 data.gpu_temp_retain = gpu_temp_retain;
12550 }
12551 #endif // HAVE_NVML || HAVE_NVAPI
12552 #endif
12553 }
12554
12555 /**
12556 * OpenCL devices: simply push all devices from all platforms into the same device array
12557 */
12558
12559 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12560
12561 data.devices_param = devices_param;
12562
12563 uint devices_cnt = 0;
12564
12565 uint devices_active = 0;
12566
12567 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12568 {
12569 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12570
12571 cl_platform_id platform = platforms[platform_id];
12572
12573 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12574
12575 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12576 {
12577 const uint device_id = devices_cnt;
12578
12579 hc_device_param_t *device_param = &data.devices_param[device_id];
12580
12581 device_param->device = platform_devices[platform_devices_id];
12582
12583 device_param->device_id = device_id;
12584
12585 device_param->platform_devices_id = platform_devices_id;
12586
12587 // device_type
12588
12589 cl_device_type device_type;
12590
12591 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12592
12593 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12594
12595 device_param->device_type = device_type;
12596
12597 // vendor_id
12598
12599 cl_uint vendor_id = 0;
12600
12601 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12602
12603 device_param->vendor_id = vendor_id;
12604
12605 // device_name
12606
12607 char *device_name = (char *) mymalloc (INFOSZ);
12608
12609 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12610
12611 device_param->device_name = device_name;
12612
12613 // device_version
12614
12615 char *device_version = (char *) mymalloc (INFOSZ);
12616
12617 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12618
12619 device_param->device_version = device_version;
12620
12621 if (strstr (device_version, "pocl"))
12622 {
12623 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12624 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12625
12626 cl_uint vendor_id = VENDOR_ID_GENERIC;
12627
12628 device_param->vendor_id = vendor_id;
12629 }
12630
12631 // max_compute_units
12632
12633 cl_uint vector_width;
12634
12635 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12636 {
12637 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12638
12639 if ((vendor_id == VENDOR_ID_NV) && (strstr (device_name, " Ti") || strstr (device_name, " TI")))
12640 {
12641 // Yeah that's a super bad hack, but there's no other attribute we could use
12642
12643 if (vector_width < 2) vector_width *= 2;
12644 }
12645
12646 if (opti_type & OPTI_TYPE_USES_BITS_64)
12647 {
12648 if (vector_width > 1) vector_width /= 2;
12649 }
12650 }
12651 else
12652 {
12653 vector_width = opencl_vector_width;
12654 }
12655
12656 if (vector_width > 8) vector_width = 8;
12657
12658 device_param->vector_width = vector_width;
12659
12660 // max_compute_units
12661
12662 cl_uint device_processors;
12663
12664 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12665
12666 device_param->device_processors = device_processors;
12667
12668 // max_mem_alloc_size
12669
12670 cl_ulong device_maxmem_alloc;
12671
12672 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12673
12674 device_param->device_maxmem_alloc = device_maxmem_alloc;
12675
12676 // max_mem_alloc_size
12677
12678 cl_ulong device_global_mem;
12679
12680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12681
12682 device_param->device_global_mem = device_global_mem;
12683
12684 // max_clock_frequency
12685
12686 cl_uint device_maxclock_frequency;
12687
12688 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12689
12690 device_param->device_maxclock_frequency = device_maxclock_frequency;
12691
12692 // skipped
12693
12694 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12695 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12696
12697 device_param->skipped = (skipped1 || skipped2);
12698
12699 // driver_version
12700
12701 char *driver_version = (char *) mymalloc (INFOSZ);
12702
12703 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12704
12705 device_param->driver_version = driver_version;
12706
12707 // device_name_chksum
12708
12709 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12710
12711 #if __x86_64__
12712 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12713 #else
12714 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12715 #endif
12716
12717 uint device_name_digest[4] = { 0 };
12718
12719 md5_64 ((uint *) device_name_chksum, device_name_digest);
12720
12721 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12722
12723 device_param->device_name_chksum = device_name_chksum;
12724
12725 // device_processor_cores
12726
12727 if (device_type & CL_DEVICE_TYPE_CPU)
12728 {
12729 cl_uint device_processor_cores = 1;
12730
12731 device_param->device_processor_cores = device_processor_cores;
12732 }
12733
12734 if (device_type & CL_DEVICE_TYPE_GPU)
12735 {
12736 if (vendor_id == VENDOR_ID_AMD)
12737 {
12738 cl_uint device_processor_cores = 0;
12739
12740 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12741
12742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12743
12744 device_param->device_processor_cores = device_processor_cores;
12745 }
12746 else if (vendor_id == VENDOR_ID_NV)
12747 {
12748 cl_uint kernel_exec_timeout = 0;
12749
12750 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12751
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12753
12754 device_param->kernel_exec_timeout = kernel_exec_timeout;
12755
12756 cl_uint device_processor_cores = 0;
12757
12758 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12759
12760 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12761
12762 device_param->device_processor_cores = device_processor_cores;
12763
12764 cl_uint sm_minor = 0;
12765 cl_uint sm_major = 0;
12766
12767 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12768 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12769
12770 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12772
12773 device_param->sm_minor = sm_minor;
12774 device_param->sm_major = sm_major;
12775 }
12776 else
12777 {
12778 cl_uint device_processor_cores = 1;
12779
12780 device_param->device_processor_cores = device_processor_cores;
12781 }
12782 }
12783
12784 // display results
12785
12786 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12787 {
12788 if (device_param->skipped == 0)
12789 {
12790 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12791 device_id + 1,
12792 device_name,
12793 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12794 (unsigned int) (device_global_mem / 1024 / 1024),
12795 (unsigned int) (device_maxclock_frequency),
12796 (unsigned int) device_processors);
12797 }
12798 else
12799 {
12800 log_info ("Device #%u: %s, skipped",
12801 device_id + 1,
12802 device_name);
12803 }
12804 }
12805
12806 // common driver check
12807
12808 if (device_param->skipped == 0)
12809 {
12810 if (strstr (device_version, "pocl"))
12811 {
12812 if (force == 0)
12813 {
12814 log_info ("");
12815 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12816 log_info ("You are STRONGLY encouraged not to use it");
12817 log_info ("You can use --force to override this but do not post error reports if you do so");
12818 log_info ("");
12819
12820 return (-1);
12821 }
12822 }
12823
12824 if (device_type & CL_DEVICE_TYPE_GPU)
12825 {
12826 if (vendor_id == VENDOR_ID_NV)
12827 {
12828 if (device_param->kernel_exec_timeout != 0)
12829 {
12830 if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
12831 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12832 }
12833 }
12834 else if (vendor_id == VENDOR_ID_AMD)
12835 {
12836 int catalyst_check = (force == 1) ? 0 : 1;
12837
12838 int catalyst_warn = 0;
12839
12840 int catalyst_broken = 0;
12841
12842 if (catalyst_check == 1)
12843 {
12844 catalyst_warn = 1;
12845
12846 // v14.9 and higher
12847 if (atoi (device_param->driver_version) >= 1573)
12848 {
12849 catalyst_warn = 0;
12850 }
12851
12852 catalyst_check = 0;
12853 }
12854
12855 if (catalyst_broken == 1)
12856 {
12857 log_info ("");
12858 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12859 log_info ("It will pass over cracked hashes and does not report them as cracked");
12860 log_info ("You are STRONGLY encouraged not to use it");
12861 log_info ("You can use --force to override this but do not post error reports if you do so");
12862 log_info ("");
12863
12864 return (-1);
12865 }
12866
12867 if (catalyst_warn == 1)
12868 {
12869 log_info ("");
12870 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12871 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12872 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12873 #ifdef _WIN
12874 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12875 #endif
12876 log_info ("You can use --force to override this but do not post error reports if you do so");
12877 log_info ("");
12878
12879 return (-1);
12880 }
12881 }
12882 }
12883
12884 devices_active++;
12885 }
12886
12887 // next please
12888
12889 devices_cnt++;
12890 }
12891 }
12892
12893 if (keyspace == 0 && devices_active == 0)
12894 {
12895 log_error ("ERROR: No devices found/left");
12896
12897 return (-1);
12898 }
12899
12900 data.devices_cnt = devices_cnt;
12901
12902 data.devices_active = devices_active;
12903
12904 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12905 {
12906 log_info ("");
12907 }
12908
12909 /**
12910 * OpenCL devices: allocate buffer for device specific information
12911 */
12912
12913 #ifdef HAVE_HWMON
12914 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12915
12916 #ifdef HAVE_ADL
12917 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12918
12919 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12920 #endif // ADL
12921 #endif
12922
12923 /**
12924 * enable custom signal handler(s)
12925 */
12926
12927 if (benchmark == 0)
12928 {
12929 hc_signal (sigHandler_default);
12930 }
12931 else
12932 {
12933 hc_signal (sigHandler_benchmark);
12934 }
12935
12936 /**
12937 * User-defined GPU temp handling
12938 */
12939
12940 #ifdef HAVE_HWMON
12941 if (gpu_temp_disable == 1)
12942 {
12943 gpu_temp_abort = 0;
12944 gpu_temp_retain = 0;
12945 }
12946
12947 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12948 {
12949 if (gpu_temp_abort < gpu_temp_retain)
12950 {
12951 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12952
12953 return (-1);
12954 }
12955 }
12956
12957 data.gpu_temp_disable = gpu_temp_disable;
12958 data.gpu_temp_abort = gpu_temp_abort;
12959 data.gpu_temp_retain = gpu_temp_retain;
12960 #endif
12961
12962 /**
12963 * inform the user
12964 */
12965
12966 if (data.quiet == 0)
12967 {
12968 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12969
12970 log_info ("Bitmaps: %u bits, %u entries, 0x%08x mask, %u bytes, %u/%u rotates", bitmap_bits, bitmap_nums, bitmap_mask, bitmap_size, bitmap_shift1, bitmap_shift2);
12971
12972 if (attack_mode == ATTACK_MODE_STRAIGHT)
12973 {
12974 log_info ("Rules: %u", kernel_rules_cnt);
12975 }
12976
12977 if (opti_type)
12978 {
12979 log_info ("Applicable Optimizers:");
12980
12981 for (uint i = 0; i < 32; i++)
12982 {
12983 const uint opti_bit = 1u << i;
12984
12985 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12986 }
12987 }
12988
12989 /**
12990 * Watchdog and Temperature balance
12991 */
12992
12993 #ifdef HAVE_HWMON
12994 if (gpu_temp_abort == 0)
12995 {
12996 log_info ("Watchdog: Temperature abort trigger disabled");
12997 }
12998 else
12999 {
13000 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13001 }
13002
13003 if (gpu_temp_retain == 0)
13004 {
13005 log_info ("Watchdog: Temperature retain trigger disabled");
13006 }
13007 else
13008 {
13009 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13010 }
13011 #endif
13012 }
13013
13014 if (data.quiet == 0) log_info ("");
13015
13016 /**
13017 * HM devices: init
13018 */
13019
13020 #ifdef HAVE_HWMON
13021 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13022 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13023 #endif
13024
13025 #ifdef HAVE_ADL
13026 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13027 #endif
13028
13029 if (gpu_temp_disable == 0)
13030 {
13031 #if defined(WIN) && defined(HAVE_NVAPI)
13032 if (NvAPI_Initialize () == NVAPI_OK)
13033 {
13034 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13035
13036 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13037
13038 int tmp_out = 0;
13039
13040 for (int i = 0; i < tmp_in; i++)
13041 {
13042 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13043 }
13044
13045 for (int i = 0; i < tmp_out; i++)
13046 {
13047 NvU32 speed;
13048
13049 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13050 }
13051 }
13052 #endif // WIN && HAVE_NVAPI
13053
13054 #if defined(LINUX) && defined(HAVE_NVML)
13055 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13056
13057 data.hm_dll_nv = hm_dll_nv;
13058
13059 if (hm_dll_nv)
13060 {
13061 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13062 {
13063 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13064
13065 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13066
13067 int tmp_out = 0;
13068
13069 for (int i = 0; i < tmp_in; i++)
13070 {
13071 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13072 }
13073
13074 for (int i = 0; i < tmp_out; i++)
13075 {
13076 unsigned int speed;
13077
13078 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13079 }
13080 }
13081 }
13082 #endif // LINUX && HAVE_NVML
13083
13084 #ifdef HAVE_ADL
13085 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13086
13087 data.hm_dll_amd = hm_dll_amd;
13088
13089 if (hm_dll_amd)
13090 {
13091 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13092 {
13093 // total number of adapters
13094
13095 int hm_adapters_num;
13096
13097 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13098
13099 // adapter info
13100
13101 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13102
13103 if (lpAdapterInfo == NULL) return (-1);
13104
13105 // get a list (of ids of) valid/usable adapters
13106
13107 int num_adl_adapters = 0;
13108
13109 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13110
13111 if (num_adl_adapters > 0)
13112 {
13113 hc_thread_mutex_lock (mux_adl);
13114
13115 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13116
13117 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13118
13119 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13120 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13121
13122 hc_thread_mutex_unlock (mux_adl);
13123 }
13124
13125 myfree (valid_adl_device_list);
13126 myfree (lpAdapterInfo);
13127 }
13128 }
13129 #endif // HAVE_ADL
13130 }
13131
13132 /**
13133 * HM devices: copy
13134 */
13135
13136 if (gpu_temp_disable == 0)
13137 {
13138 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13139 {
13140 hc_device_param_t *device_param = &data.devices_param[device_id];
13141
13142 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13143
13144 if (device_param->skipped) continue;
13145
13146 const uint platform_devices_id = device_param->platform_devices_id;
13147
13148 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13149 if (device_param->vendor_id == VENDOR_ID_NV)
13150 {
13151 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13152 }
13153 #endif
13154
13155 #ifdef HAVE_ADL
13156 if (device_param->vendor_id == VENDOR_ID_AMD)
13157 {
13158 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13159 }
13160 #endif
13161 }
13162 }
13163
13164 /*
13165 * Temporary fix:
13166 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13167 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13168 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13169 * Driver / ADL bug?
13170 */
13171
13172 #ifdef HAVE_ADL
13173 if (powertune_enable == 1)
13174 {
13175 hc_thread_mutex_lock (mux_adl);
13176
13177 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13178 {
13179 hc_device_param_t *device_param = &data.devices_param[device_id];
13180
13181 if (device_param->skipped) continue;
13182
13183 if (data.hm_device[device_id].od_version == 6)
13184 {
13185 // set powertune value only
13186
13187 int powertune_supported = 0;
13188
13189 int ADL_rc = 0;
13190
13191 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13192 {
13193 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13194
13195 return (-1);
13196 }
13197
13198 if (powertune_supported != 0)
13199 {
13200 // powertune set
13201 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13202
13203 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13204 {
13205 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13206
13207 return (-1);
13208 }
13209
13210 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13211 {
13212 log_error ("ERROR: Failed to set new ADL PowerControl values");
13213
13214 return (-1);
13215 }
13216 }
13217 }
13218 }
13219
13220 hc_thread_mutex_unlock (mux_adl);
13221 }
13222 #endif // HAVE_ADK
13223 #endif // HAVE_HWMON
13224
13225 #ifdef OSX
13226 /*
13227 * List of OSX kernel to fix
13228 */
13229 if ((hash_mode == 6100) || (hash_mode == 6900) || (hash_mode == 11700) || (hash_mode == 11800) || (hash_mode == 5300) || \
13230 (hash_mode == 5400) || (hash_mode == 5500) || (hash_mode == 5600) || (hash_mode == 7500) || (hash_mode == 11100) || \
13231 (hash_mode == 11400) || (hash_mode == 2611) || (hash_mode == 2711) || (hash_mode == 2811) || (hash_mode == 8400) || \
13232 (hash_mode == 2612) || (hash_mode == 3711) || (hash_mode == 7600) || (hash_mode == 3100) || (hash_mode == 8000) || \
13233 (hash_mode == 12600) || (hash_mode == 3000) || (hash_mode == 1500) || (hash_mode == 12400) || (hash_mode == 8500) || \
13234 (hash_mode == 8600) || (hash_mode == 8700) || (hash_mode == 9100) || (hash_mode == 11600) || (hash_mode == 12500) || \
13235 (hash_mode == 6231) || (hash_mode == 8800) || (hash_mode == 9700) || (hash_mode == 9710) || (hash_mode == 9800) || \
13236 (hash_mode == 9810) || (hash_mode == 9400) || (hash_mode == 9500) || (hash_mode == 9600) || (hash_mode == 10400) || \
13237 (hash_mode == 10410) || (hash_mode == 10700) || (hash_mode == 6800) || (hash_mode == 6600) || (hash_mode == 11300) || \
13238 (hash_mode == 12700))
13239 {
13240 if (force == 0)
13241 {
13242 log_info ("");
13243 log_info ("Warning: Hash mode %d is not stable in OSX.", hash_mode);
13244 log_info ("You can use --force to override this but do not post error reports if you do so");
13245 log_info ("");
13246
13247 continue;
13248 }
13249 }
13250 #endif
13251
13252 #ifdef DEBUG
13253 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13254 #endif
13255
13256 uint kernel_blocks_all = 0;
13257
13258 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13259 {
13260 /**
13261 * host buffer
13262 */
13263
13264 hc_device_param_t *device_param = &data.devices_param[device_id];
13265
13266 if (device_param->skipped) continue;
13267
13268 /**
13269 * device properties
13270 */
13271
13272 char *device_name_chksum = device_param->device_name_chksum;
13273
13274 uint device_processors = device_param->device_processors;
13275
13276 uint device_processor_cores = device_param->device_processor_cores;
13277
13278 cl_device_type device_type = device_param->device_type;
13279
13280 /**
13281 * create context for each device
13282 */
13283
13284 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13285
13286 /**
13287 * create command-queue
13288 */
13289
13290 // not supported with NV
13291 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13292
13293 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13294
13295 /**
13296 * create input buffers on device
13297 */
13298
13299 uint kernel_threads = KERNEL_THREADS;
13300
13301 // bcrypt
13302 if (hash_mode == 3200) kernel_threads = 8;
13303 if (hash_mode == 9000) kernel_threads = 8;
13304
13305 if (device_type & CL_DEVICE_TYPE_CPU)
13306 {
13307 if (benchmark_mode == 0)
13308 {
13309 if (kernel_accel > 16)
13310 {
13311 kernel_accel = 16;
13312 }
13313 }
13314 else
13315 {
13316 if (kernel_accel > 64)
13317 {
13318 kernel_accel = 64;
13319 }
13320 }
13321 }
13322
13323 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13324 uint kernel_blocks = kernel_power;
13325
13326 device_param->kernel_threads = kernel_threads;
13327 device_param->kernel_power_user = kernel_power;
13328 device_param->kernel_blocks_user = kernel_blocks;
13329
13330 kernel_blocks_all += kernel_blocks;
13331
13332 uint size_pws = kernel_power * sizeof (pw_t);
13333
13334 uint size_tmps = 4;
13335
13336 switch (hash_mode)
13337 {
13338 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13339 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13340 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13341 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13342 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13343 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13344 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13345 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13346 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13347 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13348 case 6211:
13349 case 6212:
13350 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13351 case 6221:
13352 case 6222:
13353 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13354 case 6231:
13355 case 6232:
13356 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13357 case 6241:
13358 case 6242:
13359 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13360 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13361 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13362 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13363 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13364 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13365 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13366 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13367 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13368 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13369 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13370 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13371 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13372 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13373 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13374 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13375 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13376 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13377 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13378 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13379 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13380 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13381 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13382 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13383 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13384 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13385 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13386 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13387 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13388 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13389 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13390 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13391 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13392 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13393 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13394 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13395 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13396 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13397 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13398 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13399 };
13400
13401 uint size_hooks = 4;
13402
13403 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13404 {
13405 // insert correct hook size
13406 }
13407
13408 // we can optimize some stuff here...
13409
13410 device_param->size_pws = size_pws;
13411 device_param->size_tmps = size_tmps;
13412 device_param->size_hooks = size_hooks;
13413
13414 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13415 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13416
13417 device_param->size_root_css = size_root_css;
13418 device_param->size_markov_css = size_markov_css;
13419
13420 uint size_results = KERNEL_THREADS * sizeof (uint);
13421
13422 device_param->size_results = size_results;
13423
13424 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13425 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13426
13427 uint size_plains = digests_cnt * sizeof (plain_t);
13428 uint size_salts = salts_cnt * sizeof (salt_t);
13429 uint size_esalts = salts_cnt * esalt_size;
13430
13431 device_param->size_plains = size_plains;
13432 device_param->size_digests = size_digests;
13433 device_param->size_shown = size_shown;
13434 device_param->size_salts = size_salts;
13435
13436 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13437 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13438 uint size_tm = 32 * sizeof (bs_word_t);
13439
13440 u64 size_scryptV = 1;
13441
13442 if ((hash_mode == 8900) || (hash_mode == 9300))
13443 {
13444 uint tmto_start = 0;
13445 uint tmto_stop = 10;
13446
13447 if (scrypt_tmto)
13448 {
13449 tmto_start = scrypt_tmto;
13450 }
13451 else
13452 {
13453 // in case the user did not specify the tmto manually
13454 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13455 // but set the lower end only in case the user has a device with too less memory
13456
13457 if (hash_mode == 8900)
13458 {
13459 if (device_param->vendor_id == VENDOR_ID_AMD)
13460 {
13461 tmto_start = 1;
13462 }
13463 else if (device_param->vendor_id == VENDOR_ID_NV)
13464 {
13465 tmto_start = 3;
13466 }
13467 }
13468 else if (hash_mode == 9300)
13469 {
13470 if (device_param->vendor_id == VENDOR_ID_AMD)
13471 {
13472 tmto_start = 3;
13473 }
13474 else if (device_param->vendor_id == VENDOR_ID_NV)
13475 {
13476 tmto_start = 5;
13477 }
13478 }
13479 }
13480
13481 if (quiet == 0) log_info ("");
13482
13483 uint shader_per_mp = 1;
13484
13485 if (device_param->vendor_id == VENDOR_ID_AMD)
13486 {
13487 shader_per_mp = 8;
13488 }
13489 else if (device_param->vendor_id == VENDOR_ID_NV)
13490 {
13491 shader_per_mp = 32;
13492 }
13493
13494 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13495 {
13496 // TODO: in theory the following calculation needs to be done per salt, not global
13497 // we assume all hashes have the same scrypt settings
13498
13499 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13500
13501 size_scryptV /= 1 << tmto;
13502
13503 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13504
13505 if (size_scryptV > device_param->device_maxmem_alloc)
13506 {
13507 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13508
13509 continue;
13510 }
13511
13512 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13513 {
13514 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13515 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13516 }
13517
13518 break;
13519 }
13520
13521 if (data.salts_buf[0].scrypt_phy == 0)
13522 {
13523 log_error ("ERROR: can't allocate enough device memory");
13524
13525 return -1;
13526 }
13527
13528 if (quiet == 0) log_info ("");
13529 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13530 }
13531
13532 /**
13533 * default building options
13534 */
13535
13536 char build_opts[1024] = { 0 };
13537
13538 // we don't have sm_* on vendors not NV but it doesn't matter
13539
13540 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13541
13542 /**
13543 * main kernel
13544 */
13545
13546 {
13547 /**
13548 * kernel source filename
13549 */
13550
13551 char source_file[256] = { 0 };
13552
13553 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13554
13555 struct stat sst;
13556
13557 if (stat (source_file, &sst) == -1)
13558 {
13559 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13560
13561 return -1;
13562 }
13563
13564 /**
13565 * kernel cached filename
13566 */
13567
13568 char cached_file[256] = { 0 };
13569
13570 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13571
13572 int cached = 1;
13573
13574 struct stat cst;
13575
13576 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13577 {
13578 cached = 0;
13579 }
13580
13581 /**
13582 * kernel compile or load
13583 */
13584
13585 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13586
13587 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13588
13589 if (force_jit_compilation == -1)
13590 {
13591 if (cached == 0)
13592 {
13593 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13594
13595 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13596
13597 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13598
13599 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13600
13601 size_t binary_size;
13602
13603 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13604
13605 u8 *binary = (u8 *) mymalloc (binary_size);
13606
13607 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13608
13609 writeProgramBin (cached_file, binary, binary_size);
13610
13611 local_free (binary);
13612 }
13613 else
13614 {
13615 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13616
13617 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13618
13619 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13620
13621 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13622 }
13623 }
13624 else
13625 {
13626 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13627
13628 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13629
13630 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13631
13632 char build_opts_update[1024] = { 0 };
13633
13634 if (force_jit_compilation == 1500)
13635 {
13636 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13637 }
13638 else if (force_jit_compilation == 8900)
13639 {
13640 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
13641 }
13642
13643 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
13644 }
13645
13646 local_free (kernel_lengths);
13647 local_free (kernel_sources[0]);
13648 local_free (kernel_sources);
13649 }
13650
13651 /**
13652 * word generator kernel
13653 */
13654
13655 if (attack_mode != ATTACK_MODE_STRAIGHT)
13656 {
13657 /**
13658 * kernel mp source filename
13659 */
13660
13661 char source_file[256] = { 0 };
13662
13663 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13664
13665 struct stat sst;
13666
13667 if (stat (source_file, &sst) == -1)
13668 {
13669 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13670
13671 return -1;
13672 }
13673
13674 /**
13675 * kernel mp cached filename
13676 */
13677
13678 char cached_file[256] = { 0 };
13679
13680 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13681
13682 int cached = 1;
13683
13684 struct stat cst;
13685
13686 if (stat (cached_file, &cst) == -1)
13687 {
13688 cached = 0;
13689 }
13690
13691 /**
13692 * kernel compile or load
13693 */
13694
13695 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13696
13697 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13698
13699 if (cached == 0)
13700 {
13701 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13702
13703 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13704
13705 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13706
13707 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13708
13709 size_t binary_size;
13710
13711 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13712
13713 u8 *binary = (u8 *) mymalloc (binary_size);
13714
13715 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13716
13717 writeProgramBin (cached_file, binary, binary_size);
13718
13719 local_free (binary);
13720 }
13721 else
13722 {
13723 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13724
13725 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13726
13727 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13728
13729 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13730 }
13731
13732 local_free (kernel_lengths);
13733 local_free (kernel_sources[0]);
13734 local_free (kernel_sources);
13735 }
13736
13737 /**
13738 * amplifier kernel
13739 */
13740
13741 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13742 {
13743
13744 }
13745 else
13746 {
13747 /**
13748 * kernel amp source filename
13749 */
13750
13751 char source_file[256] = { 0 };
13752
13753 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13754
13755 struct stat sst;
13756
13757 if (stat (source_file, &sst) == -1)
13758 {
13759 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13760
13761 return -1;
13762 }
13763
13764 /**
13765 * kernel amp cached filename
13766 */
13767
13768 char cached_file[256] = { 0 };
13769
13770 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13771
13772 int cached = 1;
13773
13774 struct stat cst;
13775
13776 if (stat (cached_file, &cst) == -1)
13777 {
13778 cached = 0;
13779 }
13780
13781 /**
13782 * kernel compile or load
13783 */
13784
13785 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13786
13787 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13788
13789 if (cached == 0)
13790 {
13791 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13792
13793 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13794
13795 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13796
13797 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13798
13799 size_t binary_size;
13800
13801 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13802
13803 u8 *binary = (u8 *) mymalloc (binary_size);
13804
13805 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13806
13807 writeProgramBin (cached_file, binary, binary_size);
13808
13809 local_free (binary);
13810 }
13811 else
13812 {
13813 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13814
13815 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13816
13817 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13818
13819 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13820 }
13821
13822 local_free (kernel_lengths);
13823 local_free (kernel_sources[0]);
13824 local_free (kernel_sources);
13825 }
13826
13827 /**
13828 * global buffers
13829 */
13830
13831 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13832 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13833 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13834 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13835 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13836 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13837 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13838 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13839 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13840 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13841 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13842 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13843 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13844 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13845 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13846 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13847 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13848 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13849
13850 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);
13851 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);
13852 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);
13853 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);
13854 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);
13855 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);
13856 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);
13857 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);
13858 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13859 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13860 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13861
13862 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13863 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13864 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13865 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13866 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13867 run_kernel_bzero (device_param, device_param->d_result, size_results);
13868
13869 /**
13870 * special buffers
13871 */
13872
13873 if (attack_kern == ATTACK_KERN_STRAIGHT)
13874 {
13875 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13876 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13877
13878 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13879
13880 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13881 }
13882 else if (attack_kern == ATTACK_KERN_COMBI)
13883 {
13884 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13885 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13886 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13887 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13888
13889 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13890 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13891 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13892 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13893 }
13894 else if (attack_kern == ATTACK_KERN_BF)
13895 {
13896 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13897 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13898 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13899 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13900 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13901
13902 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13903 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13904 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13905 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13906 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13907 }
13908
13909 if (size_esalts)
13910 {
13911 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13912
13913 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13914 }
13915
13916 /**
13917 * main host data
13918 */
13919
13920 uint *result = (uint *) mymalloc (size_results);
13921
13922 device_param->result = result;
13923
13924 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13925
13926 device_param->pws_buf = pws_buf;
13927
13928 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13929
13930 for (int i = 0; i < 64; i++)
13931 {
13932 pw_caches[i].pw_buf.pw_len = i;
13933 pw_caches[i].cnt = 0;
13934 }
13935
13936 device_param->pw_caches = pw_caches;
13937
13938 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13939
13940 device_param->combs_buf = combs_buf;
13941
13942 void *hooks_buf = mymalloc (size_hooks);
13943
13944 device_param->hooks_buf = hooks_buf;
13945
13946 device_param->pw_transpose = pw_transpose_to_hi1;
13947 device_param->pw_add = pw_add_to_hc1;
13948
13949 /**
13950 * kernel args
13951 */
13952
13953 device_param->kernel_params_buf32[21] = bitmap_mask;
13954 device_param->kernel_params_buf32[22] = bitmap_shift1;
13955 device_param->kernel_params_buf32[23] = bitmap_shift2;
13956 device_param->kernel_params_buf32[24] = 0; // salt_pos
13957 device_param->kernel_params_buf32[25] = 0; // loop_pos
13958 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13959 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13960 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13961 device_param->kernel_params_buf32[29] = 0; // digests_offset
13962 device_param->kernel_params_buf32[30] = 0; // combs_mode
13963 device_param->kernel_params_buf32[31] = 0; // gid_max
13964
13965 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13966 ? &device_param->d_pws_buf
13967 : &device_param->d_pws_amp_buf;
13968 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13969 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13970 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13971 device_param->kernel_params[ 4] = &device_param->d_tmps;
13972 device_param->kernel_params[ 5] = &device_param->d_hooks;
13973 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13974 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13975 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13976 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13977 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13978 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13979 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13980 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13981 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13982 device_param->kernel_params[15] = &device_param->d_digests_buf;
13983 device_param->kernel_params[16] = &device_param->d_digests_shown;
13984 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13985 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13986 device_param->kernel_params[19] = &device_param->d_result;
13987 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13988 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13989 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13990 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13991 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13992 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13993 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13994 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13995 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13996 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13997 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13998 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13999
14000 device_param->kernel_params_mp_buf64[3] = 0;
14001 device_param->kernel_params_mp_buf32[4] = 0;
14002 device_param->kernel_params_mp_buf32[5] = 0;
14003 device_param->kernel_params_mp_buf32[6] = 0;
14004 device_param->kernel_params_mp_buf32[7] = 0;
14005 device_param->kernel_params_mp_buf32[8] = 0;
14006
14007 device_param->kernel_params_mp[0] = NULL;
14008 device_param->kernel_params_mp[1] = NULL;
14009 device_param->kernel_params_mp[2] = NULL;
14010 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14011 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14012 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14013 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14014 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14015 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14016
14017 device_param->kernel_params_mp_l_buf64[3] = 0;
14018 device_param->kernel_params_mp_l_buf32[4] = 0;
14019 device_param->kernel_params_mp_l_buf32[5] = 0;
14020 device_param->kernel_params_mp_l_buf32[6] = 0;
14021 device_param->kernel_params_mp_l_buf32[7] = 0;
14022 device_param->kernel_params_mp_l_buf32[8] = 0;
14023 device_param->kernel_params_mp_l_buf32[9] = 0;
14024
14025 device_param->kernel_params_mp_l[0] = NULL;
14026 device_param->kernel_params_mp_l[1] = NULL;
14027 device_param->kernel_params_mp_l[2] = NULL;
14028 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14029 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14030 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14031 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14032 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14033 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14034 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14035
14036 device_param->kernel_params_mp_r_buf64[3] = 0;
14037 device_param->kernel_params_mp_r_buf32[4] = 0;
14038 device_param->kernel_params_mp_r_buf32[5] = 0;
14039 device_param->kernel_params_mp_r_buf32[6] = 0;
14040 device_param->kernel_params_mp_r_buf32[7] = 0;
14041 device_param->kernel_params_mp_r_buf32[8] = 0;
14042
14043 device_param->kernel_params_mp_r[0] = NULL;
14044 device_param->kernel_params_mp_r[1] = NULL;
14045 device_param->kernel_params_mp_r[2] = NULL;
14046 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14047 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14048 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14049 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14050 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14051 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14052
14053 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14054 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14055
14056 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14057 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14058 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14059 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14060 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14061 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14062 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14063
14064 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14065
14066 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14067 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14068
14069 /**
14070 * kernel name
14071 */
14072
14073 char kernel_name[64] = { 0 };
14074
14075 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14076 {
14077 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14078 {
14079 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14080
14081 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14082
14083 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14084
14085 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14086
14087 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14088
14089 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14090 }
14091 else
14092 {
14093 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14094
14095 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14096
14097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14098
14099 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14100
14101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14102
14103 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14104 }
14105
14106 if (data.attack_mode == ATTACK_MODE_BF)
14107 {
14108 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14109 {
14110 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14111
14112 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14113
14114 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14115
14116 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14117 }
14118 }
14119 }
14120 else
14121 {
14122 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14123
14124 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14125
14126 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14127
14128 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14129
14130 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14131
14132 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14133
14134 if (opts_type & OPTS_TYPE_HOOK12)
14135 {
14136 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14137
14138 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14139 }
14140
14141 if (opts_type & OPTS_TYPE_HOOK23)
14142 {
14143 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14144
14145 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14146 }
14147 }
14148
14149 for (uint i = 0; i <= 20; i++)
14150 {
14151 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14152 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14153 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14154
14155 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14156 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14157 }
14158
14159 for (uint i = 21; i <= 31; i++)
14160 {
14161 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14162 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14163 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14164
14165 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14166 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14167 }
14168
14169 if (attack_mode == ATTACK_MODE_BF)
14170 {
14171 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14172 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14173
14174 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14175 {
14176 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14177
14178 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14179 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14180 }
14181 }
14182 else if (attack_mode == ATTACK_MODE_HYBRID1)
14183 {
14184 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14185 }
14186 else if (attack_mode == ATTACK_MODE_HYBRID2)
14187 {
14188 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14189 }
14190
14191 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14192 {
14193 // nothing to do
14194 }
14195 else
14196 {
14197 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14198 }
14199
14200 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14201 {
14202 // nothing to do
14203 }
14204 else
14205 {
14206 for (uint i = 0; i < 5; i++)
14207 {
14208 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14209 }
14210
14211 for (uint i = 5; i < 7; i++)
14212 {
14213 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14214 }
14215 }
14216
14217 /**
14218 * Store initial fanspeed if gpu_temp_retain is enabled
14219 */
14220
14221 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14222 int gpu_temp_retain_set = 0;
14223
14224 if (gpu_temp_disable == 0)
14225 {
14226 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14227 {
14228 hc_thread_mutex_lock (mux_adl);
14229
14230 if (data.hm_device[device_id].fan_supported == 1)
14231 {
14232 if (gpu_temp_retain_chgd == 0)
14233 {
14234 uint cur_temp = 0;
14235 uint default_temp = 0;
14236
14237 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);
14238
14239 if (ADL_rc == ADL_OK)
14240 {
14241 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14242
14243 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14244
14245 // special case with multi gpu setups: always use minimum retain
14246
14247 if (gpu_temp_retain_set == 0)
14248 {
14249 gpu_temp_retain = gpu_temp_retain_target;
14250 gpu_temp_retain_set = 1;
14251 }
14252 else
14253 {
14254 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14255 }
14256
14257 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14258 }
14259 }
14260
14261 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14262
14263 temp_retain_fanspeed_value[device_id] = fan_speed;
14264
14265 if (fan_speed == -1)
14266 {
14267 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14268
14269 temp_retain_fanspeed_value[device_id] = 0;
14270 }
14271 }
14272
14273 hc_thread_mutex_unlock (mux_adl);
14274 }
14275 }
14276
14277 /**
14278 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14279 */
14280
14281 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14282 {
14283 hc_thread_mutex_lock (mux_adl);
14284
14285 if (data.hm_device[device_id].od_version == 6)
14286 {
14287 int ADL_rc;
14288
14289 // check powertune capabilities first, if not available then skip device
14290
14291 int powertune_supported = 0;
14292
14293 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14294 {
14295 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14296
14297 return (-1);
14298 }
14299
14300 if (powertune_supported != 0)
14301 {
14302 // powercontrol settings
14303
14304 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14305
14306 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14307 {
14308 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]);
14309 }
14310
14311 if (ADL_rc != ADL_OK)
14312 {
14313 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14314
14315 return (-1);
14316 }
14317
14318 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14319 {
14320 log_error ("ERROR: Failed to set new ADL PowerControl values");
14321
14322 return (-1);
14323 }
14324
14325 // clocks
14326
14327 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14328
14329 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14330
14331 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)
14332 {
14333 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14334
14335 return (-1);
14336 }
14337
14338 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14339
14340 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14341
14342 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14343 {
14344 log_error ("ERROR: Failed to get ADL device capabilities");
14345
14346 return (-1);
14347 }
14348
14349 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14350 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14351
14352 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14353 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14354
14355 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14356 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14357
14358 // warning if profile has too low max values
14359
14360 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14361 {
14362 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14363 }
14364
14365 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14366 {
14367 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14368 }
14369
14370 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14371
14372 performance_state->iNumberOfPerformanceLevels = 2;
14373
14374 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14375 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14376 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14377 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14378
14379 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)
14380 {
14381 log_info ("ERROR: Failed to set ADL performance state");
14382
14383 return (-1);
14384 }
14385
14386 local_free (performance_state);
14387 }
14388 }
14389
14390 hc_thread_mutex_unlock (mux_adl);
14391 }
14392 #endif // HAVE_HWMON && HAVE_ADL
14393 }
14394
14395 data.kernel_blocks_all = kernel_blocks_all;
14396
14397 if (data.quiet == 0) log_info ("");
14398
14399 /**
14400 * Inform user which algorithm is checked and at which workload setting
14401 */
14402
14403 if (benchmark == 1)
14404 {
14405 quiet = 0;
14406
14407 data.quiet = quiet;
14408
14409 char *hash_type = strhashtype (data.hash_mode); // not a bug
14410
14411 log_info ("Hashtype: %s", hash_type);
14412 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14413 log_info ("");
14414 }
14415
14416 /**
14417 * keep track of the progress
14418 */
14419
14420 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14421 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14422 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14423
14424 /**
14425 * open filehandles
14426 */
14427
14428 #if _WIN
14429 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14430 {
14431 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14432
14433 return (-1);
14434 }
14435
14436 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14437 {
14438 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14439
14440 return (-1);
14441 }
14442
14443 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14444 {
14445 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14446
14447 return (-1);
14448 }
14449 #endif
14450
14451 /**
14452 * dictionary pad
14453 */
14454
14455 segment_size *= (1024 * 1024);
14456
14457 data.segment_size = segment_size;
14458
14459 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14460
14461 wl_data->buf = (char *) mymalloc (segment_size);
14462 wl_data->avail = segment_size;
14463 wl_data->incr = segment_size;
14464 wl_data->cnt = 0;
14465 wl_data->pos = 0;
14466
14467 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14468
14469 data.wordlist_mode = wordlist_mode;
14470
14471 cs_t *css_buf = NULL;
14472 uint css_cnt = 0;
14473 uint dictcnt = 0;
14474 uint maskcnt = 1;
14475 char **masks = NULL;
14476 char **dictfiles = NULL;
14477
14478 uint mask_from_file = 0;
14479
14480 if (attack_mode == ATTACK_MODE_STRAIGHT)
14481 {
14482 if (wordlist_mode == WL_MODE_FILE)
14483 {
14484 int wls_left = myargc - (optind + 1);
14485
14486 for (int i = 0; i < wls_left; i++)
14487 {
14488 char *l0_filename = myargv[optind + 1 + i];
14489
14490 struct stat l0_stat;
14491
14492 if (stat (l0_filename, &l0_stat) == -1)
14493 {
14494 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14495
14496 return (-1);
14497 }
14498
14499 uint is_dir = S_ISDIR (l0_stat.st_mode);
14500
14501 if (is_dir == 0)
14502 {
14503 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14504
14505 dictcnt++;
14506
14507 dictfiles[dictcnt - 1] = l0_filename;
14508 }
14509 else
14510 {
14511 // do not allow --keyspace w/ a directory
14512
14513 if (keyspace == 1)
14514 {
14515 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14516
14517 return (-1);
14518 }
14519
14520 char **dictionary_files = NULL;
14521
14522 dictionary_files = scan_directory (l0_filename);
14523
14524 if (dictionary_files != NULL)
14525 {
14526 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14527
14528 for (int d = 0; dictionary_files[d] != NULL; d++)
14529 {
14530 char *l1_filename = dictionary_files[d];
14531
14532 struct stat l1_stat;
14533
14534 if (stat (l1_filename, &l1_stat) == -1)
14535 {
14536 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14537
14538 return (-1);
14539 }
14540
14541 if (S_ISREG (l1_stat.st_mode))
14542 {
14543 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14544
14545 dictcnt++;
14546
14547 dictfiles[dictcnt - 1] = strdup (l1_filename);
14548 }
14549 }
14550 }
14551
14552 local_free (dictionary_files);
14553 }
14554 }
14555
14556 if (dictcnt < 1)
14557 {
14558 log_error ("ERROR: No usable dictionary file found.");
14559
14560 return (-1);
14561 }
14562 }
14563 else if (wordlist_mode == WL_MODE_STDIN)
14564 {
14565 dictcnt = 1;
14566 }
14567 }
14568 else if (attack_mode == ATTACK_MODE_COMBI)
14569 {
14570 // display
14571
14572 char *dictfile1 = myargv[optind + 1 + 0];
14573 char *dictfile2 = myargv[optind + 1 + 1];
14574
14575 // find the bigger dictionary and use as base
14576
14577 FILE *fp1 = NULL;
14578 FILE *fp2 = NULL;
14579
14580 struct stat tmp_stat;
14581
14582 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14583 {
14584 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14585
14586 return (-1);
14587 }
14588
14589 if (stat (dictfile1, &tmp_stat) == -1)
14590 {
14591 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14592
14593 fclose (fp1);
14594
14595 return (-1);
14596 }
14597
14598 if (S_ISDIR (tmp_stat.st_mode))
14599 {
14600 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14601
14602 fclose (fp1);
14603
14604 return (-1);
14605 }
14606
14607 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14608 {
14609 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14610
14611 fclose (fp1);
14612
14613 return (-1);
14614 }
14615
14616 if (stat (dictfile2, &tmp_stat) == -1)
14617 {
14618 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14619
14620 fclose (fp1);
14621 fclose (fp2);
14622
14623 return (-1);
14624 }
14625
14626 if (S_ISDIR (tmp_stat.st_mode))
14627 {
14628 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14629
14630 fclose (fp1);
14631 fclose (fp2);
14632
14633 return (-1);
14634 }
14635
14636 data.combs_cnt = 1;
14637
14638 data.quiet = 1;
14639
14640 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14641
14642 data.quiet = quiet;
14643
14644 if (words1_cnt == 0)
14645 {
14646 log_error ("ERROR: %s: empty file", dictfile1);
14647
14648 fclose (fp1);
14649 fclose (fp2);
14650
14651 return (-1);
14652 }
14653
14654 data.combs_cnt = 1;
14655
14656 data.quiet = 1;
14657
14658 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14659
14660 data.quiet = quiet;
14661
14662 if (words2_cnt == 0)
14663 {
14664 log_error ("ERROR: %s: empty file", dictfile2);
14665
14666 fclose (fp1);
14667 fclose (fp2);
14668
14669 return (-1);
14670 }
14671
14672 fclose (fp1);
14673 fclose (fp2);
14674
14675 data.dictfile = dictfile1;
14676 data.dictfile2 = dictfile2;
14677
14678 if (words1_cnt >= words2_cnt)
14679 {
14680 data.combs_cnt = words2_cnt;
14681 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14682
14683 dictfiles = &data.dictfile;
14684
14685 dictcnt = 1;
14686 }
14687 else
14688 {
14689 data.combs_cnt = words1_cnt;
14690 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14691
14692 dictfiles = &data.dictfile2;
14693
14694 dictcnt = 1;
14695
14696 // we also have to switch wordlist related rules!
14697
14698 char *tmpc = data.rule_buf_l;
14699
14700 data.rule_buf_l = data.rule_buf_r;
14701 data.rule_buf_r = tmpc;
14702
14703 int tmpi = data.rule_len_l;
14704
14705 data.rule_len_l = data.rule_len_r;
14706 data.rule_len_r = tmpi;
14707 }
14708 }
14709 else if (attack_mode == ATTACK_MODE_BF)
14710 {
14711 char *mask = NULL;
14712
14713 maskcnt = 0;
14714
14715 if (benchmark == 0)
14716 {
14717 mask = myargv[optind + 1];
14718
14719 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14720
14721 if ((optind + 2) <= myargc)
14722 {
14723 struct stat file_stat;
14724
14725 if (stat (mask, &file_stat) == -1)
14726 {
14727 maskcnt = 1;
14728
14729 masks[maskcnt - 1] = mystrdup (mask);
14730 }
14731 else
14732 {
14733 int wls_left = myargc - (optind + 1);
14734
14735 uint masks_avail = INCR_MASKS;
14736
14737 for (int i = 0; i < wls_left; i++)
14738 {
14739 if (i != 0)
14740 {
14741 mask = myargv[optind + 1 + i];
14742
14743 if (stat (mask, &file_stat) == -1)
14744 {
14745 log_error ("ERROR: %s: %s", mask, strerror (errno));
14746
14747 return (-1);
14748 }
14749 }
14750
14751 uint is_file = S_ISREG (file_stat.st_mode);
14752
14753 if (is_file == 1)
14754 {
14755 FILE *mask_fp;
14756
14757 if ((mask_fp = fopen (mask, "r")) == NULL)
14758 {
14759 log_error ("ERROR: %s: %s", mask, strerror (errno));
14760
14761 return (-1);
14762 }
14763
14764 char line_buf[BUFSIZ] = { 0 };
14765
14766 while (!feof (mask_fp))
14767 {
14768 memset (line_buf, 0, BUFSIZ);
14769
14770 int line_len = fgetl (mask_fp, line_buf);
14771
14772 if (line_len == 0) continue;
14773
14774 if (line_buf[0] == '#') continue;
14775
14776 if (masks_avail == maskcnt)
14777 {
14778 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14779
14780 masks_avail += INCR_MASKS;
14781 }
14782
14783 masks[maskcnt] = mystrdup (line_buf);
14784
14785 maskcnt++;
14786 }
14787
14788 fclose (mask_fp);
14789 }
14790 else
14791 {
14792 log_error ("ERROR: %s: unsupported file-type", mask);
14793
14794 return (-1);
14795 }
14796 }
14797
14798 mask_from_file = 1;
14799 }
14800 }
14801 else
14802 {
14803 custom_charset_1 = (char *) "?l?d?u";
14804 custom_charset_2 = (char *) "?l?d";
14805 custom_charset_3 = (char *) "?l?d*!$@_";
14806
14807 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14808 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14809 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14810
14811 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14812
14813 wordlist_mode = WL_MODE_MASK;
14814
14815 data.wordlist_mode = wordlist_mode;
14816
14817 increment = 1;
14818
14819 maskcnt = 1;
14820 }
14821 }
14822 else
14823 {
14824 /**
14825 * generate full masks and charsets
14826 */
14827
14828 masks = (char **) mymalloc (sizeof (char *));
14829
14830 switch (hash_mode)
14831 {
14832 case 1731: pw_min = 5;
14833 pw_max = 5;
14834 mask = mystrdup ("?b?b?b?b?b");
14835 break;
14836 case 12500: pw_min = 5;
14837 pw_max = 5;
14838 mask = mystrdup ("?b?b?b?b?b");
14839 break;
14840 default: pw_min = 7;
14841 pw_max = 7;
14842 mask = mystrdup ("?b?b?b?b?b?b?b");
14843 break;
14844 }
14845
14846 maskcnt = 1;
14847
14848 masks[maskcnt - 1] = mystrdup (mask);
14849
14850 wordlist_mode = WL_MODE_MASK;
14851
14852 data.wordlist_mode = wordlist_mode;
14853
14854 increment = 1;
14855 }
14856
14857 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14858
14859 if (increment)
14860 {
14861 if (increment_min > pw_min) pw_min = increment_min;
14862
14863 if (increment_max < pw_max) pw_max = increment_max;
14864 }
14865 }
14866 else if (attack_mode == ATTACK_MODE_HYBRID1)
14867 {
14868 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14869
14870 // display
14871
14872 char *mask = myargv[myargc - 1];
14873
14874 maskcnt = 0;
14875
14876 masks = (char **) mymalloc (1 * sizeof (char *));
14877
14878 // mod
14879
14880 struct stat file_stat;
14881
14882 if (stat (mask, &file_stat) == -1)
14883 {
14884 maskcnt = 1;
14885
14886 masks[maskcnt - 1] = mystrdup (mask);
14887 }
14888 else
14889 {
14890 uint is_file = S_ISREG (file_stat.st_mode);
14891
14892 if (is_file == 1)
14893 {
14894 FILE *mask_fp;
14895
14896 if ((mask_fp = fopen (mask, "r")) == NULL)
14897 {
14898 log_error ("ERROR: %s: %s", mask, strerror (errno));
14899
14900 return (-1);
14901 }
14902
14903 char line_buf[BUFSIZ] = { 0 };
14904
14905 uint masks_avail = 1;
14906
14907 while (!feof (mask_fp))
14908 {
14909 memset (line_buf, 0, BUFSIZ);
14910
14911 int line_len = fgetl (mask_fp, line_buf);
14912
14913 if (line_len == 0) continue;
14914
14915 if (line_buf[0] == '#') continue;
14916
14917 if (masks_avail == maskcnt)
14918 {
14919 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14920
14921 masks_avail += INCR_MASKS;
14922 }
14923
14924 masks[maskcnt] = mystrdup (line_buf);
14925
14926 maskcnt++;
14927 }
14928
14929 fclose (mask_fp);
14930
14931 mask_from_file = 1;
14932 }
14933 else
14934 {
14935 maskcnt = 1;
14936
14937 masks[maskcnt - 1] = mystrdup (mask);
14938 }
14939 }
14940
14941 // base
14942
14943 int wls_left = myargc - (optind + 2);
14944
14945 for (int i = 0; i < wls_left; i++)
14946 {
14947 char *filename = myargv[optind + 1 + i];
14948
14949 struct stat file_stat;
14950
14951 if (stat (filename, &file_stat) == -1)
14952 {
14953 log_error ("ERROR: %s: %s", filename, strerror (errno));
14954
14955 return (-1);
14956 }
14957
14958 uint is_dir = S_ISDIR (file_stat.st_mode);
14959
14960 if (is_dir == 0)
14961 {
14962 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14963
14964 dictcnt++;
14965
14966 dictfiles[dictcnt - 1] = filename;
14967 }
14968 else
14969 {
14970 // do not allow --keyspace w/ a directory
14971
14972 if (keyspace == 1)
14973 {
14974 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14975
14976 return (-1);
14977 }
14978
14979 char **dictionary_files = NULL;
14980
14981 dictionary_files = scan_directory (filename);
14982
14983 if (dictionary_files != NULL)
14984 {
14985 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14986
14987 for (int d = 0; dictionary_files[d] != NULL; d++)
14988 {
14989 char *l1_filename = dictionary_files[d];
14990
14991 struct stat l1_stat;
14992
14993 if (stat (l1_filename, &l1_stat) == -1)
14994 {
14995 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14996
14997 return (-1);
14998 }
14999
15000 if (S_ISREG (l1_stat.st_mode))
15001 {
15002 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15003
15004 dictcnt++;
15005
15006 dictfiles[dictcnt - 1] = strdup (l1_filename);
15007 }
15008 }
15009 }
15010
15011 local_free (dictionary_files);
15012 }
15013 }
15014
15015 if (dictcnt < 1)
15016 {
15017 log_error ("ERROR: No usable dictionary file found.");
15018
15019 return (-1);
15020 }
15021
15022 if (increment)
15023 {
15024 maskcnt = 0;
15025
15026 uint mask_min = increment_min; // we can't reject smaller masks here
15027 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15028
15029 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15030 {
15031 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15032
15033 if (cur_mask == NULL) break;
15034
15035 masks[maskcnt] = cur_mask;
15036
15037 maskcnt++;
15038
15039 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15040 }
15041 }
15042 }
15043 else if (attack_mode == ATTACK_MODE_HYBRID2)
15044 {
15045 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15046
15047 // display
15048
15049 char *mask = myargv[optind + 1 + 0];
15050
15051 maskcnt = 0;
15052
15053 masks = (char **) mymalloc (1 * sizeof (char *));
15054
15055 // mod
15056
15057 struct stat file_stat;
15058
15059 if (stat (mask, &file_stat) == -1)
15060 {
15061 maskcnt = 1;
15062
15063 masks[maskcnt - 1] = mystrdup (mask);
15064 }
15065 else
15066 {
15067 uint is_file = S_ISREG (file_stat.st_mode);
15068
15069 if (is_file == 1)
15070 {
15071 FILE *mask_fp;
15072
15073 if ((mask_fp = fopen (mask, "r")) == NULL)
15074 {
15075 log_error ("ERROR: %s: %s", mask, strerror (errno));
15076
15077 return (-1);
15078 }
15079
15080 char line_buf[BUFSIZ] = { 0 };
15081
15082 uint masks_avail = 1;
15083
15084 while (!feof (mask_fp))
15085 {
15086 memset (line_buf, 0, BUFSIZ);
15087
15088 int line_len = fgetl (mask_fp, line_buf);
15089
15090 if (line_len == 0) continue;
15091
15092 if (line_buf[0] == '#') continue;
15093
15094 if (masks_avail == maskcnt)
15095 {
15096 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15097
15098 masks_avail += INCR_MASKS;
15099 }
15100
15101 masks[maskcnt] = mystrdup (line_buf);
15102
15103 maskcnt++;
15104 }
15105
15106 fclose (mask_fp);
15107
15108 mask_from_file = 1;
15109 }
15110 else
15111 {
15112 maskcnt = 1;
15113
15114 masks[maskcnt - 1] = mystrdup (mask);
15115 }
15116 }
15117
15118 // base
15119
15120 int wls_left = myargc - (optind + 2);
15121
15122 for (int i = 0; i < wls_left; i++)
15123 {
15124 char *filename = myargv[optind + 2 + i];
15125
15126 struct stat file_stat;
15127
15128 if (stat (filename, &file_stat) == -1)
15129 {
15130 log_error ("ERROR: %s: %s", filename, strerror (errno));
15131
15132 return (-1);
15133 }
15134
15135 uint is_dir = S_ISDIR (file_stat.st_mode);
15136
15137 if (is_dir == 0)
15138 {
15139 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15140
15141 dictcnt++;
15142
15143 dictfiles[dictcnt - 1] = filename;
15144 }
15145 else
15146 {
15147 // do not allow --keyspace w/ a directory
15148
15149 if (keyspace == 1)
15150 {
15151 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15152
15153 return (-1);
15154 }
15155
15156 char **dictionary_files = NULL;
15157
15158 dictionary_files = scan_directory (filename);
15159
15160 if (dictionary_files != NULL)
15161 {
15162 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15163
15164 for (int d = 0; dictionary_files[d] != NULL; d++)
15165 {
15166 char *l1_filename = dictionary_files[d];
15167
15168 struct stat l1_stat;
15169
15170 if (stat (l1_filename, &l1_stat) == -1)
15171 {
15172 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15173
15174 return (-1);
15175 }
15176
15177 if (S_ISREG (l1_stat.st_mode))
15178 {
15179 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15180
15181 dictcnt++;
15182
15183 dictfiles[dictcnt - 1] = strdup (l1_filename);
15184 }
15185 }
15186 }
15187
15188 local_free (dictionary_files);
15189 }
15190 }
15191
15192 if (dictcnt < 1)
15193 {
15194 log_error ("ERROR: No usable dictionary file found.");
15195
15196 return (-1);
15197 }
15198
15199 if (increment)
15200 {
15201 maskcnt = 0;
15202
15203 uint mask_min = increment_min; // we can't reject smaller masks here
15204 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15205
15206 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15207 {
15208 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15209
15210 if (cur_mask == NULL) break;
15211
15212 masks[maskcnt] = cur_mask;
15213
15214 maskcnt++;
15215
15216 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15217 }
15218 }
15219 }
15220
15221 data.pw_min = pw_min;
15222 data.pw_max = pw_max;
15223
15224 /**
15225 * weak hash check
15226 */
15227
15228 if (weak_hash_threshold >= salts_cnt)
15229 {
15230 uint first_device_id = 0;
15231
15232 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15233 {
15234 hc_device_param_t *device_param = &data.devices_param[device_id];
15235
15236 if (device_param->skipped) continue;
15237
15238 first_device_id = device_id;
15239
15240 break;
15241 }
15242
15243 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15244
15245 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15246 {
15247 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15248 }
15249 }
15250
15251 // Display hack, guarantee that there is at least one \r before real start
15252
15253 if (data.quiet == 0) log_info_nn ("");
15254
15255 /**
15256 * status and monitor threads
15257 */
15258
15259 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15260
15261 hc_thread_t i_thread = 0;
15262
15263 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15264 {
15265 hc_thread_create (i_thread, thread_keypress, &benchmark);
15266 }
15267
15268 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15269
15270 uint ni_threads_cnt = 0;
15271
15272 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15273
15274 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15275
15276 ni_threads_cnt++;
15277
15278 /**
15279 * Outfile remove
15280 */
15281
15282 if (keyspace == 0)
15283 {
15284 if (outfile_check_timer != 0)
15285 {
15286 if (data.outfile_check_directory != NULL)
15287 {
15288 if ((hash_mode != 5200) &&
15289 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15290 (hash_mode != 9000))
15291 {
15292 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15293
15294 ni_threads_cnt++;
15295 }
15296 else
15297 {
15298 outfile_check_timer = 0;
15299 }
15300 }
15301 else
15302 {
15303 outfile_check_timer = 0;
15304 }
15305 }
15306 }
15307
15308 /**
15309 * Inform the user if we got some hashes remove because of the pot file remove feature
15310 */
15311
15312 if (data.quiet == 0)
15313 {
15314 if (potfile_remove_cracks > 0)
15315 {
15316 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15317 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15318 }
15319 }
15320
15321 data.outfile_check_timer = outfile_check_timer;
15322
15323 /**
15324 * main loop
15325 */
15326
15327 char **induction_dictionaries = NULL;
15328
15329 int induction_dictionaries_cnt = 0;
15330
15331 hcstat_table_t *root_table_buf = NULL;
15332 hcstat_table_t *markov_table_buf = NULL;
15333
15334 uint initial_restore_done = 0;
15335
15336 data.maskcnt = maskcnt;
15337
15338 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15339 {
15340 if (data.devices_status == STATUS_CRACKED) break;
15341
15342 data.devices_status = STATUS_INIT;
15343
15344 if (maskpos > rd->maskpos)
15345 {
15346 rd->dictpos = 0;
15347 }
15348
15349 rd->maskpos = maskpos;
15350 data.maskpos = maskpos;
15351
15352 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15353 {
15354 char *mask = masks[maskpos];
15355
15356 if (mask_from_file == 1)
15357 {
15358 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15359
15360 char *str_ptr;
15361 uint str_pos;
15362
15363 uint mask_offset = 0;
15364
15365 uint separator_cnt;
15366
15367 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15368 {
15369 str_ptr = strstr (mask + mask_offset, ",");
15370
15371 if (str_ptr == NULL) break;
15372
15373 str_pos = str_ptr - mask;
15374
15375 // escaped separator, i.e. "\,"
15376
15377 if (str_pos > 0)
15378 {
15379 if (mask[str_pos - 1] == '\\')
15380 {
15381 separator_cnt --;
15382
15383 mask_offset = str_pos + 1;
15384
15385 continue;
15386 }
15387 }
15388
15389 // reset the offset
15390
15391 mask_offset = 0;
15392
15393 mask[str_pos] = '\0';
15394
15395 switch (separator_cnt)
15396 {
15397 case 0:
15398 mp_reset_usr (mp_usr, 0);
15399
15400 custom_charset_1 = mask;
15401 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15402 break;
15403
15404 case 1:
15405 mp_reset_usr (mp_usr, 1);
15406
15407 custom_charset_2 = mask;
15408 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15409 break;
15410
15411 case 2:
15412 mp_reset_usr (mp_usr, 2);
15413
15414 custom_charset_3 = mask;
15415 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15416 break;
15417
15418 case 3:
15419 mp_reset_usr (mp_usr, 3);
15420
15421 custom_charset_4 = mask;
15422 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15423 break;
15424 }
15425
15426 mask = mask + str_pos + 1;
15427 }
15428 }
15429
15430 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15431 {
15432 if (maskpos > 0)
15433 {
15434 local_free (css_buf);
15435 local_free (data.root_css_buf);
15436 local_free (data.markov_css_buf);
15437
15438 local_free (masks[maskpos - 1]);
15439 }
15440
15441 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15442
15443 data.mask = mask;
15444 data.css_cnt = css_cnt;
15445 data.css_buf = css_buf;
15446
15447 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15448
15449 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15450
15451 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15452 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15453
15454 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15455
15456 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15457
15458 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15459 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15460
15461 data.root_css_buf = root_css_buf;
15462 data.markov_css_buf = markov_css_buf;
15463
15464 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15465
15466 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15467
15468 local_free (root_table_buf);
15469 local_free (markov_table_buf);
15470
15471 // args
15472
15473 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15474 {
15475 hc_device_param_t *device_param = &data.devices_param[device_id];
15476
15477 if (device_param->skipped) continue;
15478
15479 device_param->kernel_params_mp[0] = &device_param->d_combs;
15480 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15481 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15482
15483 device_param->kernel_params_mp_buf64[3] = 0;
15484 device_param->kernel_params_mp_buf32[4] = css_cnt;
15485 device_param->kernel_params_mp_buf32[5] = 0;
15486 device_param->kernel_params_mp_buf32[6] = 0;
15487 device_param->kernel_params_mp_buf32[7] = 0;
15488
15489 if (attack_mode == ATTACK_MODE_HYBRID1)
15490 {
15491 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15492 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15493 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15494 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15495 }
15496 else if (attack_mode == ATTACK_MODE_HYBRID2)
15497 {
15498 device_param->kernel_params_mp_buf32[5] = 0;
15499 device_param->kernel_params_mp_buf32[6] = 0;
15500 device_param->kernel_params_mp_buf32[7] = 0;
15501 }
15502
15503 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]);
15504 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]);
15505 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]);
15506
15507 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);
15508 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);
15509 }
15510 }
15511 else if (attack_mode == ATTACK_MODE_BF)
15512 {
15513 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15514
15515 if (increment)
15516 {
15517 for (uint i = 0; i < dictcnt; i++)
15518 {
15519 local_free (dictfiles[i]);
15520 }
15521
15522 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15523 {
15524 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15525
15526 if (l1_filename == NULL) break;
15527
15528 dictcnt++;
15529
15530 dictfiles[dictcnt - 1] = l1_filename;
15531 }
15532 }
15533 else
15534 {
15535 dictcnt++;
15536
15537 dictfiles[dictcnt - 1] = mask;
15538 }
15539
15540 if (dictcnt == 0)
15541 {
15542 log_error ("ERROR: Mask is too small");
15543
15544 return (-1);
15545 }
15546 }
15547 }
15548
15549 free (induction_dictionaries);
15550
15551 // induction_dictionaries_cnt = 0; // implied
15552
15553 if (attack_mode != ATTACK_MODE_BF)
15554 {
15555 if (keyspace == 0)
15556 {
15557 induction_dictionaries = scan_directory (induction_directory);
15558
15559 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15560 }
15561 }
15562
15563 if (induction_dictionaries_cnt)
15564 {
15565 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15566 }
15567
15568 /**
15569 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15570 */
15571 if (keyspace == 1)
15572 {
15573 if ((maskcnt > 1) || (dictcnt > 1))
15574 {
15575 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15576
15577 return (-1);
15578 }
15579 }
15580
15581 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15582 {
15583 char *subid = logfile_generate_subid ();
15584
15585 data.subid = subid;
15586
15587 logfile_sub_msg ("START");
15588
15589 data.devices_status = STATUS_INIT;
15590
15591 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15592 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15593 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15594
15595 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15596
15597 data.cpt_pos = 0;
15598
15599 data.cpt_start = time (NULL);
15600
15601 data.cpt_total = 0;
15602
15603 if (data.restore == 0)
15604 {
15605 rd->words_cur = skip;
15606
15607 skip = 0;
15608
15609 data.skip = 0;
15610 }
15611
15612 data.ms_paused = 0;
15613
15614 data.words_cur = rd->words_cur;
15615
15616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15617 {
15618 hc_device_param_t *device_param = &data.devices_param[device_id];
15619
15620 if (device_param->skipped) continue;
15621
15622 device_param->speed_pos = 0;
15623
15624 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15625 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15626 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15627
15628 device_param->kernel_power = device_param->kernel_power_user;
15629 device_param->kernel_blocks = device_param->kernel_blocks_user;
15630
15631 device_param->outerloop_pos = 0;
15632 device_param->outerloop_left = 0;
15633 device_param->innerloop_pos = 0;
15634 device_param->innerloop_left = 0;
15635
15636 // some more resets:
15637
15638 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15639
15640 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15641
15642 device_param->pw_cnt = 0;
15643 device_param->pws_cnt = 0;
15644
15645 device_param->words_off = 0;
15646 device_param->words_done = 0;
15647 }
15648
15649 data.kernel_blocks_div = 0;
15650
15651 // figure out some workload
15652
15653 if (attack_mode == ATTACK_MODE_STRAIGHT)
15654 {
15655 if (data.wordlist_mode == WL_MODE_FILE)
15656 {
15657 char *dictfile = NULL;
15658
15659 if (induction_dictionaries_cnt)
15660 {
15661 dictfile = induction_dictionaries[0];
15662 }
15663 else
15664 {
15665 dictfile = dictfiles[dictpos];
15666 }
15667
15668 data.dictfile = dictfile;
15669
15670 logfile_sub_string (dictfile);
15671
15672 for (uint i = 0; i < rp_files_cnt; i++)
15673 {
15674 logfile_sub_var_string ("rulefile", rp_files[i]);
15675 }
15676
15677 FILE *fd2 = fopen (dictfile, "rb");
15678
15679 if (fd2 == NULL)
15680 {
15681 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15682
15683 return (-1);
15684 }
15685
15686 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15687
15688 fclose (fd2);
15689
15690 if (data.words_cnt == 0)
15691 {
15692 if (data.devices_status == STATUS_CRACKED) break;
15693 if (data.devices_status == STATUS_ABORTED) break;
15694
15695 dictpos++;
15696
15697 continue;
15698 }
15699 }
15700 }
15701 else if (attack_mode == ATTACK_MODE_COMBI)
15702 {
15703 char *dictfile = data.dictfile;
15704 char *dictfile2 = data.dictfile2;
15705
15706 logfile_sub_string (dictfile);
15707 logfile_sub_string (dictfile2);
15708
15709 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15710 {
15711 FILE *fd2 = fopen (dictfile, "rb");
15712
15713 if (fd2 == NULL)
15714 {
15715 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15716
15717 return (-1);
15718 }
15719
15720 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15721
15722 fclose (fd2);
15723 }
15724 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15725 {
15726 FILE *fd2 = fopen (dictfile2, "rb");
15727
15728 if (fd2 == NULL)
15729 {
15730 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15731
15732 return (-1);
15733 }
15734
15735 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15736
15737 fclose (fd2);
15738 }
15739
15740 if (data.words_cnt == 0)
15741 {
15742 if (data.devices_status == STATUS_CRACKED) break;
15743 if (data.devices_status == STATUS_ABORTED) break;
15744
15745 dictpos++;
15746
15747 continue;
15748 }
15749 }
15750 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15751 {
15752 char *dictfile = NULL;
15753
15754 if (induction_dictionaries_cnt)
15755 {
15756 dictfile = induction_dictionaries[0];
15757 }
15758 else
15759 {
15760 dictfile = dictfiles[dictpos];
15761 }
15762
15763 data.dictfile = dictfile;
15764
15765 char *mask = data.mask;
15766
15767 logfile_sub_string (dictfile);
15768 logfile_sub_string (mask);
15769
15770 FILE *fd2 = fopen (dictfile, "rb");
15771
15772 if (fd2 == NULL)
15773 {
15774 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15775
15776 return (-1);
15777 }
15778
15779 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15780
15781 fclose (fd2);
15782
15783 if (data.words_cnt == 0)
15784 {
15785 if (data.devices_status == STATUS_CRACKED) break;
15786 if (data.devices_status == STATUS_ABORTED) break;
15787
15788 dictpos++;
15789
15790 continue;
15791 }
15792 }
15793 else if (attack_mode == ATTACK_MODE_BF)
15794 {
15795 local_free (css_buf);
15796 local_free (data.root_css_buf);
15797 local_free (data.markov_css_buf);
15798
15799 char *mask = dictfiles[dictpos];
15800
15801 logfile_sub_string (mask);
15802
15803 // base
15804
15805 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15806
15807 if (opts_type & OPTS_TYPE_PT_UNICODE)
15808 {
15809 uint css_cnt_unicode = css_cnt * 2;
15810
15811 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15812
15813 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15814 {
15815 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15816
15817 css_buf_unicode[j + 1].cs_buf[0] = 0;
15818 css_buf_unicode[j + 1].cs_len = 1;
15819 }
15820
15821 free (css_buf);
15822
15823 css_buf = css_buf_unicode;
15824 css_cnt = css_cnt_unicode;
15825 }
15826
15827 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15828
15829 uint mask_min = pw_min;
15830 uint mask_max = pw_max;
15831
15832 if (opts_type & OPTS_TYPE_PT_UNICODE)
15833 {
15834 mask_min *= 2;
15835 mask_max *= 2;
15836 }
15837
15838 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15839 {
15840 if (css_cnt < mask_min)
15841 {
15842 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15843 }
15844
15845 if (css_cnt > mask_max)
15846 {
15847 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15848 }
15849
15850 // skip to next mask
15851
15852 dictpos++;
15853
15854 rd->dictpos = dictpos;
15855
15856 logfile_sub_msg ("STOP");
15857
15858 continue;
15859 }
15860
15861 uint save_css_cnt = css_cnt;
15862
15863 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15864 {
15865 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15866 {
15867 uint salt_len = (uint) data.salts_buf[0].salt_len;
15868 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15869
15870 uint css_cnt_salt = css_cnt + salt_len;
15871
15872 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15873
15874 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15875
15876 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15877 {
15878 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15879 css_buf_salt[j].cs_len = 1;
15880 }
15881
15882 free (css_buf);
15883
15884 css_buf = css_buf_salt;
15885 css_cnt = css_cnt_salt;
15886 }
15887 }
15888
15889 data.mask = mask;
15890 data.css_cnt = css_cnt;
15891 data.css_buf = css_buf;
15892
15893 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15894
15895 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15896
15897 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15898
15899 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15900 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15901
15902 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15903
15904 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15905
15906 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15907 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15908
15909 data.root_css_buf = root_css_buf;
15910 data.markov_css_buf = markov_css_buf;
15911
15912 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15913
15914 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15915
15916 local_free (root_table_buf);
15917 local_free (markov_table_buf);
15918
15919 // copy + args
15920
15921 uint css_cnt_l = css_cnt;
15922 uint css_cnt_r;
15923
15924 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15925 {
15926 if (save_css_cnt < 6)
15927 {
15928 css_cnt_r = 1;
15929 }
15930 else if (save_css_cnt == 6)
15931 {
15932 css_cnt_r = 2;
15933 }
15934 else
15935 {
15936 if (opts_type & OPTS_TYPE_PT_UNICODE)
15937 {
15938 if (save_css_cnt == 8 || save_css_cnt == 10)
15939 {
15940 css_cnt_r = 2;
15941 }
15942 else
15943 {
15944 css_cnt_r = 4;
15945 }
15946 }
15947 else
15948 {
15949 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15950 {
15951 css_cnt_r = 3;
15952 }
15953 else
15954 {
15955 css_cnt_r = 4;
15956 }
15957 }
15958 }
15959 }
15960 else
15961 {
15962 css_cnt_r = 1;
15963
15964 /* unfinished code?
15965 int sum = css_buf[css_cnt_r - 1].cs_len;
15966
15967 for (uint i = 1; i < 4 && i < css_cnt; i++)
15968 {
15969 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15970
15971 css_cnt_r++;
15972
15973 sum *= css_buf[css_cnt_r - 1].cs_len;
15974 }
15975 */
15976 }
15977
15978 css_cnt_l -= css_cnt_r;
15979
15980 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15981
15982 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15983 {
15984 hc_device_param_t *device_param = &data.devices_param[device_id];
15985
15986 if (device_param->skipped) continue;
15987
15988 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15989 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15990 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15991
15992 device_param->kernel_params_mp_l_buf64[3] = 0;
15993 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15994 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15995 device_param->kernel_params_mp_l_buf32[6] = 0;
15996 device_param->kernel_params_mp_l_buf32[7] = 0;
15997 device_param->kernel_params_mp_l_buf32[8] = 0;
15998
15999 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16000 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16001 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16002 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16003
16004 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16005 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16006 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16007
16008 device_param->kernel_params_mp_r_buf64[3] = 0;
16009 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16010 device_param->kernel_params_mp_r_buf32[5] = 0;
16011 device_param->kernel_params_mp_r_buf32[6] = 0;
16012 device_param->kernel_params_mp_r_buf32[7] = 0;
16013
16014 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]);
16015 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]);
16016 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]);
16017
16018 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]);
16019 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]);
16020 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]);
16021
16022 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);
16023 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);
16024 }
16025 }
16026
16027 u64 words_base = data.words_cnt;
16028
16029 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16030 {
16031 if (data.kernel_rules_cnt)
16032 {
16033 words_base /= data.kernel_rules_cnt;
16034 }
16035 }
16036 else if (data.attack_kern == ATTACK_KERN_COMBI)
16037 {
16038 if (data.combs_cnt)
16039 {
16040 words_base /= data.combs_cnt;
16041 }
16042 }
16043 else if (data.attack_kern == ATTACK_KERN_BF)
16044 {
16045 if (data.bfs_cnt)
16046 {
16047 words_base /= data.bfs_cnt;
16048 }
16049 }
16050
16051 data.words_base = words_base;
16052
16053 if (keyspace == 1)
16054 {
16055 log_info ("%llu", (unsigned long long int) words_base);
16056
16057 return (0);
16058 }
16059
16060 if (data.words_cur > data.words_base)
16061 {
16062 log_error ("ERROR: restore value greater keyspace");
16063
16064 return (-1);
16065 }
16066
16067 if (data.words_cur)
16068 {
16069 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16070 {
16071 for (uint i = 0; i < data.salts_cnt; i++)
16072 {
16073 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16074 }
16075 }
16076 else if (data.attack_kern == ATTACK_KERN_COMBI)
16077 {
16078 for (uint i = 0; i < data.salts_cnt; i++)
16079 {
16080 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16081 }
16082 }
16083 else if (data.attack_kern == ATTACK_KERN_BF)
16084 {
16085 for (uint i = 0; i < data.salts_cnt; i++)
16086 {
16087 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16088 }
16089 }
16090 }
16091
16092 /*
16093 * Inform user about possible slow speeds
16094 */
16095
16096 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16097 {
16098 if (data.words_base < kernel_blocks_all)
16099 {
16100 if (quiet == 0)
16101 {
16102 log_info ("");
16103 log_info ("ATTENTION!");
16104 log_info (" The wordlist or mask you are using is too small.");
16105 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16106 log_info (" The cracking speed will drop.");
16107 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16108 log_info ("");
16109 }
16110 }
16111 }
16112
16113 /*
16114 * Update loopback file
16115 */
16116
16117 if (loopback == 1)
16118 {
16119 time_t now;
16120
16121 time (&now);
16122
16123 uint random_num = get_random_num (0, 9999);
16124
16125 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16126
16127 data.loopback_file = loopback_file;
16128 }
16129
16130 /*
16131 * Update dictionary statistic
16132 */
16133
16134 if (keyspace == 0)
16135 {
16136 dictstat_fp = fopen (dictstat, "wb");
16137
16138 if (dictstat_fp)
16139 {
16140 lock_file (dictstat_fp);
16141
16142 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16143
16144 fclose (dictstat_fp);
16145 }
16146 }
16147
16148 data.devices_status = STATUS_RUNNING;
16149
16150 if (initial_restore_done == 0)
16151 {
16152 if (data.restore_disable == 0) cycle_restore ();
16153
16154 initial_restore_done = 1;
16155 }
16156
16157 hc_timer_set (&data.timer_running);
16158
16159 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16160 {
16161 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16162 {
16163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16164 if (quiet == 0) fflush (stdout);
16165 }
16166 }
16167 else if (wordlist_mode == WL_MODE_STDIN)
16168 {
16169 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16170 if (data.quiet == 0) log_info ("");
16171 }
16172
16173 time_t runtime_start;
16174
16175 time (&runtime_start);
16176
16177 data.runtime_start = runtime_start;
16178
16179 /**
16180 * create cracker threads
16181 */
16182
16183 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16184
16185 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16186 {
16187 hc_device_param_t *device_param = &devices_param[device_id];
16188
16189 if (wordlist_mode == WL_MODE_STDIN)
16190 {
16191 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16192 }
16193 else
16194 {
16195 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16196 }
16197 }
16198
16199 // wait for crack threads to exit
16200
16201 hc_thread_wait (devices_cnt, c_threads);
16202
16203 local_free (c_threads);
16204
16205 data.restore = 0;
16206
16207 // finalize task
16208
16209 logfile_sub_var_uint ("status-after-work", data.devices_status);
16210
16211 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16212
16213 if (data.devices_status == STATUS_CRACKED) break;
16214 if (data.devices_status == STATUS_ABORTED) break;
16215
16216 if (data.devices_status == STATUS_BYPASS)
16217 {
16218 data.devices_status = STATUS_RUNNING;
16219 }
16220
16221 if (induction_dictionaries_cnt)
16222 {
16223 unlink (induction_dictionaries[0]);
16224 }
16225
16226 free (induction_dictionaries);
16227
16228 if (attack_mode != ATTACK_MODE_BF)
16229 {
16230 induction_dictionaries = scan_directory (induction_directory);
16231
16232 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16233 }
16234
16235 if (benchmark == 0)
16236 {
16237 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16238 {
16239 if (quiet == 0) clear_prompt ();
16240
16241 if (quiet == 0) log_info ("");
16242
16243 if (status == 1)
16244 {
16245 status_display ();
16246 }
16247 else
16248 {
16249 if (quiet == 0) status_display ();
16250 }
16251
16252 if (quiet == 0) log_info ("");
16253 }
16254 }
16255
16256 if (attack_mode == ATTACK_MODE_BF)
16257 {
16258 dictpos++;
16259
16260 rd->dictpos = dictpos;
16261 }
16262 else
16263 {
16264 if (induction_dictionaries_cnt)
16265 {
16266 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16267 }
16268 else
16269 {
16270 dictpos++;
16271
16272 rd->dictpos = dictpos;
16273 }
16274 }
16275
16276 time_t runtime_stop;
16277
16278 time (&runtime_stop);
16279
16280 data.runtime_stop = runtime_stop;
16281
16282 logfile_sub_uint (runtime_start);
16283 logfile_sub_uint (runtime_stop);
16284
16285 logfile_sub_msg ("STOP");
16286
16287 global_free (subid);
16288 }
16289
16290 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16291
16292 if (data.devices_status == STATUS_CRACKED) break;
16293 if (data.devices_status == STATUS_ABORTED) break;
16294 if (data.devices_status == STATUS_QUIT) break;
16295
16296 if (data.devices_status == STATUS_BYPASS)
16297 {
16298 data.devices_status = STATUS_RUNNING;
16299 }
16300 }
16301
16302 // 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
16303
16304 if (attack_mode == ATTACK_MODE_STRAIGHT)
16305 {
16306 if (data.wordlist_mode == WL_MODE_FILE)
16307 {
16308 if (data.dictfile == NULL)
16309 {
16310 if (dictfiles != NULL)
16311 {
16312 data.dictfile = dictfiles[0];
16313
16314 hc_timer_set (&data.timer_running);
16315 }
16316 }
16317 }
16318 }
16319 // NOTE: combi is okay because it is already set beforehand
16320 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16321 {
16322 if (data.dictfile == NULL)
16323 {
16324 if (dictfiles != NULL)
16325 {
16326 hc_timer_set (&data.timer_running);
16327
16328 data.dictfile = dictfiles[0];
16329 }
16330 }
16331 }
16332 else if (attack_mode == ATTACK_MODE_BF)
16333 {
16334 if (data.mask == NULL)
16335 {
16336 hc_timer_set (&data.timer_running);
16337
16338 data.mask = masks[0];
16339 }
16340 }
16341
16342 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16343 {
16344 data.devices_status = STATUS_EXHAUSTED;
16345 }
16346
16347 // if cracked / aborted remove last induction dictionary
16348
16349 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16350 {
16351 struct stat induct_stat;
16352
16353 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16354 {
16355 unlink (induction_dictionaries[file_pos]);
16356 }
16357 }
16358
16359 // wait for non-interactive threads
16360
16361 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16362 {
16363 hc_thread_wait (1, &ni_threads[thread_idx]);
16364 }
16365
16366 local_free (ni_threads);
16367
16368 // wait for interactive threads
16369
16370 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16371 {
16372 hc_thread_wait (1, &i_thread);
16373 }
16374
16375 // we dont need restore file anymore
16376 if (data.restore_disable == 0)
16377 {
16378 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16379 {
16380 unlink (eff_restore_file);
16381 unlink (new_restore_file);
16382 }
16383 else
16384 {
16385 cycle_restore ();
16386 }
16387 }
16388
16389 // finally save left hashes
16390
16391 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16392 {
16393 save_hash ();
16394 }
16395
16396 /**
16397 * Clean up
16398 */
16399
16400 if (benchmark == 1)
16401 {
16402 status_benchmark ();
16403
16404 log_info ("");
16405 }
16406 else
16407 {
16408 if (quiet == 0) clear_prompt ();
16409
16410 if (quiet == 0) log_info ("");
16411
16412 if (status == 1)
16413 {
16414 status_display ();
16415 }
16416 else
16417 {
16418 if (quiet == 0) status_display ();
16419 }
16420
16421 if (quiet == 0) log_info ("");
16422 }
16423
16424 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16425 {
16426 hc_device_param_t *device_param = &data.devices_param[device_id];
16427
16428 if (device_param->skipped) continue;
16429
16430 local_free (device_param->result);
16431
16432 local_free (device_param->pw_caches);
16433
16434 local_free (device_param->combs_buf);
16435
16436 local_free (device_param->hooks_buf);
16437
16438 local_free (device_param->device_name);
16439
16440 local_free (device_param->device_name_chksum);
16441
16442 local_free (device_param->device_version);
16443
16444 local_free (device_param->driver_version);
16445
16446 if (device_param->pws_buf) myfree (device_param->pws_buf);
16447 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16448 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16449 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16450 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16451 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16452 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16453 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16454 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16455 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16456 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16457 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16458 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16459 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16460 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16461 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16462 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16463 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16464 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16465 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16466 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16467 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16468 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16469 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16470 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16471 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16472 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16473 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16474 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16475
16476 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16477 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16478 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16479 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16480 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16481 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16482 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16483 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16484 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16485 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16486 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16487
16488 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16489 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16490 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16491
16492 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16493 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16494 }
16495
16496 // reset default fan speed
16497
16498 #ifdef HAVE_HWMON
16499 if (gpu_temp_disable == 0)
16500 {
16501 #ifdef HAVE_ADL
16502 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16503 {
16504 hc_thread_mutex_lock (mux_adl);
16505
16506 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16507 {
16508 hc_device_param_t *device_param = &data.devices_param[device_id];
16509
16510 if (device_param->skipped) continue;
16511
16512 if (data.hm_device[device_id].fan_supported == 1)
16513 {
16514 int fanspeed = temp_retain_fanspeed_value[device_id];
16515
16516 if (fanspeed == -1) continue;
16517
16518 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16519
16520 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16521 }
16522 }
16523
16524 hc_thread_mutex_unlock (mux_adl);
16525 }
16526 #endif // HAVE_ADL
16527 }
16528
16529 // reset power tuning
16530
16531 #ifdef HAVE_ADL
16532 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16533 {
16534 hc_thread_mutex_lock (mux_adl);
16535
16536 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16537 {
16538 hc_device_param_t *device_param = &data.devices_param[device_id];
16539
16540 if (device_param->skipped) continue;
16541
16542 if (data.hm_device[device_id].od_version == 6)
16543 {
16544 // check powertune capabilities first, if not available then skip device
16545
16546 int powertune_supported = 0;
16547
16548 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16549 {
16550 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16551
16552 return (-1);
16553 }
16554
16555 if (powertune_supported != 0)
16556 {
16557 // powercontrol settings
16558
16559 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)
16560 {
16561 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16562
16563 return (-1);
16564 }
16565
16566 // clocks
16567
16568 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16569
16570 performance_state->iNumberOfPerformanceLevels = 2;
16571
16572 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16573 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16574 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16575 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16576
16577 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)
16578 {
16579 log_info ("ERROR: Failed to restore ADL performance state");
16580
16581 return (-1);
16582 }
16583
16584 local_free (performance_state);
16585 }
16586 }
16587 }
16588
16589 hc_thread_mutex_unlock (mux_adl);
16590 }
16591 #endif // HAVE_ADL
16592
16593 if (gpu_temp_disable == 0)
16594 {
16595 #if defined(LINUX) && defined(HAVE_NVML)
16596 if (data.hm_dll_nv)
16597 {
16598 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16599
16600 hm_close (data.hm_dll_nv);
16601 }
16602 #endif
16603
16604 #if defined(WIN) && (HAVE_NVAPI)
16605 NvAPI_Unload ();
16606 #endif
16607
16608 #ifdef HAVE_ADL
16609 if (data.hm_dll_amd)
16610 {
16611 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16612
16613 hm_close (data.hm_dll_amd);
16614 }
16615 #endif
16616 }
16617 #endif // HAVE_HWMON
16618
16619 // free memory
16620
16621 local_free (masks);
16622
16623 local_free (dictstat_base);
16624
16625 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16626 {
16627 pot_t *pot_ptr = &pot[pot_pos];
16628
16629 hash_t *hash = &pot_ptr->hash;
16630
16631 local_free (hash->digest);
16632
16633 if (isSalted)
16634 {
16635 local_free (hash->salt);
16636 }
16637 }
16638
16639 local_free (pot);
16640
16641 local_free (all_kernel_rules_cnt);
16642 local_free (all_kernel_rules_buf);
16643
16644 local_free (wl_data->buf);
16645 local_free (wl_data);
16646
16647 local_free (bitmap_s1_a);
16648 local_free (bitmap_s1_b);
16649 local_free (bitmap_s1_c);
16650 local_free (bitmap_s1_d);
16651 local_free (bitmap_s2_a);
16652 local_free (bitmap_s2_b);
16653 local_free (bitmap_s2_c);
16654 local_free (bitmap_s2_d);
16655
16656 #ifdef HAVE_HWMON
16657 local_free (temp_retain_fanspeed_value);
16658 #ifdef HAVE_ADL
16659 local_free (od_clock_mem_status);
16660 local_free (od_power_control_status);
16661 #endif // ADL
16662 #endif
16663
16664 global_free (devices_param);
16665
16666 global_free (kernel_rules_buf);
16667
16668 global_free (root_css_buf);
16669 global_free (markov_css_buf);
16670
16671 global_free (digests_buf);
16672 global_free (digests_shown);
16673 global_free (digests_shown_tmp);
16674
16675 global_free (salts_buf);
16676 global_free (salts_shown);
16677
16678 global_free (esalts_buf);
16679
16680 global_free (words_progress_done);
16681 global_free (words_progress_rejected);
16682 global_free (words_progress_restored);
16683
16684 if (pot_fp) fclose (pot_fp);
16685
16686 if (data.devices_status == STATUS_QUIT) break;
16687 }
16688
16689 // destroy others mutex
16690
16691 hc_thread_mutex_delete (mux_dispatcher);
16692 hc_thread_mutex_delete (mux_counter);
16693 hc_thread_mutex_delete (mux_display);
16694 hc_thread_mutex_delete (mux_adl);
16695
16696 // free memory
16697
16698 local_free (eff_restore_file);
16699 local_free (new_restore_file);
16700
16701 local_free (rd);
16702
16703 // loopback
16704
16705 local_free (loopback_file);
16706
16707 if (loopback == 1) unlink (loopback_file);
16708
16709 // induction directory
16710
16711 if (induction_dir == NULL)
16712 {
16713 if (attack_mode != ATTACK_MODE_BF)
16714 {
16715 if (rmdir (induction_directory) == -1)
16716 {
16717 if (errno == ENOENT)
16718 {
16719 // good, we can ignore
16720 }
16721 else if (errno == ENOTEMPTY)
16722 {
16723 // good, we can ignore
16724 }
16725 else
16726 {
16727 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16728
16729 return (-1);
16730 }
16731 }
16732
16733 local_free (induction_directory);
16734 }
16735 }
16736
16737 // outfile-check directory
16738
16739 if (outfile_check_dir == NULL)
16740 {
16741 if (rmdir (outfile_check_directory) == -1)
16742 {
16743 if (errno == ENOENT)
16744 {
16745 // good, we can ignore
16746 }
16747 else if (errno == ENOTEMPTY)
16748 {
16749 // good, we can ignore
16750 }
16751 else
16752 {
16753 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16754
16755 return (-1);
16756 }
16757 }
16758
16759 local_free (outfile_check_directory);
16760 }
16761
16762 time_t proc_stop;
16763
16764 time (&proc_stop);
16765
16766 logfile_top_uint (proc_start);
16767 logfile_top_uint (proc_stop);
16768
16769 logfile_top_msg ("STOP");
16770
16771 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16772 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16773
16774 if (data.ocl) ocl_close (data.ocl);
16775
16776 if (data.devices_status == STATUS_ABORTED) return 2;
16777 if (data.devices_status == STATUS_QUIT) return 2;
16778 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16779 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16780 if (data.devices_status == STATUS_CRACKED) return 0;
16781
16782 return -1;
16783 }
Hashcat additions to support pwdhash