projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #196 from gm4tr1x/hwmon
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 #ifndef OSX
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 #else
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
397 #endif
398 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
399 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
400 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
401 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
402 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
403 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
404 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 #ifdef HAVE_HWMON
407 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
408 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
409 #ifdef HAVE_ADL
410 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
411 #endif
412 #endif
413 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
414 "",
415 "* Distributed:",
416 "",
417 " -s, --skip=NUM Skip number of words",
418 " -l, --limit=NUM Limit number of words",
419 " --keyspace Show keyspace base:mod values and quit",
420 "",
421 "* Rules:",
422 "",
423 " -j, --rule-left=RULE Single rule applied to each word from left dict",
424 " -k, --rule-right=RULE Single rule applied to each word from right dict",
425 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
426 " -g, --generate-rules=NUM Generate NUM random rules",
427 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
428 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
429 " --generate-rules-seed=NUM Force RNG seed to NUM",
430 "",
431 "* Custom charsets:",
432 "",
433 " -1, --custom-charset1=CS User-defined charsets",
434 " -2, --custom-charset2=CS Example:",
435 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
436 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
437 "",
438 "* Increment:",
439 "",
440 " -i, --increment Enable increment mode",
441 " --increment-min=NUM Start incrementing at NUM",
442 " --increment-max=NUM Stop incrementing at NUM",
443 "",
444 "==========",
445 "References",
446 "==========",
447 "",
448 "* Workload Profile:",
449 "",
450 " 1 = Reduced performance profile (low latency desktop)",
451 " 2 = Default performance profile",
452 " 3 = Tuned performance profile (high latency desktop)",
453 "",
454 "* Benchmark Settings:",
455 "",
456 " 0 = Manual Tuning",
457 " 1 = Performance Tuning, default",
458 "",
459 "* OpenCL device-types:",
460 "",
461 " 1 = CPU devices",
462 " 2 = GPU devices",
463 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
464 "",
465 "* Outfile Formats:",
466 "",
467 " 1 = hash[:salt]",
468 " 2 = plain",
469 " 3 = hash[:salt]:plain",
470 " 4 = hex_plain",
471 " 5 = hash[:salt]:hex_plain",
472 " 6 = plain:hex_plain",
473 " 7 = hash[:salt]:plain:hex_plain",
474 " 8 = crackpos",
475 " 9 = hash[:salt]:crackpos",
476 " 10 = plain:crackpos",
477 " 11 = hash[:salt]:plain:crackpos",
478 " 12 = hex_plain:crackpos",
479 " 13 = hash[:salt]:hex_plain:crackpos",
480 " 14 = plain:hex_plain:crackpos",
481 " 15 = hash[:salt]:plain:hex_plain:crackpos",
482 "",
483 "* Debug mode output formats (for hybrid mode only, by using rules):",
484 "",
485 " 1 = save finding rule",
486 " 2 = save original word",
487 " 3 = save original word and finding rule",
488 " 4 = save original word, finding rule and modified plain",
489 "",
490 "* Built-in charsets:",
491 "",
492 " ?l = abcdefghijklmnopqrstuvwxyz",
493 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
494 " ?d = 0123456789",
495 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
496 " ?a = ?l?u?d?s",
497 " ?b = 0x00 - 0xff",
498 "",
499 "* Attack modes:",
500 "",
501 " 0 = Straight",
502 " 1 = Combination",
503 " 3 = Brute-force",
504 " 6 = Hybrid dict + mask",
505 " 7 = Hybrid mask + dict",
506 "",
507 "* Hash types:",
508 "",
509 "[[ Roll-your-own: Raw Hashes ]]",
510 "",
511 " 900 = MD4",
512 " 0 = MD5",
513 " 5100 = Half MD5",
514 " 100 = SHA1",
515 " 10800 = SHA-384",
516 " 1400 = SHA-256",
517 " 1700 = SHA-512",
518 " 5000 = SHA-3(Keccak)",
519 " 10100 = SipHash",
520 " 6000 = RipeMD160",
521 " 6100 = Whirlpool",
522 " 6900 = GOST R 34.11-94",
523 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
524 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
525 "",
526 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
527 "",
528 " 10 = md5($pass.$salt)",
529 " 20 = md5($salt.$pass)",
530 " 30 = md5(unicode($pass).$salt)",
531 " 40 = md5($salt.unicode($pass))",
532 " 3800 = md5($salt.$pass.$salt)",
533 " 3710 = md5($salt.md5($pass))",
534 " 2600 = md5(md5($pass)",
535 " 4300 = md5(strtoupper(md5($pass)))",
536 " 4400 = md5(sha1($pass))",
537 " 110 = sha1($pass.$salt)",
538 " 120 = sha1($salt.$pass)",
539 " 130 = sha1(unicode($pass).$salt)",
540 " 140 = sha1($salt.unicode($pass))",
541 " 4500 = sha1(sha1($pass)",
542 " 4700 = sha1(md5($pass))",
543 " 4900 = sha1($salt.$pass.$salt)",
544 " 1410 = sha256($pass.$salt)",
545 " 1420 = sha256($salt.$pass)",
546 " 1430 = sha256(unicode($pass).$salt)",
547 " 1440 = sha256($salt.unicode($pass))",
548 " 1710 = sha512($pass.$salt)",
549 " 1720 = sha512($salt.$pass)",
550 " 1730 = sha512(unicode($pass).$salt)",
551 " 1740 = sha512($salt.unicode($pass))",
552 "",
553 "[[ Roll-your-own: Authenticated Hashes ]]",
554 "",
555 " 50 = HMAC-MD5 (key = $pass)",
556 " 60 = HMAC-MD5 (key = $salt)",
557 " 150 = HMAC-SHA1 (key = $pass)",
558 " 160 = HMAC-SHA1 (key = $salt)",
559 " 1450 = HMAC-SHA256 (key = $pass)",
560 " 1460 = HMAC-SHA256 (key = $salt)",
561 " 1750 = HMAC-SHA512 (key = $pass)",
562 " 1760 = HMAC-SHA512 (key = $salt)",
563 "",
564 "[[ Generic KDF ]]",
565 "",
566 " 400 = phpass",
567 " 8900 = scrypt",
568 " 11900 = PBKDF2-HMAC-MD5",
569 " 12000 = PBKDF2-HMAC-SHA1",
570 " 10900 = PBKDF2-HMAC-SHA256",
571 " 12100 = PBKDF2-HMAC-SHA512",
572 "",
573 "[[ Network protocols, Challenge-Response ]]",
574 "",
575 " 23 = Skype",
576 " 2500 = WPA/WPA2",
577 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
578 " 5300 = IKE-PSK MD5",
579 " 5400 = IKE-PSK SHA1",
580 " 5500 = NetNTLMv1",
581 " 5500 = NetNTLMv1 + ESS",
582 " 5600 = NetNTLMv2",
583 " 7300 = IPMI2 RAKP HMAC-SHA1",
584 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
585 " 8300 = DNSSEC (NSEC3)",
586 " 10200 = Cram MD5",
587 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
588 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
589 " 11400 = SIP digest authentication (MD5)",
590 "",
591 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
592 "",
593 " 121 = SMF (Simple Machines Forum)",
594 " 400 = phpBB3",
595 " 2611 = vBulletin < v3.8.5",
596 " 2711 = vBulletin > v3.8.5",
597 " 2811 = MyBB",
598 " 2811 = IPB (Invison Power Board)",
599 " 8400 = WBB3 (Woltlab Burning Board)",
600 " 11 = Joomla < 2.5.18",
601 " 400 = Joomla > 2.5.18",
602 " 400 = Wordpress",
603 " 2612 = PHPS",
604 " 7900 = Drupal7",
605 " 21 = osCommerce",
606 " 21 = xt:Commerce",
607 " 11000 = PrestaShop",
608 " 124 = Django (SHA-1)",
609 " 10000 = Django (PBKDF2-SHA256)",
610 " 3711 = Mediawiki B type",
611 " 7600 = Redmine",
612 "",
613 "[[ Database Server ]]",
614 "",
615 " 12 = PostgreSQL",
616 " 131 = MSSQL(2000)",
617 " 132 = MSSQL(2005)",
618 " 1731 = MSSQL(2012)",
619 " 1731 = MSSQL(2014)",
620 " 200 = MySQL323",
621 " 300 = MySQL4.1/MySQL5",
622 " 3100 = Oracle H: Type (Oracle 7+)",
623 " 112 = Oracle S: Type (Oracle 11+)",
624 " 12300 = Oracle T: Type (Oracle 12+)",
625 " 8000 = Sybase ASE",
626 "",
627 "[[ HTTP, SMTP, LDAP Server ]]",
628 "",
629 " 141 = EPiServer 6.x < v4",
630 " 1441 = EPiServer 6.x > v4",
631 " 1600 = Apache $apr1$",
632 " 12600 = ColdFusion 10+",
633 " 1421 = hMailServer",
634 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
635 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
636 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
637 "",
638 "[[ Checksums ]]",
639 "",
640 " 11500 = CRC32",
641 "",
642 "[[ Operating-Systems ]]",
643 "",
644 " 3000 = LM",
645 " 1000 = NTLM",
646 " 1100 = Domain Cached Credentials (DCC), MS Cache",
647 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
648 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
649 " 1500 = descrypt, DES(Unix), Traditional DES",
650 " 12400 = BSDiCrypt, Extended DES",
651 " 500 = md5crypt $1$, MD5(Unix)",
652 " 3200 = bcrypt $2*$, Blowfish(Unix)",
653 " 7400 = sha256crypt $5$, SHA256(Unix)",
654 " 1800 = sha512crypt $6$, SHA512(Unix)",
655 " 122 = OSX v10.4",
656 " 122 = OSX v10.5",
657 " 122 = OSX v10.6",
658 " 1722 = OSX v10.7",
659 " 7100 = OSX v10.8",
660 " 7100 = OSX v10.9",
661 " 7100 = OSX v10.10",
662 " 6300 = AIX {smd5}",
663 " 6700 = AIX {ssha1}",
664 " 6400 = AIX {ssha256}",
665 " 6500 = AIX {ssha512}",
666 " 2400 = Cisco-PIX",
667 " 2410 = Cisco-ASA",
668 " 500 = Cisco-IOS $1$",
669 " 5700 = Cisco-IOS $4$",
670 " 9200 = Cisco-IOS $8$",
671 " 9300 = Cisco-IOS $9$",
672 " 22 = Juniper Netscreen/SSG (ScreenOS)",
673 " 501 = Juniper IVE",
674 " 5800 = Android PIN",
675 " 8100 = Citrix Netscaler",
676 " 8500 = RACF",
677 " 7200 = GRUB 2",
678 " 9900 = Radmin2",
679 "",
680 "[[ Enterprise Application Software (EAS) ]]",
681 "",
682 " 7700 = SAP CODVN B (BCODE)",
683 " 7800 = SAP CODVN F/G (PASSCODE)",
684 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
685 " 8600 = Lotus Notes/Domino 5",
686 " 8700 = Lotus Notes/Domino 6",
687 " 9100 = Lotus Notes/Domino 8",
688 " 133 = PeopleSoft",
689 "",
690 "[[ Archives ]]",
691 "",
692 " 11600 = 7-Zip",
693 " 12500 = RAR3-hp",
694 " 13000 = RAR5",
695 "",
696 "[[ Full-Disk encryptions (FDE) ]]",
697 "",
698 " 62XY = TrueCrypt 5.0+",
699 " X = 1 = PBKDF2-HMAC-RipeMD160",
700 " X = 2 = PBKDF2-HMAC-SHA512",
701 " X = 3 = PBKDF2-HMAC-Whirlpool",
702 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
703 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
704 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
705 " Y = 3 = XTS 1536 bit (Ciphers: All)",
706 " 8800 = Android FDE < v4.3",
707 " 12900 = Android FDE (Samsung DEK)",
708 " 12200 = eCryptfs",
709 "",
710 "[[ Documents ]]",
711 "",
712 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
713 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
714 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
715 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
716 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
717 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
718 " 9400 = MS Office 2007",
719 " 9500 = MS Office 2010",
720 " 9600 = MS Office 2013",
721 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
722 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
723 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
724 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
725 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
726 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
727 "",
728 "[[ Password Managers ]]",
729 "",
730 " 9000 = Password Safe v2",
731 " 5200 = Password Safe v3",
732 " 6800 = Lastpass",
733 " 6600 = 1Password, agilekeychain",
734 " 8200 = 1Password, cloudkeychain",
735 " 11300 = Bitcoin/Litecoin wallet.dat",
736 " 12700 = Blockchain, My Wallet",
737 "",
738 NULL
739 };
740
741 /**
742 * oclHashcat specific functions
743 */
744
745 void status_display_automat ()
746 {
747 FILE *out = stdout;
748
749 fprintf (out, "STATUS\t%u\t", data.devices_status);
750
751 /**
752 * speed new
753 */
754
755 fprintf (out, "SPEED\t");
756
757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
758 {
759 hc_device_param_t *device_param = &data.devices_param[device_id];
760
761 if (device_param->skipped) continue;
762
763 u64 speed_cnt = 0;
764 float speed_ms = 0;
765
766 for (int i = 0; i < SPEED_CACHE; i++)
767 {
768 float rec_ms;
769
770 hc_timer_get (device_param->speed_rec[i], rec_ms);
771
772 if (rec_ms > SPEED_MAXAGE) continue;
773
774 speed_cnt += device_param->speed_cnt[i];
775 speed_ms += device_param->speed_ms[i];
776 }
777
778 speed_cnt /= SPEED_CACHE;
779 speed_ms /= SPEED_CACHE;
780
781 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
782 }
783
784 /**
785 * words_cur
786 */
787
788 u64 words_cur = get_lowest_words_done ();
789
790 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
791
792 /**
793 * counter
794 */
795
796 uint salts_left = data.salts_cnt - data.salts_done;
797
798 if (salts_left == 0) salts_left = 1;
799
800 u64 progress_total = data.words_cnt * salts_left;
801
802 u64 all_done = 0;
803 u64 all_rejected = 0;
804 u64 all_restored = 0;
805
806 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
807 {
808 if (salts_left > 1)
809 {
810 // otherwise the final cracked status shows 0/XXX progress
811
812 if (data.salts_shown[salt_pos] == 1) continue;
813 }
814
815 all_done += data.words_progress_done[salt_pos];
816 all_rejected += data.words_progress_rejected[salt_pos];
817 all_restored += data.words_progress_restored[salt_pos];
818 }
819
820 u64 progress_cur = all_restored + all_done + all_rejected;
821 u64 progress_end = progress_total;
822
823 u64 progress_skip = 0;
824
825 if (data.skip)
826 {
827 progress_skip = MIN (data.skip, data.words_base) * salts_left;
828
829 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
830 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
831 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
832 }
833
834 if (data.limit)
835 {
836 progress_end = MIN (data.limit, data.words_base) * salts_left;
837
838 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
839 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
840 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
841 }
842
843 u64 progress_cur_relative_skip = progress_cur - progress_skip;
844 u64 progress_end_relative_skip = progress_end - progress_skip;
845
846 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
847
848 /**
849 * cracks
850 */
851
852 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
853 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
854
855 /**
856 * temperature
857 */
858
859 #ifdef HAVE_HWMON
860 if (data.gpu_temp_disable == 0)
861 {
862 fprintf (out, "TEMP\t");
863
864 hc_thread_mutex_lock (mux_adl);
865
866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
867 {
868 hc_device_param_t *device_param = &data.devices_param[device_id];
869
870 if (device_param->skipped) continue;
871
872 int temp = hm_get_temperature_with_device_id (device_id);
873
874 fprintf (out, "%d\t", temp);
875 }
876
877 hc_thread_mutex_unlock (mux_adl);
878 }
879 #endif // HAVE_HWMON
880
881 #ifdef _WIN
882 fputc ('\r', out);
883 fputc ('\n', out);
884 #endif
885
886 #ifdef _POSIX
887 fputc ('\n', out);
888 #endif
889
890 fflush (out);
891 }
892
893 void status_display ()
894 {
895 if (data.devices_status == STATUS_INIT) return;
896 if (data.devices_status == STATUS_STARTING) return;
897 if (data.devices_status == STATUS_BYPASS) return;
898
899 if (data.status_automat == 1)
900 {
901 status_display_automat ();
902
903 return;
904 }
905
906 char tmp_buf[1000] = { 0 };
907
908 uint tmp_len = 0;
909
910 log_info ("Session.Name...: %s", data.session);
911
912 char *status_type = strstatus (data.devices_status);
913
914 uint hash_mode = data.hash_mode;
915
916 char *hash_type = strhashtype (hash_mode); // not a bug
917
918 log_info ("Status.........: %s", status_type);
919
920 /**
921 * show rules
922 */
923
924 if (data.rp_files_cnt)
925 {
926 uint i;
927
928 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
929 {
930 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
931 }
932
933 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
934
935 log_info ("Rules.Type.....: %s", tmp_buf);
936
937 tmp_len = 0;
938 }
939
940 if (data.rp_gen)
941 {
942 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
943
944 if (data.rp_gen_seed)
945 {
946 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
947 }
948 }
949
950 /**
951 * show input
952 */
953
954 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
955 {
956 if (data.wordlist_mode == WL_MODE_FILE)
957 {
958 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
959 }
960 else if (data.wordlist_mode == WL_MODE_STDIN)
961 {
962 log_info ("Input.Mode.....: Pipe");
963 }
964 }
965 else if (data.attack_mode == ATTACK_MODE_COMBI)
966 {
967 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
968 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
969 }
970 else if (data.attack_mode == ATTACK_MODE_BF)
971 {
972 char *mask = data.mask;
973
974 if (mask != NULL)
975 {
976 uint mask_len = data.css_cnt;
977
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
979
980 if (mask_len > 0)
981 {
982 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
983 {
984 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
985 {
986 mask_len -= data.salts_buf[0].salt_len;
987 }
988 }
989
990 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
991
992 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
993 }
994
995 if (data.maskcnt > 1)
996 {
997 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1000 }
1001
1002 log_info ("Input.Mode.....: %s", tmp_buf);
1003 }
1004
1005 tmp_len = 0;
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1008 {
1009 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1010 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1013 {
1014 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1015 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1016 }
1017
1018 if (data.digests_cnt == 1)
1019 {
1020 if (data.hash_mode == 2500)
1021 {
1022 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1023
1024 uint pke[25] = { 0 };
1025
1026 char *pke_ptr = (char *) pke;
1027
1028 for (uint i = 0; i < 25; i++)
1029 {
1030 pke[i] = byte_swap_32 (wpa->pke[i]);
1031 }
1032
1033 char mac1[6] = { 0 };
1034 char mac2[6] = { 0 };
1035
1036 memcpy (mac1, pke_ptr + 23, 6);
1037 memcpy (mac2, pke_ptr + 29, 6);
1038
1039 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1040 (char *) data.salts_buf[0].salt_buf,
1041 mac1[0] & 0xff,
1042 mac1[1] & 0xff,
1043 mac1[2] & 0xff,
1044 mac1[3] & 0xff,
1045 mac1[4] & 0xff,
1046 mac1[5] & 0xff,
1047 mac2[0] & 0xff,
1048 mac2[1] & 0xff,
1049 mac2[2] & 0xff,
1050 mac2[3] & 0xff,
1051 mac2[4] & 0xff,
1052 mac2[5] & 0xff);
1053 }
1054 else if (data.hash_mode == 5200)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if (data.hash_mode == 9000)
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else
1067 {
1068 char out_buf[4096] = { 0 };
1069
1070 ascii_digest (out_buf, 0, 0);
1071
1072 // limit length
1073 if (strlen (out_buf) > 40)
1074 {
1075 out_buf[41] = '.';
1076 out_buf[42] = '.';
1077 out_buf[43] = '.';
1078 out_buf[44] = 0;
1079 }
1080
1081 log_info ("Hash.Target....: %s", out_buf);
1082 }
1083 }
1084 else
1085 {
1086 if (data.hash_mode == 3000)
1087 {
1088 char out_buf1[4096] = { 0 };
1089 char out_buf2[4096] = { 0 };
1090
1091 ascii_digest (out_buf1, 0, 0);
1092 ascii_digest (out_buf2, 0, 1);
1093
1094 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1095 }
1096 else
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 }
1101
1102 log_info ("Hash.Type......: %s", hash_type);
1103
1104 /**
1105 * speed new
1106 */
1107
1108 u64 speed_cnt[DEVICES_MAX] = { 0 };
1109 float speed_ms[DEVICES_MAX] = { 0 };
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hc_device_param_t *device_param = &data.devices_param[device_id];
1114
1115 if (device_param->skipped) continue;
1116
1117 // we need to clear values (set to 0) because in case the device does
1118 // not get new candidates it idles around but speed display would
1119 // show it as working.
1120 // if we instantly set it to 0 after reading it happens that the
1121 // speed can be shown as zero if the users refreshes too fast.
1122 // therefore, we add a timestamp when a stat was recorded and if its
1123 // too old we will not use it
1124
1125 speed_cnt[device_id] = 0;
1126 speed_ms[device_id] = 0;
1127
1128 for (int i = 0; i < SPEED_CACHE; i++)
1129 {
1130 float rec_ms;
1131
1132 hc_timer_get (device_param->speed_rec[i], rec_ms);
1133
1134 if (rec_ms > SPEED_MAXAGE) continue;
1135
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 float hashes_all_ms = 0;
1145
1146 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * timers
1166 */
1167
1168 float ms_running = 0;
1169
1170 hc_timer_get (data.timer_running, ms_running);
1171
1172 float ms_paused = data.ms_paused;
1173
1174 if (data.devices_status == STATUS_PAUSED)
1175 {
1176 float ms_paused_tmp = 0;
1177
1178 hc_timer_get (data.timer_paused, ms_paused_tmp);
1179
1180 ms_paused += ms_paused_tmp;
1181 }
1182
1183 #ifdef WIN
1184
1185 __time64_t sec_run = ms_running / 1000;
1186
1187 #else
1188
1189 time_t sec_run = ms_running / 1000;
1190
1191 #endif
1192
1193 if (sec_run)
1194 {
1195 char display_run[32] = { 0 };
1196
1197 struct tm tm_run;
1198
1199 struct tm *tmp = NULL;
1200
1201 #ifdef WIN
1202
1203 tmp = _gmtime64 (&sec_run);
1204
1205 #else
1206
1207 tmp = gmtime (&sec_run);
1208
1209 #endif
1210
1211 if (tmp != NULL)
1212 {
1213 memset (&tm_run, 0, sizeof (tm_run));
1214
1215 memcpy (&tm_run, tmp, sizeof (tm_run));
1216
1217 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1218
1219 char *start = ctime (&data.proc_start);
1220
1221 size_t start_len = strlen (start);
1222
1223 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1224 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1225
1226 log_info ("Time.Started...: %s (%s)", start, display_run);
1227 }
1228 }
1229 else
1230 {
1231 log_info ("Time.Started...: 0 secs");
1232 }
1233
1234 /**
1235 * counters
1236 */
1237
1238 uint salts_left = data.salts_cnt - data.salts_done;
1239
1240 if (salts_left == 0) salts_left = 1;
1241
1242 u64 progress_total = data.words_cnt * salts_left;
1243
1244 u64 all_done = 0;
1245 u64 all_rejected = 0;
1246 u64 all_restored = 0;
1247
1248 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1249 {
1250 if (salts_left > 1)
1251 {
1252 // otherwise the final cracked status shows 0/XXX progress
1253
1254 if (data.salts_shown[salt_pos] == 1) continue;
1255 }
1256
1257 all_done += data.words_progress_done[salt_pos];
1258 all_rejected += data.words_progress_rejected[salt_pos];
1259 all_restored += data.words_progress_restored[salt_pos];
1260 }
1261
1262 u64 progress_cur = all_restored + all_done + all_rejected;
1263 u64 progress_end = progress_total;
1264
1265 u64 progress_skip = 0;
1266
1267 if (data.skip)
1268 {
1269 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1270
1271 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1272 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1273 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1274 }
1275
1276 if (data.limit)
1277 {
1278 progress_end = MIN (data.limit, data.words_base) * salts_left;
1279
1280 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1281 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1282 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1283 }
1284
1285 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1286 u64 progress_end_relative_skip = progress_end - progress_skip;
1287
1288 float speed_ms_real = ms_running - ms_paused;
1289 u64 speed_plains_real = all_done;
1290
1291 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1292 {
1293 if (data.devices_status != STATUS_CRACKED)
1294 {
1295 u64 words_per_ms = 0;
1296
1297 if (speed_plains_real && speed_ms_real)
1298 {
1299 words_per_ms = speed_plains_real / speed_ms_real;
1300 }
1301
1302 #ifdef WIN
1303 __time64_t sec_etc = 0;
1304 #else
1305 time_t sec_etc = 0;
1306 #endif
1307
1308 if (words_per_ms)
1309 {
1310 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1311
1312 u64 ms_left = progress_left_relative_skip / words_per_ms;
1313
1314 sec_etc = ms_left / 1000;
1315 }
1316
1317 if (sec_etc == 0)
1318 {
1319 log_info ("Time.Estimated.: 0 secs");
1320 }
1321 else if ((u64) sec_etc > ETC_MAX)
1322 {
1323 log_info ("Time.Estimated.: > 10 Years");
1324 }
1325 else
1326 {
1327 char display_etc[32] = { 0 };
1328
1329 struct tm tm_etc;
1330
1331 struct tm *tmp = NULL;
1332
1333 #ifdef WIN
1334
1335 tmp = _gmtime64 (&sec_etc);
1336
1337 #else
1338
1339 tmp = gmtime (&sec_etc);
1340
1341 #endif
1342
1343 if (tmp != NULL)
1344 {
1345 memset (&tm_etc, 0, sizeof (tm_etc));
1346
1347 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1348
1349 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1350
1351 time_t now;
1352
1353 time (&now);
1354
1355 now += sec_etc;
1356
1357 char *etc = ctime (&now);
1358
1359 size_t etc_len = strlen (etc);
1360
1361 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1362 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1363
1364 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1365 }
1366 }
1367 }
1368 }
1369
1370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1371 {
1372 hc_device_param_t *device_param = &data.devices_param[device_id];
1373
1374 if (device_param->skipped) continue;
1375
1376 char display_dev_cur[16] = { 0 };
1377
1378 strncpy (display_dev_cur, "0.00", 4);
1379
1380 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1381
1382 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1383 }
1384
1385 char display_all_cur[16] = { 0 };
1386
1387 strncpy (display_all_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1390
1391 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1392
1393 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1394 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1395
1396 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1397
1398 // crack-per-time
1399
1400 if (data.digests_cnt > 100)
1401 {
1402 time_t now = time (NULL);
1403
1404 int cpt_cur_min = 0;
1405 int cpt_cur_hour = 0;
1406 int cpt_cur_day = 0;
1407
1408 for (int i = 0; i < CPT_BUF; i++)
1409 {
1410 const uint cracked = data.cpt_buf[i].cracked;
1411 const time_t timestamp = data.cpt_buf[i].timestamp;
1412
1413 if ((timestamp + 60) > now)
1414 {
1415 cpt_cur_min += cracked;
1416 }
1417
1418 if ((timestamp + 3600) > now)
1419 {
1420 cpt_cur_hour += cracked;
1421 }
1422
1423 if ((timestamp + 86400) > now)
1424 {
1425 cpt_cur_day += cracked;
1426 }
1427 }
1428
1429 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1430 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1431 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1432
1433 if ((data.cpt_start + 86400) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_cur_hour,
1438 cpt_cur_day,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else if ((data.cpt_start + 3600) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 60) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else
1461 {
1462 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 }
1468
1469 // Restore point
1470
1471 u64 restore_point = get_lowest_words_done ();
1472
1473 u64 restore_total = data.words_base;
1474
1475 float percent_restore = 0;
1476
1477 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1478
1479 if (progress_end_relative_skip)
1480 {
1481 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1482 {
1483 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1484 float percent_rejected = 0.0;
1485
1486 if (progress_cur)
1487 {
1488 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1489 }
1490
1491 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1492 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1493
1494 if (data.restore_disable == 0)
1495 {
1496 if (percent_finished != 1)
1497 {
1498 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1499 }
1500 }
1501 }
1502 }
1503 else
1504 {
1505 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1506 {
1507 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509
1510 if (data.restore_disable == 0)
1511 {
1512 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513 }
1514 }
1515 else
1516 {
1517 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1518 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1519
1520 // --restore not allowed if stdin is used -- really? why?
1521
1522 //if (data.restore_disable == 0)
1523 //{
1524 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1525 //}
1526 }
1527 }
1528
1529 #ifdef HAVE_HWMON
1530 if (data.gpu_temp_disable == 0)
1531 {
1532 hc_thread_mutex_lock (mux_adl);
1533
1534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1535 {
1536 hc_device_param_t *device_param = &data.devices_param[device_id];
1537
1538 if (device_param->skipped) continue;
1539
1540 #define HM_STR_BUF_SIZE 255
1541
1542 if (data.hm_device[device_id].fan_supported == 1)
1543 {
1544 char utilization[HM_STR_BUF_SIZE] = { 0 };
1545 char temperature[HM_STR_BUF_SIZE] = { 0 };
1546 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1547
1548 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1549 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1550
1551 if (device_param->vendor_id == VENDOR_ID_AMD)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555 else if (device_param->vendor_id == VENDOR_ID_NV)
1556 {
1557 #ifdef LINUX
1558 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1559 #else
1560 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1561 #endif
1562 }
1563
1564 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1565 }
1566 else
1567 {
1568 char utilization[HM_STR_BUF_SIZE] = { 0 };
1569 char temperature[HM_STR_BUF_SIZE] = { 0 };
1570
1571 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1572 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1573
1574 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1575 }
1576 }
1577
1578 hc_thread_mutex_unlock (mux_adl);
1579 }
1580 #endif // HAVE_HWMON
1581 }
1582
1583 static void status_benchmark ()
1584 {
1585 if (data.devices_status == STATUS_INIT) return;
1586 if (data.devices_status == STATUS_STARTING) return;
1587
1588 if (data.words_cnt == 0) return;
1589
1590 u64 speed_cnt[DEVICES_MAX] = { 0 };
1591 float speed_ms[DEVICES_MAX] = { 0 };
1592
1593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1594 {
1595 hc_device_param_t *device_param = &data.devices_param[device_id];
1596
1597 if (device_param->skipped) continue;
1598
1599 speed_cnt[device_id] = 0;
1600 speed_ms[device_id] = 0;
1601
1602 for (int i = 0; i < SPEED_CACHE; i++)
1603 {
1604 speed_cnt[device_id] += device_param->speed_cnt[i];
1605 speed_ms[device_id] += device_param->speed_ms[i];
1606 }
1607
1608 speed_cnt[device_id] /= SPEED_CACHE;
1609 speed_ms[device_id] /= SPEED_CACHE;
1610 }
1611
1612 float hashes_all_ms = 0;
1613
1614 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 hashes_dev_ms[device_id] = 0;
1623
1624 if (speed_ms[device_id])
1625 {
1626 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1627
1628 hashes_all_ms += hashes_dev_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 char display_dev_cur[16] = { 0 };
1639
1640 strncpy (display_dev_cur, "0.00", 4);
1641
1642 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1643
1644 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1645 }
1646
1647 char display_all_cur[16] = { 0 };
1648
1649 strncpy (display_all_cur, "0.00", 4);
1650
1651 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1652
1653 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1654 }
1655
1656 /**
1657 * oclHashcat -only- functions
1658 */
1659
1660 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1661 {
1662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1663 {
1664 if (attack_kern == ATTACK_KERN_STRAIGHT)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1666 else if (attack_kern == ATTACK_KERN_COMBI)
1667 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1668 else if (attack_kern == ATTACK_KERN_BF)
1669 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1670 }
1671 else
1672 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1673 }
1674
1675 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1676 {
1677 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1678 {
1679 if (attack_kern == ATTACK_KERN_STRAIGHT)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 else if (attack_kern == ATTACK_KERN_COMBI)
1682 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1683 else if (attack_kern == ATTACK_KERN_BF)
1684 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1685 }
1686 else
1687 {
1688 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1689 }
1690 }
1691
1692 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1693 {
1694 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1695 {
1696 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1697 }
1698 else
1699 {
1700 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1701 }
1702 }
1703
1704 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1705 {
1706 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1707 {
1708 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1709 }
1710 else
1711 {
1712 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1713 }
1714 }
1715
1716 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1717 {
1718 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1719 }
1720
1721 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1722 {
1723 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1724 }
1725
1726 static uint convert_from_hex (char *line_buf, const uint line_len)
1727 {
1728 if (line_len & 1) return (line_len); // not in hex
1729
1730 if (data.hex_wordlist == 1)
1731 {
1732 uint i;
1733 uint j;
1734
1735 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1736 {
1737 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1738 }
1739
1740 memset (line_buf + i, 0, line_len - i);
1741
1742 return (i);
1743 }
1744 else if (line_len >= 6) // $HEX[] = 6
1745 {
1746 if (line_buf[0] != '$') return (line_len);
1747 if (line_buf[1] != 'H') return (line_len);
1748 if (line_buf[2] != 'E') return (line_len);
1749 if (line_buf[3] != 'X') return (line_len);
1750 if (line_buf[4] != '[') return (line_len);
1751 if (line_buf[line_len - 1] != ']') return (line_len);
1752
1753 uint i;
1754 uint j;
1755
1756 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1757 {
1758 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1759 }
1760
1761 memset (line_buf + i, 0, line_len - i);
1762
1763 return (i);
1764 }
1765
1766 return (line_len);
1767 }
1768
1769 static uint count_lines (FILE *fd)
1770 {
1771 uint cnt = 0;
1772
1773 char *buf = (char *) mymalloc (BUFSIZ + 1);
1774
1775 size_t nread_tmp = 0;
1776
1777 char *ptr = buf;
1778
1779 while (!feof (fd))
1780 {
1781 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1782 nread_tmp = nread;
1783
1784 if (nread < 1) continue;
1785
1786 ptr = buf;
1787
1788 do
1789 {
1790 if (*ptr++ == '\n') cnt++;
1791
1792 } while (nread--);
1793 }
1794
1795 // special case (if last line did not contain a newline char ... at the very end of the file)
1796
1797 if (nread_tmp > 3)
1798 {
1799 ptr -= 2;
1800
1801 if (*ptr != '\n')
1802 {
1803 ptr--;
1804
1805 if (*ptr != '\n') // needed ? different on windows systems?
1806 {
1807 cnt++;
1808 }
1809 }
1810 }
1811
1812 myfree (buf);
1813
1814 return cnt;
1815 }
1816
1817 static void clear_prompt ()
1818 {
1819 fputc ('\r', stdout);
1820
1821 for (size_t i = 0; i < strlen (PROMPT); i++)
1822 {
1823 fputc (' ', stdout);
1824 }
1825
1826 fputc ('\r', stdout);
1827
1828 fflush (stdout);
1829 }
1830
1831 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1832 {
1833 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1834 }
1835
1836 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1837 {
1838 char *outfile = data.outfile;
1839 uint quiet = data.quiet;
1840 FILE *pot_fp = data.pot_fp;
1841 uint loopback = data.loopback;
1842 uint debug_mode = data.debug_mode;
1843 char *debug_file = data.debug_file;
1844
1845 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1846 int debug_rule_len = 0; // -1 error
1847 uint debug_plain_len = 0;
1848
1849 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1850
1851 // hash
1852
1853 char out_buf[4096] = { 0 };
1854
1855 ascii_digest (out_buf, salt_pos, digest_pos);
1856
1857 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1858
1859 // plain
1860
1861 plain_t plain;
1862
1863 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1864
1865 uint gidvid = plain.gidvid;
1866 uint il_pos = plain.il_pos;
1867
1868 u64 crackpos = device_param->words_off;
1869
1870 uint plain_buf[16] = { 0 };
1871
1872 u8 *plain_ptr = (u8 *) plain_buf;
1873 unsigned int plain_len = 0;
1874
1875 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1876 {
1877 u64 gidd = gidvid;
1878 u64 gidm = 0;
1879
1880 pw_t pw;
1881
1882 gidd_to_pw_t (device_param, gidd, &pw);
1883
1884 for (int i = 0, j = gidm; i < 16; i++, j++)
1885 {
1886 plain_buf[i] = pw.h.hi1[0][j];
1887 }
1888
1889 plain_len = pw.pw_len;
1890
1891 const uint off = device_param->innerloop_pos + il_pos;
1892
1893 if (debug_mode > 0)
1894 {
1895 debug_rule_len = 0;
1896
1897 // save rule
1898 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1899 {
1900 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1901
1902 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1903 }
1904
1905 // save plain
1906 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1907 {
1908 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1909
1910 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1911
1912 debug_plain_len = plain_len;
1913 }
1914 }
1915
1916 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1917
1918 crackpos += gidvid;
1919 crackpos *= data.kernel_rules_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921
1922 if (plain_len > data.pw_max) plain_len = data.pw_max;
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_COMBI)
1925 {
1926 u64 gidd = gidvid;
1927 u64 gidm = 0;
1928
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidd, &pw);
1932
1933 for (int i = 0, j = gidm; i < 16; i++, j++)
1934 {
1935 plain_buf[i] = pw.h.hi1[0][j];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1941 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1942
1943 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1944 {
1945 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1946 }
1947 else
1948 {
1949 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1950
1951 memcpy (plain_ptr, comb_buf, comb_len);
1952 }
1953
1954 plain_len += comb_len;
1955
1956 crackpos += gidvid;
1957 crackpos *= data.combs_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (data.pw_max != PW_DICTMAX1)
1961 {
1962 if (plain_len > data.pw_max) plain_len = data.pw_max;
1963 }
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_BF)
1966 {
1967 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1968 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1969
1970 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1971 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1972
1973 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1974 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1975
1976 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1977 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1978
1979 plain_len = data.css_cnt;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.bfs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984 }
1985 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1986 {
1987 u64 gidd = gidvid;
1988 u64 gidm = 0;
1989
1990 pw_t pw;
1991
1992 gidd_to_pw_t (device_param, gidd, &pw);
1993
1994 for (int i = 0, j = gidm; i < 16; i++, j++)
1995 {
1996 plain_buf[i] = pw.h.hi1[0][j];
1997 }
1998
1999 plain_len = pw.pw_len;
2000
2001 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2002
2003 uint start = 0;
2004 uint stop = device_param->kernel_params_mp_buf32[4];
2005
2006 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2007
2008 plain_len += start + stop;
2009
2010 crackpos += gidvid;
2011 crackpos *= data.combs_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013
2014 if (data.pw_max != PW_DICTMAX1)
2015 {
2016 if (plain_len > data.pw_max) plain_len = data.pw_max;
2017 }
2018 }
2019 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2020 {
2021 u64 gidd = gidvid;
2022 u64 gidm = 0;
2023
2024 pw_t pw;
2025
2026 gidd_to_pw_t (device_param, gidd, &pw);
2027
2028 for (int i = 0, j = gidm; i < 16; i++, j++)
2029 {
2030 plain_buf[i] = pw.h.hi1[0][j];
2031 }
2032
2033 plain_len = pw.pw_len;
2034
2035 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2036
2037 uint start = 0;
2038 uint stop = device_param->kernel_params_mp_buf32[4];
2039
2040 memmove (plain_ptr + stop, plain_ptr, plain_len);
2041
2042 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2043
2044 plain_len += start + stop;
2045
2046 crackpos += gidvid;
2047 crackpos *= data.combs_cnt;
2048 crackpos += device_param->innerloop_pos + il_pos;
2049
2050 if (data.pw_max != PW_DICTMAX1)
2051 {
2052 if (plain_len > data.pw_max) plain_len = data.pw_max;
2053 }
2054 }
2055
2056 if (data.attack_mode == ATTACK_MODE_BF)
2057 {
2058 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2059 {
2060 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2061 {
2062 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2063 {
2064 plain_len = plain_len - data.salts_buf[0].salt_len;
2065 }
2066 }
2067
2068 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2069 {
2070 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2071 {
2072 plain_ptr[j] = plain_ptr[i];
2073 }
2074
2075 plain_len = plain_len / 2;
2076 }
2077 }
2078 }
2079
2080 // if enabled, update also the potfile
2081
2082 if (pot_fp)
2083 {
2084 lock_file (pot_fp);
2085
2086 fprintf (pot_fp, "%s:", out_buf);
2087
2088 format_plain (pot_fp, plain_ptr, plain_len, 1);
2089
2090 fputc ('\n', pot_fp);
2091
2092 fflush (pot_fp);
2093
2094 unlock_file (pot_fp);
2095 }
2096
2097 // outfile
2098
2099 FILE *out_fp = NULL;
2100
2101 if (outfile != NULL)
2102 {
2103 if ((out_fp = fopen (outfile, "ab")) == NULL)
2104 {
2105 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2106
2107 out_fp = stdout;
2108 }
2109 lock_file (out_fp);
2110 }
2111 else
2112 {
2113 out_fp = stdout;
2114
2115 if (quiet == 0) clear_prompt ();
2116 }
2117
2118 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2119
2120 if (outfile != NULL)
2121 {
2122 if (out_fp != stdout)
2123 {
2124 fclose (out_fp);
2125 }
2126 }
2127 else
2128 {
2129 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2130 {
2131 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2132 {
2133 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2134 if (quiet == 0) fflush (stdout);
2135 }
2136 }
2137 }
2138
2139 // loopback
2140
2141 if (loopback)
2142 {
2143 char *loopback_file = data.loopback_file;
2144
2145 FILE *fb_fp = NULL;
2146
2147 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2148 {
2149 lock_file (fb_fp);
2150
2151 format_plain (fb_fp, plain_ptr, plain_len, 1);
2152
2153 fputc ('\n', fb_fp);
2154
2155 fclose (fb_fp);
2156 }
2157 }
2158
2159 // (rule) debug mode
2160
2161 // the next check implies that:
2162 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2163 // - debug_mode > 0
2164
2165 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2166 {
2167 if (debug_rule_len < 0) debug_rule_len = 0;
2168
2169 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2170
2171 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2172
2173 if ((quiet == 0) && (debug_file == NULL))
2174 {
2175 fprintf (stdout, "%s", PROMPT);
2176 fflush (stdout);
2177 }
2178 }
2179 }
2180
2181 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2182 {
2183 salt_t *salt_buf = &data.salts_buf[salt_pos];
2184
2185 int found = 0;
2186
2187 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2188
2189 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2190
2191 if (found == 1)
2192 {
2193 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2194
2195 log_info_nn ("");
2196
2197 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2198
2199 uint cpt_cracked = 0;
2200
2201 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2202 {
2203 uint idx = salt_buf->digests_offset + digest_pos;
2204
2205 if (data.digests_shown_tmp[idx] == 0) continue;
2206
2207 if (data.digests_shown[idx] == 1) continue;
2208
2209 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2210 {
2211 data.digests_shown[idx] = 1;
2212
2213 data.digests_done++;
2214
2215 cpt_cracked++;
2216
2217 salt_buf->digests_done++;
2218
2219 if (salt_buf->digests_done == salt_buf->digests_cnt)
2220 {
2221 data.salts_shown[salt_pos] = 1;
2222
2223 data.salts_done++;
2224 }
2225 }
2226
2227 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2228
2229 check_hash (device_param, salt_pos, digest_pos);
2230 }
2231
2232 if (cpt_cracked > 0)
2233 {
2234 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2235 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2236
2237 data.cpt_pos++;
2238
2239 data.cpt_total += cpt_cracked;
2240
2241 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2242 }
2243
2244 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2245 {
2246 // we need to reset cracked state on the device
2247 // otherwise host thinks again and again the hash was cracked
2248 // and returns invalid password each time
2249
2250 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2251
2252 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2253 }
2254
2255 memset (device_param->result, 0, device_param->size_results);
2256
2257 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2258 }
2259 }
2260
2261 static void save_hash ()
2262 {
2263 char *hashfile = data.hashfile;
2264
2265 char new_hashfile[256] = { 0 };
2266 char old_hashfile[256] = { 0 };
2267
2268 snprintf (new_hashfile, 255, "%s.new", hashfile);
2269 snprintf (old_hashfile, 255, "%s.old", hashfile);
2270
2271 unlink (new_hashfile);
2272
2273 char separator = data.separator;
2274
2275 FILE *fp = fopen (new_hashfile, "wb");
2276
2277 if (fp == NULL)
2278 {
2279 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2280
2281 exit (-1);
2282 }
2283
2284 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2285 {
2286 if (data.salts_shown[salt_pos] == 1) continue;
2287
2288 salt_t *salt_buf = &data.salts_buf[salt_pos];
2289
2290 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2291 {
2292 uint idx = salt_buf->digests_offset + digest_pos;
2293
2294 if (data.digests_shown[idx] == 1) continue;
2295
2296 if (data.hash_mode != 2500)
2297 {
2298 char out_buf[4096] = { 0 };
2299
2300 if (data.username == 1)
2301 {
2302 user_t *user = data.hash_info[idx]->user;
2303
2304 uint i;
2305
2306 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2307
2308 fputc (separator, fp);
2309 }
2310
2311 ascii_digest (out_buf, salt_pos, digest_pos);
2312
2313 fputs (out_buf, fp);
2314
2315 log_out (fp, "");
2316 }
2317 else
2318 {
2319 hccap_t hccap;
2320
2321 to_hccap_t (&hccap, salt_pos, digest_pos);
2322
2323 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2324 }
2325 }
2326 }
2327
2328 fflush (fp);
2329
2330 fclose (fp);
2331
2332 unlink (old_hashfile);
2333
2334 if (rename (hashfile, old_hashfile) != 0)
2335 {
2336 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2337
2338 exit (-1);
2339 }
2340
2341 unlink (hashfile);
2342
2343 if (rename (new_hashfile, hashfile) != 0)
2344 {
2345 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2346
2347 exit (-1);
2348 }
2349
2350 unlink (old_hashfile);
2351 }
2352
2353 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2354 {
2355 // function called only in case kernel_blocks_all > words_left)
2356
2357 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2358
2359 kernel_blocks_div += kernel_blocks_div / 100;
2360
2361 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2362
2363 while (kernel_blocks_new < total_left)
2364 {
2365 kernel_blocks_div += kernel_blocks_div / 100;
2366
2367 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2368 }
2369
2370 if (data.quiet == 0)
2371 {
2372 clear_prompt ();
2373
2374 log_info ("");
2375
2376 log_info ("INFO: approaching final keyspace, workload adjusted");
2377
2378 log_info ("");
2379
2380 fprintf (stdout, "%s", PROMPT);
2381
2382 fflush (stdout);
2383 }
2384
2385 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2386
2387 return kernel_blocks_div;
2388 }
2389
2390 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2391 {
2392 uint num_elements = num;
2393
2394 device_param->kernel_params_buf32[30] = data.combs_mode;
2395 device_param->kernel_params_buf32[31] = num;
2396
2397 uint kernel_threads = device_param->kernel_threads;
2398
2399 while (num_elements % kernel_threads) num_elements++;
2400
2401 cl_kernel kernel = NULL;
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_1: kernel = device_param->kernel1; break;
2406 case KERN_RUN_12: kernel = device_param->kernel12; break;
2407 case KERN_RUN_2: kernel = device_param->kernel2; break;
2408 case KERN_RUN_23: kernel = device_param->kernel23; break;
2409 case KERN_RUN_3: kernel = device_param->kernel3; break;
2410 }
2411
2412 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2413 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2414 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2415 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2416 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2417 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2418 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2419 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2420 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2421 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2422 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2423
2424 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2425 {
2426 const size_t global_work_size[3] = { num_elements, 32, 1 };
2427 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2428
2429 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2430 }
2431 else
2432 {
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2437
2438 if (rc != CL_SUCCESS)
2439 {
2440 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2443 }
2444 }
2445
2446 hc_clFlush (data.ocl, device_param->command_queue);
2447
2448 hc_clFinish (data.ocl, device_param->command_queue);
2449 }
2450
2451 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2452 {
2453 uint num_elements = num;
2454
2455 switch (kern_run)
2456 {
2457 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2458 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2459 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2460 }
2461
2462 // causes problems with special threads like in bcrypt
2463 // const uint kernel_threads = device_param->kernel_threads;
2464
2465 const uint kernel_threads = KERNEL_THREADS;
2466
2467 while (num_elements % kernel_threads) num_elements++;
2468
2469 cl_kernel kernel = NULL;
2470
2471 switch (kern_run)
2472 {
2473 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2474 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2475 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2476 }
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2481 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2482 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2483 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2484 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2485 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2486 break;
2487 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2493 break;
2494 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2495 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2496 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2497 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2498 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2499 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2500 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2501 break;
2502 }
2503
2504 const size_t global_work_size[3] = { num_elements, 1, 1 };
2505 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2506
2507 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2508
2509 if (rc != CL_SUCCESS)
2510 {
2511 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2512
2513 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2514 }
2515
2516 hc_clFlush (data.ocl, device_param->command_queue);
2517
2518 hc_clFinish (data.ocl, device_param->command_queue);
2519 }
2520
2521 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2522 {
2523 uint num_elements = num;
2524
2525 uint kernel_threads = device_param->kernel_threads;
2526
2527 while (num_elements % kernel_threads) num_elements++;
2528
2529 cl_kernel kernel = device_param->kernel_tb;
2530
2531 const size_t global_work_size[3] = { num_elements, 1, 1 };
2532 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2533
2534 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2535
2536 hc_clFlush (data.ocl, device_param->command_queue);
2537
2538 hc_clFinish (data.ocl, device_param->command_queue);
2539 }
2540
2541 static void run_kernel_tm (hc_device_param_t *device_param)
2542 {
2543 const uint num_elements = 1024; // fixed
2544
2545 const uint kernel_threads = 32;
2546
2547 cl_kernel kernel = device_param->kernel_tm;
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2553
2554 hc_clFlush (data.ocl, device_param->command_queue);
2555
2556 hc_clFinish (data.ocl, device_param->command_queue);
2557 }
2558
2559 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2560 {
2561 uint num_elements = num;
2562
2563 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2564 device_param->kernel_params_amp_buf32[6] = num_elements;
2565
2566 // causes problems with special threads like in bcrypt
2567 // const uint kernel_threads = device_param->kernel_threads;
2568
2569 const uint kernel_threads = KERNEL_THREADS;
2570
2571 while (num_elements % kernel_threads) num_elements++;
2572
2573 cl_kernel kernel = device_param->kernel_amp;
2574
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2589 {
2590 if (device_param->vendor_id == VENDOR_ID_AMD)
2591 {
2592 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2593
2594 const cl_uchar zero = 0;
2595
2596 hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2597 }
2598 else
2599 {
2600 // NOTE: clEnqueueFillBuffer () always fails with -59
2601 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2602 // How's that possible, OpenCL 1.2 support is advertised??
2603 // We need to workaround...
2604
2605 #define FILLSZ 0x100000
2606
2607 char *tmp = (char *) mymalloc (FILLSZ);
2608
2609 for (uint i = 0; i < size; i += FILLSZ)
2610 {
2611 const int left = size - i;
2612
2613 const int fillsz = MIN (FILLSZ, left);
2614
2615 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2616 }
2617
2618 myfree (tmp);
2619 }
2620 }
2621
2622 static int run_rule_engine (const int rule_len, const char *rule_buf)
2623 {
2624 if (rule_len == 0)
2625 {
2626 return 0;
2627 }
2628 else if (rule_len == 1)
2629 {
2630 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2631 }
2632
2633 return 1;
2634 }
2635
2636 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2637 {
2638 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2639 {
2640 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2641 }
2642 else if (data.attack_kern == ATTACK_KERN_COMBI)
2643 {
2644 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2645 }
2646 else if (data.attack_kern == ATTACK_KERN_BF)
2647 {
2648 const u64 off = device_param->words_off;
2649
2650 device_param->kernel_params_mp_l_buf64[3] = off;
2651
2652 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2653 }
2654 }
2655
2656 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2657 {
2658 const uint kernel_loops = data.kernel_loops;
2659
2660 // init speed timer
2661
2662 uint speed_pos = device_param->speed_pos;
2663
2664 #ifdef _POSIX
2665 if (device_param->timer_speed.tv_sec == 0)
2666 {
2667 hc_timer_set (&device_param->timer_speed);
2668 }
2669 #endif
2670
2671 #ifdef _WIN
2672 if (device_param->timer_speed.QuadPart == 0)
2673 {
2674 hc_timer_set (&device_param->timer_speed);
2675 }
2676 #endif
2677
2678 // find higest password length, this is for optimization stuff
2679
2680 uint highest_pw_len = 0;
2681
2682 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2683 {
2684 }
2685 else if (data.attack_kern == ATTACK_KERN_COMBI)
2686 {
2687 }
2688 else if (data.attack_kern == ATTACK_KERN_BF)
2689 {
2690 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2691 + device_param->kernel_params_mp_l_buf32[5];
2692 }
2693
2694 // bitslice optimization stuff
2695
2696 if (data.attack_mode == ATTACK_MODE_BF)
2697 {
2698 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2699 {
2700 run_kernel_tb (device_param, pws_cnt);
2701 }
2702 }
2703
2704 // iteration type
2705
2706 uint innerloop_step = 0;
2707 uint innerloop_cnt = 0;
2708
2709 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2710 else innerloop_step = 1;
2711
2712 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2713 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2714 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2715
2716 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2717
2718 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2719 {
2720 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2721
2722 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2723
2724 if (data.devices_status == STATUS_CRACKED) break;
2725 if (data.devices_status == STATUS_ABORTED) break;
2726 if (data.devices_status == STATUS_QUIT) break;
2727 if (data.devices_status == STATUS_BYPASS) break;
2728
2729 if (data.salts_shown[salt_pos] == 1) continue;
2730
2731 salt_t *salt_buf = &data.salts_buf[salt_pos];
2732
2733 device_param->kernel_params_buf32[24] = salt_pos;
2734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2736
2737 FILE *combs_fp = device_param->combs_fp;
2738
2739 if (data.attack_mode == ATTACK_MODE_COMBI)
2740 {
2741 rewind (combs_fp);
2742 }
2743
2744 // innerloops
2745
2746 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2747 {
2748 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2749
2750 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2751
2752 if (data.devices_status == STATUS_CRACKED) break;
2753 if (data.devices_status == STATUS_ABORTED) break;
2754 if (data.devices_status == STATUS_QUIT) break;
2755 if (data.devices_status == STATUS_BYPASS) break;
2756
2757 uint innerloop_left = innerloop_cnt - innerloop_pos;
2758
2759 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2760
2761 device_param->innerloop_pos = innerloop_pos;
2762 device_param->innerloop_left = innerloop_left;
2763
2764 device_param->kernel_params_buf32[27] = innerloop_left;
2765
2766 if (innerloop_left == 0) continue;
2767
2768 // initialize amplifiers
2769
2770 if (data.attack_mode == ATTACK_MODE_COMBI)
2771 {
2772 char line_buf[BUFSIZ] = { 0 };
2773
2774 uint i = 0;
2775
2776 while (i < innerloop_left)
2777 {
2778 if (feof (combs_fp)) break;
2779
2780 int line_len = fgetl (combs_fp, line_buf);
2781
2782 if (line_len >= PW_MAX1) continue;
2783
2784 line_len = convert_from_hex (line_buf, line_len);
2785
2786 char *line_buf_new = line_buf;
2787
2788 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2789 {
2790 char rule_buf_out[BLOCK_SIZE] = { 0 };
2791
2792 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2793
2794 if (rule_len_out < 0)
2795 {
2796 data.words_progress_rejected[salt_pos] += pw_cnt;
2797
2798 continue;
2799 }
2800
2801 line_len = rule_len_out;
2802
2803 line_buf_new = rule_buf_out;
2804 }
2805
2806 line_len = MIN (line_len, PW_DICTMAX);
2807
2808 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2809
2810 memcpy (ptr, line_buf_new, line_len);
2811
2812 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2813
2814 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2815 {
2816 uppercase (ptr, line_len);
2817 }
2818
2819 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2820 {
2821 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2822 {
2823 ptr[line_len] = 0x80;
2824 }
2825
2826 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2827 {
2828 ptr[line_len] = 0x01;
2829 }
2830 }
2831
2832 device_param->combs_buf[i].pw_len = line_len;
2833
2834 i++;
2835 }
2836
2837 for (uint j = i; j < innerloop_left; j++)
2838 {
2839 device_param->combs_buf[j].i[0] = 0;
2840 device_param->combs_buf[j].i[1] = 0;
2841 device_param->combs_buf[j].i[2] = 0;
2842 device_param->combs_buf[j].i[3] = 0;
2843 device_param->combs_buf[j].i[4] = 0;
2844 device_param->combs_buf[j].i[5] = 0;
2845 device_param->combs_buf[j].i[6] = 0;
2846 device_param->combs_buf[j].i[7] = 0;
2847
2848 device_param->combs_buf[j].pw_len = 0;
2849 }
2850
2851 innerloop_left = i;
2852 }
2853 else if (data.attack_mode == ATTACK_MODE_BF)
2854 {
2855 u64 off = innerloop_pos;
2856
2857 device_param->kernel_params_mp_r_buf64[3] = off;
2858
2859 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2860 }
2861 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2862 {
2863 u64 off = innerloop_pos;
2864
2865 device_param->kernel_params_mp_buf64[3] = off;
2866
2867 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2868 }
2869 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2870 {
2871 u64 off = innerloop_pos;
2872
2873 device_param->kernel_params_mp_buf64[3] = off;
2874
2875 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2876 }
2877
2878 // copy amplifiers
2879
2880 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2881 {
2882 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2883 }
2884 else if (data.attack_mode == ATTACK_MODE_COMBI)
2885 {
2886 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2887 }
2888 else if (data.attack_mode == ATTACK_MODE_BF)
2889 {
2890 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2891 }
2892 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2893 {
2894 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2895 }
2896 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2897 {
2898 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2899 }
2900
2901 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2902 {
2903 if (data.attack_mode == ATTACK_MODE_BF)
2904 {
2905 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2906 {
2907 const uint size_tm = 32 * sizeof (bs_word_t);
2908
2909 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2910
2911 run_kernel_tm (device_param);
2912
2913 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2914 }
2915 }
2916
2917 if (highest_pw_len < 16)
2918 {
2919 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2920 }
2921 else if (highest_pw_len < 32)
2922 {
2923 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2924 }
2925 else
2926 {
2927 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2928 }
2929 }
2930 else
2931 {
2932 run_kernel_amp (device_param, pws_cnt);
2933
2934 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2935
2936 if (data.opts_type & OPTS_TYPE_HOOK12)
2937 {
2938 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2939 }
2940
2941 uint iter = salt_buf->salt_iter;
2942
2943 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2944 {
2945 uint loop_left = iter - loop_pos;
2946
2947 loop_left = MIN (loop_left, kernel_loops);
2948
2949 device_param->kernel_params_buf32[25] = loop_pos;
2950 device_param->kernel_params_buf32[26] = loop_left;
2951
2952 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2953
2954 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2955
2956 if (data.devices_status == STATUS_CRACKED) break;
2957 if (data.devices_status == STATUS_ABORTED) break;
2958 if (data.devices_status == STATUS_QUIT) break;
2959 }
2960
2961 if (data.opts_type & OPTS_TYPE_HOOK23)
2962 {
2963 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2964
2965 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2966
2967 // do something with data
2968
2969 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2970 }
2971
2972 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2973 }
2974
2975 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2976
2977 if (data.devices_status == STATUS_CRACKED) break;
2978 if (data.devices_status == STATUS_ABORTED) break;
2979 if (data.devices_status == STATUS_QUIT) break;
2980
2981 /**
2982 * result
2983 */
2984
2985 hc_thread_mutex_lock (mux_display);
2986
2987 check_cracked (device_param, salt_pos);
2988
2989 hc_thread_mutex_unlock (mux_display);
2990
2991 /**
2992 * progress
2993 */
2994
2995 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2996
2997 hc_thread_mutex_lock (mux_counter);
2998
2999 data.words_progress_done[salt_pos] += perf_sum_all;
3000
3001 hc_thread_mutex_unlock (mux_counter);
3002
3003 /**
3004 * speed
3005 */
3006
3007 float speed_ms;
3008
3009 hc_timer_get (device_param->timer_speed, speed_ms);
3010
3011 hc_timer_set (&device_param->timer_speed);
3012
3013 hc_thread_mutex_lock (mux_display);
3014
3015 device_param->speed_cnt[speed_pos] = perf_sum_all;
3016
3017 device_param->speed_ms[speed_pos] = speed_ms;
3018
3019 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3020
3021 hc_thread_mutex_unlock (mux_display);
3022
3023 speed_pos++;
3024
3025 if (speed_pos == SPEED_CACHE)
3026 {
3027 speed_pos = 0;
3028 }
3029 }
3030 }
3031
3032 device_param->speed_pos = speed_pos;
3033 }
3034
3035 static void load_segment (wl_data_t *wl_data, FILE *fd)
3036 {
3037 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3038
3039 wl_data->pos = 0;
3040
3041 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3042
3043 wl_data->buf[wl_data->cnt] = 0;
3044
3045 if (wl_data->cnt == 0) return;
3046
3047 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3048
3049 while (!feof (fd))
3050 {
3051 if (wl_data->cnt == wl_data->avail)
3052 {
3053 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3054
3055 wl_data->avail += wl_data->incr;
3056 }
3057
3058 const int c = fgetc (fd);
3059
3060 if (c == EOF) break;
3061
3062 wl_data->buf[wl_data->cnt] = (char) c;
3063
3064 wl_data->cnt++;
3065
3066 if (c == '\n') break;
3067 }
3068
3069 // ensure stream ends with a newline
3070
3071 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3072 {
3073 wl_data->cnt++;
3074
3075 wl_data->buf[wl_data->cnt - 1] = '\n';
3076 }
3077
3078 return;
3079 }
3080
3081 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3082 {
3083 char *ptr = buf;
3084
3085 for (u32 i = 0; i < sz; i++, ptr++)
3086 {
3087 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3088
3089 if (i == 7)
3090 {
3091 *off = i;
3092 *len = i;
3093
3094 return;
3095 }
3096
3097 if (*ptr != '\n') continue;
3098
3099 *off = i + 1;
3100
3101 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3102
3103 *len = i;
3104
3105 return;
3106 }
3107
3108 *off = sz;
3109 *len = sz;
3110 }
3111
3112 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3113 {
3114 char *ptr = buf;
3115
3116 for (u32 i = 0; i < sz; i++, ptr++)
3117 {
3118 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3119
3120 if (*ptr != '\n') continue;
3121
3122 *off = i + 1;
3123
3124 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3125
3126 *len = i;
3127
3128 return;
3129 }
3130
3131 *off = sz;
3132 *len = sz;
3133 }
3134
3135 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3136 {
3137 char *ptr = buf;
3138
3139 for (u32 i = 0; i < sz; i++, ptr++)
3140 {
3141 if (*ptr != '\n') continue;
3142
3143 *off = i + 1;
3144
3145 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3146
3147 *len = i;
3148
3149 return;
3150 }
3151
3152 *off = sz;
3153 *len = sz;
3154 }
3155
3156 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3157 {
3158 while (wl_data->pos < wl_data->cnt)
3159 {
3160 uint off;
3161 uint len;
3162
3163 char *ptr = wl_data->buf + wl_data->pos;
3164
3165 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3166
3167 wl_data->pos += off;
3168
3169 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3170 {
3171 char rule_buf_out[BLOCK_SIZE] = { 0 };
3172
3173 int rule_len_out = -1;
3174
3175 if (len < BLOCK_SIZE)
3176 {
3177 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3178 }
3179
3180 if (rule_len_out < 0)
3181 {
3182 continue;
3183 }
3184
3185 if (rule_len_out > PW_MAX)
3186 {
3187 continue;
3188 }
3189 }
3190 else
3191 {
3192 if (len > PW_MAX)
3193 {
3194 continue;
3195 }
3196 }
3197
3198 *out_buf = ptr;
3199 *out_len = len;
3200
3201 return;
3202 }
3203
3204 if (feof (fd))
3205 {
3206 fprintf (stderr, "bug!!\n");
3207
3208 return;
3209 }
3210
3211 load_segment (wl_data, fd);
3212
3213 get_next_word (wl_data, fd, out_buf, out_len);
3214 }
3215
3216 #ifdef _POSIX
3217 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3218 #endif
3219
3220 #ifdef _WIN
3221 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3222 #endif
3223 {
3224 hc_signal (NULL);
3225
3226 dictstat_t d;
3227
3228 d.cnt = 0;
3229
3230 #ifdef _POSIX
3231 fstat (fileno (fd), &d.stat);
3232 #endif
3233
3234 #ifdef _WIN
3235 _fstat64 (fileno (fd), &d.stat);
3236 #endif
3237
3238 d.stat.st_mode = 0;
3239 d.stat.st_nlink = 0;
3240 d.stat.st_uid = 0;
3241 d.stat.st_gid = 0;
3242 d.stat.st_rdev = 0;
3243 d.stat.st_atime = 0;
3244
3245 #ifdef _POSIX
3246 d.stat.st_blksize = 0;
3247 d.stat.st_blocks = 0;
3248 #endif
3249
3250 if (d.stat.st_size == 0) return 0;
3251
3252 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3253
3254 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3255 {
3256 if (d_cache)
3257 {
3258 u64 cnt = d_cache->cnt;
3259
3260 u64 keyspace = cnt;
3261
3262 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3263 {
3264 keyspace *= data.kernel_rules_cnt;
3265 }
3266 else if (data.attack_kern == ATTACK_KERN_COMBI)
3267 {
3268 keyspace *= data.combs_cnt;
3269 }
3270
3271 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3272 if (data.quiet == 0) log_info ("");
3273
3274 hc_signal (sigHandler_default);
3275
3276 return (keyspace);
3277 }
3278 }
3279
3280 time_t now = 0;
3281 time_t prev = 0;
3282
3283 u64 comp = 0;
3284 u64 cnt = 0;
3285 u64 cnt2 = 0;
3286
3287 while (!feof (fd))
3288 {
3289 load_segment (wl_data, fd);
3290
3291 comp += wl_data->cnt;
3292
3293 u32 i = 0;
3294
3295 while (i < wl_data->cnt)
3296 {
3297 u32 len;
3298 u32 off;
3299
3300 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3301
3302 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3303 {
3304 char rule_buf_out[BLOCK_SIZE] = { 0 };
3305
3306 int rule_len_out = -1;
3307
3308 if (len < BLOCK_SIZE)
3309 {
3310 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3311 }
3312
3313 if (rule_len_out < 0)
3314 {
3315 len = PW_MAX1;
3316 }
3317 else
3318 {
3319 len = rule_len_out;
3320 }
3321 }
3322
3323 if (len < PW_MAX1)
3324 {
3325 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3326 {
3327 cnt += data.kernel_rules_cnt;
3328 }
3329 else if (data.attack_kern == ATTACK_KERN_COMBI)
3330 {
3331 cnt += data.combs_cnt;
3332 }
3333
3334 d.cnt++;
3335 }
3336
3337 i += off;
3338
3339 cnt2++;
3340 }
3341
3342 time (&now);
3343
3344 if ((now - prev) == 0) continue;
3345
3346 float percent = (float) comp / (float) d.stat.st_size;
3347
3348 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3349
3350 time (&prev);
3351 }
3352
3353 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3354 if (data.quiet == 0) log_info ("");
3355
3356 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3357
3358 hc_signal (sigHandler_default);
3359
3360 return (cnt);
3361 }
3362
3363 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3364 {
3365 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3366 }
3367
3368 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3369 {
3370 if (data.devices_status == STATUS_BYPASS) return 0;
3371
3372 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3373
3374 uint cache_cnt = pw_cache->cnt;
3375
3376 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3377
3378 memcpy (pw_hc1, pw_buf, pw_len);
3379
3380 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3381
3382 uint pws_cnt = device_param->pws_cnt;
3383
3384 cache_cnt++;
3385
3386 pw_t *pw = device_param->pws_buf + pws_cnt;
3387
3388 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3389
3390 pw->pw_len = pw_len;
3391
3392 pws_cnt++;
3393
3394 device_param->pws_cnt = pws_cnt;
3395 device_param->pw_cnt = pws_cnt * 1;
3396
3397 cache_cnt = 0;
3398
3399 pw_cache->cnt = cache_cnt;
3400
3401 return pws_cnt;
3402 }
3403
3404 static void *thread_monitor (void *p)
3405 {
3406 uint runtime_check = 0;
3407 uint remove_check = 0;
3408 uint status_check = 0;
3409 uint restore_check = 0;
3410
3411 uint restore_left = data.restore_timer;
3412 uint remove_left = data.remove_timer;
3413 uint status_left = data.status_timer;
3414
3415 #ifdef HAVE_HWMON
3416 uint hwmon_check = 0;
3417
3418 // these variables are mainly used for fan control (AMD only)
3419
3420 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3421
3422 // temperature controller "loopback" values
3423
3424 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3425 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3426
3427 #ifdef HAVE_ADL
3428 int temp_threshold = 1; // degrees celcius
3429
3430 int fan_speed_min = 15; // in percentage
3431 int fan_speed_max = 100;
3432 #endif // HAVE_ADL
3433
3434 time_t last_temp_check_time;
3435 #endif // HAVE_HWMON
3436
3437 uint sleep_time = 1;
3438
3439 if (data.runtime)
3440 {
3441 runtime_check = 1;
3442 }
3443
3444 if (data.restore_timer)
3445 {
3446 restore_check = 1;
3447 }
3448
3449 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3450 {
3451 remove_check = 1;
3452 }
3453
3454 if (data.status == 1)
3455 {
3456 status_check = 1;
3457 }
3458
3459 #ifdef HAVE_HWMON
3460 if (data.gpu_temp_disable == 0)
3461 {
3462 time (&last_temp_check_time);
3463
3464 hwmon_check = 1;
3465 }
3466 #endif
3467
3468 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3469 {
3470 #ifdef HAVE_HWMON
3471 if (hwmon_check == 0)
3472 #endif
3473 return (p);
3474 }
3475
3476 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3477 {
3478 hc_sleep (sleep_time);
3479
3480 if (data.devices_status != STATUS_RUNNING) continue;
3481
3482 #ifdef HAVE_HWMON
3483 if (hwmon_check == 1)
3484 {
3485 hc_thread_mutex_lock (mux_adl);
3486
3487 time_t temp_check_time;
3488
3489 time (&temp_check_time);
3490
3491 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3492
3493 if (Ta == 0) Ta = 1;
3494
3495 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3496 {
3497 hc_device_param_t *device_param = &data.devices_param[device_id];
3498
3499 if (device_param->skipped) continue;
3500
3501 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3502
3503 const int temperature = hm_get_temperature_with_device_id (device_id);
3504
3505 if (temperature > (int) data.gpu_temp_abort)
3506 {
3507 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3508
3509 if (data.devices_status != STATUS_QUIT) myabort ();
3510
3511 break;
3512 }
3513
3514 #ifdef HAVE_ADL
3515 const int gpu_temp_retain = data.gpu_temp_retain;
3516
3517 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3518 {
3519 if (data.hm_device[device_id].fan_supported == 1)
3520 {
3521 int temp_cur = temperature;
3522
3523 int temp_diff_new = gpu_temp_retain - temp_cur;
3524
3525 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3526
3527 // calculate Ta value (time difference in seconds between the last check and this check)
3528
3529 last_temp_check_time = temp_check_time;
3530
3531 float Kp = 1.8;
3532 float Ki = 0.005;
3533 float Kd = 6;
3534
3535 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3536
3537 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3538
3539 if (abs (fan_diff_required) >= temp_threshold)
3540 {
3541 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3542
3543 int fan_speed_level = fan_speed_cur;
3544
3545 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3546
3547 int fan_speed_new = fan_speed_level - fan_diff_required;
3548
3549 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3550 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3551
3552 if (fan_speed_new != fan_speed_cur)
3553 {
3554 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3555 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3556
3557 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3558 {
3559 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3560
3561 fan_speed_chgd[device_id] = 1;
3562 }
3563
3564 temp_diff_old[device_id] = temp_diff_new;
3565 }
3566 }
3567 }
3568 }
3569 #endif // HAVE_ADL
3570 }
3571
3572 hc_thread_mutex_unlock (mux_adl);
3573 }
3574 #endif // HAVE_HWMON
3575
3576 if (restore_check == 1)
3577 {
3578 restore_left--;
3579
3580 if (restore_left == 0)
3581 {
3582 if (data.restore_disable == 0) cycle_restore ();
3583
3584 restore_left = data.restore_timer;
3585 }
3586 }
3587
3588 if ((runtime_check == 1) && (data.runtime_start > 0))
3589 {
3590 time_t runtime_cur;
3591
3592 time (&runtime_cur);
3593
3594 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3595
3596 if (runtime_left <= 0)
3597 {
3598 if (data.benchmark == 0)
3599 {
3600 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3601 }
3602
3603 if (data.devices_status != STATUS_QUIT) myabort ();
3604 }
3605 }
3606
3607 if (remove_check == 1)
3608 {
3609 remove_left--;
3610
3611 if (remove_left == 0)
3612 {
3613 if (data.digests_saved != data.digests_done)
3614 {
3615 data.digests_saved = data.digests_done;
3616
3617 save_hash ();
3618 }
3619
3620 remove_left = data.remove_timer;
3621 }
3622 }
3623
3624 if (status_check == 1)
3625 {
3626 status_left--;
3627
3628 if (status_left == 0)
3629 {
3630 hc_thread_mutex_lock (mux_display);
3631
3632 if (data.quiet == 0) clear_prompt ();
3633
3634 if (data.quiet == 0) log_info ("");
3635
3636 status_display ();
3637
3638 if (data.quiet == 0) log_info ("");
3639
3640 hc_thread_mutex_unlock (mux_display);
3641
3642 status_left = data.status_timer;
3643 }
3644 }
3645 }
3646
3647 #ifdef HAVE_HWMON
3648 myfree (fan_speed_chgd);
3649
3650 myfree (temp_diff_old);
3651 myfree (temp_diff_sum);
3652 #endif
3653
3654 p = NULL;
3655
3656 return (p);
3657 }
3658
3659 static void *thread_outfile_remove (void *p)
3660 {
3661 // some hash-dependent constants
3662 char *outfile_dir = data.outfile_check_directory;
3663 uint dgst_size = data.dgst_size;
3664 uint isSalted = data.isSalted;
3665 uint esalt_size = data.esalt_size;
3666 uint hash_mode = data.hash_mode;
3667
3668 uint outfile_check_timer = data.outfile_check_timer;
3669
3670 char separator = data.separator;
3671
3672 // some hash-dependent functions
3673 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3674 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3675
3676 // buffers
3677 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3678
3679 hash_buf.digest = mymalloc (dgst_size);
3680
3681 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3682
3683 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3684
3685 uint digest_buf[64] = { 0 };
3686
3687 outfile_data_t *out_info = NULL;
3688
3689 char **out_files = NULL;
3690
3691 time_t folder_mtime = 0;
3692
3693 int out_cnt = 0;
3694
3695 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3696
3697 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3698 {
3699 hc_sleep (1);
3700
3701 if (data.devices_status != STATUS_RUNNING) continue;
3702
3703 check_left--;
3704
3705 if (check_left == 0)
3706 {
3707 struct stat outfile_check_stat;
3708
3709 if (stat (outfile_dir, &outfile_check_stat) == 0)
3710 {
3711 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3712
3713 if (is_dir == 1)
3714 {
3715 if (outfile_check_stat.st_mtime > folder_mtime)
3716 {
3717 char **out_files_new = scan_directory (outfile_dir);
3718
3719 int out_cnt_new = count_dictionaries (out_files_new);
3720
3721 outfile_data_t *out_info_new = NULL;
3722
3723 if (out_cnt_new > 0)
3724 {
3725 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3726
3727 for (int i = 0; i < out_cnt_new; i++)
3728 {
3729 out_info_new[i].file_name = out_files_new[i];
3730
3731 // check if there are files that we have seen/checked before (and not changed)
3732
3733 for (int j = 0; j < out_cnt; j++)
3734 {
3735 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3736 {
3737 struct stat outfile_stat;
3738
3739 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3740 {
3741 if (outfile_stat.st_ctime == out_info[j].ctime)
3742 {
3743 out_info_new[i].ctime = out_info[j].ctime;
3744 out_info_new[i].seek = out_info[j].seek;
3745 }
3746 }
3747 }
3748 }
3749 }
3750 }
3751
3752 local_free (out_info);
3753 local_free (out_files);
3754
3755 out_files = out_files_new;
3756 out_cnt = out_cnt_new;
3757 out_info = out_info_new;
3758
3759 folder_mtime = outfile_check_stat.st_mtime;
3760 }
3761
3762 for (int j = 0; j < out_cnt; j++)
3763 {
3764 FILE *fp = fopen (out_info[j].file_name, "rb");
3765
3766 if (fp != NULL)
3767 {
3768 //hc_thread_mutex_lock (mux_display);
3769
3770 #ifdef _POSIX
3771 struct stat outfile_stat;
3772
3773 fstat (fileno (fp), &outfile_stat);
3774 #endif
3775
3776 #ifdef _WIN
3777 struct stat64 outfile_stat;
3778
3779 _fstat64 (fileno (fp), &outfile_stat);
3780 #endif
3781
3782 if (outfile_stat.st_ctime > out_info[j].ctime)
3783 {
3784 out_info[j].ctime = outfile_stat.st_ctime;
3785 out_info[j].seek = 0;
3786 }
3787
3788 fseek (fp, out_info[j].seek, SEEK_SET);
3789
3790 while (!feof (fp))
3791 {
3792 char line_buf[BUFSIZ] = { 0 };
3793
3794 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3795
3796 if (ptr == NULL) break;
3797
3798 int line_len = strlen (line_buf);
3799
3800 if (line_len <= 0) continue;
3801
3802 int iter = MAX_CUT_TRIES;
3803
3804 for (uint i = line_len - 1; i && iter; i--, line_len--)
3805 {
3806 if (line_buf[i] != separator) continue;
3807
3808 int parser_status = PARSER_OK;
3809
3810 if ((hash_mode != 2500) && (hash_mode != 6800))
3811 {
3812 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3813 }
3814
3815 uint found = 0;
3816
3817 if (parser_status == PARSER_OK)
3818 {
3819 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3820 {
3821 if (data.salts_shown[salt_pos] == 1) continue;
3822
3823 salt_t *salt_buf = &data.salts_buf[salt_pos];
3824
3825 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3826 {
3827 uint idx = salt_buf->digests_offset + digest_pos;
3828
3829 if (data.digests_shown[idx] == 1) continue;
3830
3831 uint cracked = 0;
3832
3833 if (hash_mode == 6800)
3834 {
3835 if (i == salt_buf->salt_len)
3836 {
3837 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3838 }
3839 }
3840 else if (hash_mode == 2500)
3841 {
3842 // BSSID : MAC1 : MAC2 (:plain)
3843 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3844 {
3845 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3846
3847 if (!cracked) continue;
3848
3849 // now compare MAC1 and MAC2 too, since we have this additional info
3850 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3851 char *mac2_pos = mac1_pos + 12 + 1;
3852
3853 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3854 wpa_t *wpa = &wpas[salt_pos];
3855
3856 uint pke[25] = { 0 };
3857
3858 char *pke_ptr = (char *) pke;
3859
3860 for (uint i = 0; i < 25; i++)
3861 {
3862 pke[i] = byte_swap_32 (wpa->pke[i]);
3863 }
3864
3865 u8 mac1[6] = { 0 };
3866 u8 mac2[6] = { 0 };
3867
3868 memcpy (mac1, pke_ptr + 23, 6);
3869 memcpy (mac2, pke_ptr + 29, 6);
3870
3871 // compare hex string(s) vs binary MAC address(es)
3872
3873 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3874 {
3875 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3876 {
3877 cracked = 0;
3878 break;
3879 }
3880 }
3881
3882 // early skip ;)
3883 if (!cracked) continue;
3884
3885 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3886 {
3887 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3888 {
3889 cracked = 0;
3890 break;
3891 }
3892 }
3893 }
3894 }
3895 else
3896 {
3897 char *digests_buf_ptr = (char *) data.digests_buf;
3898
3899 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3900
3901 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3902 }
3903
3904 if (cracked == 1)
3905 {
3906 found = 1;
3907
3908 data.digests_shown[idx] = 1;
3909
3910 data.digests_done++;
3911
3912 salt_buf->digests_done++;
3913
3914 if (salt_buf->digests_done == salt_buf->digests_cnt)
3915 {
3916 data.salts_shown[salt_pos] = 1;
3917
3918 data.salts_done++;
3919
3920 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3921 }
3922 }
3923 }
3924
3925 if (data.devices_status == STATUS_CRACKED) break;
3926 }
3927 }
3928
3929 if (found) break;
3930
3931 if (data.devices_status == STATUS_CRACKED) break;
3932
3933 iter--;
3934 }
3935
3936 if (data.devices_status == STATUS_CRACKED) break;
3937 }
3938
3939 out_info[j].seek = ftell (fp);
3940
3941 //hc_thread_mutex_unlock (mux_display);
3942
3943 fclose (fp);
3944 }
3945 }
3946 }
3947 }
3948
3949 check_left = outfile_check_timer;
3950 }
3951 }
3952
3953 if (esalt_size) local_free (hash_buf.esalt);
3954
3955 if (isSalted) local_free (hash_buf.salt);
3956
3957 local_free (hash_buf.digest);
3958
3959 local_free (out_info);
3960
3961 local_free (out_files);
3962
3963 p = NULL;
3964
3965 return (p);
3966 }
3967
3968 static uint get_work (hc_device_param_t *device_param, const u64 max)
3969 {
3970 hc_thread_mutex_lock (mux_dispatcher);
3971
3972 const u64 words_cur = data.words_cur;
3973 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3974
3975 device_param->words_off = words_cur;
3976
3977 const u64 words_left = words_base - words_cur;
3978
3979 if (data.kernel_blocks_all > words_left)
3980 {
3981 if (data.kernel_blocks_div == 0)
3982 {
3983 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3984 }
3985 }
3986
3987 if (data.kernel_blocks_div)
3988 {
3989 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3990 {
3991 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3992 const u32 kernel_power_new = kernel_blocks_new;
3993
3994 if (kernel_blocks_new < device_param->kernel_blocks)
3995 {
3996 device_param->kernel_blocks = kernel_blocks_new;
3997 device_param->kernel_power = kernel_power_new;
3998 }
3999 }
4000 }
4001
4002 const uint kernel_blocks = device_param->kernel_blocks;
4003
4004 uint work = MIN (words_left, kernel_blocks);
4005
4006 work = MIN (work, max);
4007
4008 data.words_cur += work;
4009
4010 hc_thread_mutex_unlock (mux_dispatcher);
4011
4012 return work;
4013 }
4014
4015 static void *thread_calc_stdin (void *p)
4016 {
4017 hc_device_param_t *device_param = (hc_device_param_t *) p;
4018
4019 if (device_param->skipped) return NULL;
4020
4021 const uint attack_kern = data.attack_kern;
4022
4023 const uint kernel_blocks = device_param->kernel_blocks;
4024
4025 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4026 {
4027 hc_thread_mutex_lock (mux_dispatcher);
4028
4029 if (feof (stdin) != 0)
4030 {
4031 hc_thread_mutex_unlock (mux_dispatcher);
4032
4033 break;
4034 }
4035
4036 uint words_cur = 0;
4037
4038 while (words_cur < kernel_blocks)
4039 {
4040 char buf[BUFSIZ] = { 0 };
4041
4042 char *line_buf = fgets (buf, sizeof (buf), stdin);
4043
4044 if (line_buf == NULL) break;
4045
4046 uint line_len = in_superchop (line_buf);
4047
4048 line_len = convert_from_hex (line_buf, line_len);
4049
4050 // post-process rule engine
4051
4052 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4053 {
4054 char rule_buf_out[BLOCK_SIZE] = { 0 };
4055
4056 int rule_len_out = -1;
4057
4058 if (line_len < BLOCK_SIZE)
4059 {
4060 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4061 }
4062
4063 if (rule_len_out < 0) continue;
4064
4065 line_buf = rule_buf_out;
4066 line_len = rule_len_out;
4067 }
4068
4069 if (line_len > PW_MAX)
4070 {
4071 continue;
4072 }
4073
4074 if (attack_kern == ATTACK_KERN_STRAIGHT)
4075 {
4076 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4077 {
4078 hc_thread_mutex_lock (mux_counter);
4079
4080 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4081 {
4082 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4083 }
4084
4085 hc_thread_mutex_unlock (mux_counter);
4086
4087 continue;
4088 }
4089 }
4090 else if (attack_kern == ATTACK_KERN_COMBI)
4091 {
4092 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4093 // since we still need to combine the plains
4094
4095 if (line_len > data.pw_max)
4096 {
4097 hc_thread_mutex_lock (mux_counter);
4098
4099 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4100 {
4101 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4102 }
4103
4104 hc_thread_mutex_unlock (mux_counter);
4105
4106 continue;
4107 }
4108 }
4109
4110 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4111
4112 words_cur++;
4113
4114 if (data.devices_status == STATUS_CRACKED) break;
4115 if (data.devices_status == STATUS_ABORTED) break;
4116 if (data.devices_status == STATUS_QUIT) break;
4117 if (data.devices_status == STATUS_BYPASS) break;
4118 }
4119
4120 hc_thread_mutex_unlock (mux_dispatcher);
4121
4122 if (data.devices_status == STATUS_CRACKED) break;
4123 if (data.devices_status == STATUS_ABORTED) break;
4124 if (data.devices_status == STATUS_QUIT) break;
4125 if (data.devices_status == STATUS_BYPASS) break;
4126
4127 // we need 2 flushing because we have two independant caches and it can occur
4128 // that one buffer is already at threshold plus for that length also exists
4129 // more data in the 2nd buffer so it would overflow
4130
4131 // flush session 1
4132
4133 {
4134 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4135 {
4136 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4137
4138 const uint pw_cache_cnt = pw_cache->cnt;
4139
4140 if (pw_cache_cnt == 0) continue;
4141
4142 pw_cache->cnt = 0;
4143
4144 uint pws_cnt = device_param->pws_cnt;
4145
4146 pw_t *pw = device_param->pws_buf + pws_cnt;
4147
4148 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4149
4150 pw->pw_len = pw_len;
4151
4152 uint pw_cnt = device_param->pw_cnt;
4153
4154 pw_cnt += pw_cache_cnt;
4155
4156 device_param->pw_cnt = pw_cnt;
4157
4158 pws_cnt++;
4159
4160 device_param->pws_cnt = pws_cnt;
4161
4162 if (pws_cnt == device_param->kernel_power_user) break;
4163 }
4164
4165 const uint pw_cnt = device_param->pw_cnt;
4166 const uint pws_cnt = device_param->pws_cnt;
4167
4168 if (pws_cnt)
4169 {
4170 run_copy (device_param, pws_cnt);
4171
4172 run_cracker (device_param, pw_cnt, pws_cnt);
4173
4174 device_param->pw_cnt = 0;
4175 device_param->pws_cnt = 0;
4176 }
4177 }
4178
4179 // flush session 2
4180
4181 {
4182 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4183 {
4184 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4185
4186 const uint pw_cache_cnt = pw_cache->cnt;
4187
4188 if (pw_cache_cnt == 0) continue;
4189
4190 pw_cache->cnt = 0;
4191
4192 uint pws_cnt = device_param->pws_cnt;
4193
4194 pw_t *pw = device_param->pws_buf + pws_cnt;
4195
4196 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4197
4198 pw->pw_len = pw_len;
4199
4200 uint pw_cnt = device_param->pw_cnt;
4201
4202 pw_cnt += pw_cache_cnt;
4203
4204 device_param->pw_cnt = pw_cnt;
4205
4206 pws_cnt++;
4207
4208 device_param->pws_cnt = pws_cnt;
4209 }
4210
4211 const uint pw_cnt = device_param->pw_cnt;
4212 const uint pws_cnt = device_param->pws_cnt;
4213
4214 if (pws_cnt)
4215 {
4216 run_copy (device_param, pws_cnt);
4217
4218 run_cracker (device_param, pw_cnt, pws_cnt);
4219
4220 device_param->pw_cnt = 0;
4221 device_param->pws_cnt = 0;
4222 }
4223 }
4224 }
4225
4226 return NULL;
4227 }
4228
4229 static void *thread_calc (void *p)
4230 {
4231 hc_device_param_t *device_param = (hc_device_param_t *) p;
4232
4233 if (device_param->skipped) return NULL;
4234
4235 const uint attack_mode = data.attack_mode;
4236 const uint attack_kern = data.attack_kern;
4237
4238 if (attack_mode == ATTACK_MODE_BF)
4239 {
4240 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4241 {
4242 const uint work = get_work (device_param, -1);
4243
4244 if (work == 0) break;
4245
4246 const u64 words_off = device_param->words_off;
4247 const u64 words_fin = words_off + work;
4248
4249 const uint pw_cnt = work;
4250 const uint pws_cnt = work;
4251
4252 device_param->pw_cnt = pw_cnt;
4253 device_param->pws_cnt = pws_cnt;
4254
4255 if (pws_cnt)
4256 {
4257 run_copy (device_param, pws_cnt);
4258
4259 run_cracker (device_param, pw_cnt, pws_cnt);
4260
4261 device_param->pw_cnt = 0;
4262 device_param->pws_cnt = 0;
4263 }
4264
4265 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268 if (data.devices_status == STATUS_ABORTED) break;
4269 if (data.devices_status == STATUS_QUIT) break;
4270 if (data.devices_status == STATUS_BYPASS) break;
4271
4272 device_param->words_done = words_fin;
4273 }
4274 }
4275 else
4276 {
4277 const uint segment_size = data.segment_size;
4278
4279 char *dictfile = data.dictfile;
4280
4281 if (attack_mode == ATTACK_MODE_COMBI)
4282 {
4283 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4284 {
4285 dictfile = data.dictfile2;
4286 }
4287 }
4288
4289 FILE *fd = fopen (dictfile, "rb");
4290
4291 if (fd == NULL)
4292 {
4293 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4294
4295 return NULL;
4296 }
4297
4298 if (attack_mode == ATTACK_MODE_COMBI)
4299 {
4300 const uint combs_mode = data.combs_mode;
4301
4302 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4303 {
4304 const char *dictfilec = data.dictfile2;
4305
4306 FILE *combs_fp = fopen (dictfilec, "rb");
4307
4308 if (combs_fp == NULL)
4309 {
4310 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4311
4312 fclose (fd);
4313
4314 return NULL;
4315 }
4316
4317 device_param->combs_fp = combs_fp;
4318 }
4319 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4320 {
4321 const char *dictfilec = data.dictfile;
4322
4323 FILE *combs_fp = fopen (dictfilec, "rb");
4324
4325 if (combs_fp == NULL)
4326 {
4327 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4328
4329 fclose (fd);
4330
4331 return NULL;
4332 }
4333
4334 device_param->combs_fp = combs_fp;
4335 }
4336 }
4337
4338 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4339
4340 wl_data->buf = (char *) mymalloc (segment_size);
4341 wl_data->avail = segment_size;
4342 wl_data->incr = segment_size;
4343 wl_data->cnt = 0;
4344 wl_data->pos = 0;
4345
4346 u64 words_cur = 0;
4347
4348 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4349 {
4350 u64 words_off = 0;
4351 u64 words_fin = 0;
4352
4353 u64 max = -1;
4354
4355 while (max)
4356 {
4357 const uint work = get_work (device_param, max);
4358
4359 if (work == 0) break;
4360
4361 words_off = device_param->words_off;
4362 words_fin = words_off + work;
4363
4364 char *line_buf;
4365 uint line_len;
4366
4367 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4368
4369 max = 0;
4370
4371 for ( ; words_cur < words_fin; words_cur++)
4372 {
4373 get_next_word (wl_data, fd, &line_buf, &line_len);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (attack_kern == ATTACK_KERN_STRAIGHT)
4397 {
4398 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4399 {
4400 max++;
4401
4402 hc_thread_mutex_lock (mux_counter);
4403
4404 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4405 {
4406 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4407 }
4408
4409 hc_thread_mutex_unlock (mux_counter);
4410
4411 continue;
4412 }
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4417 // since we still need to combine the plains
4418
4419 if (line_len > data.pw_max)
4420 {
4421 max++;
4422
4423 hc_thread_mutex_lock (mux_counter);
4424
4425 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4426 {
4427 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4428 }
4429
4430 hc_thread_mutex_unlock (mux_counter);
4431
4432 continue;
4433 }
4434 }
4435
4436 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4437
4438 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4439
4440 if (data.devices_status == STATUS_CRACKED) break;
4441 if (data.devices_status == STATUS_ABORTED) break;
4442 if (data.devices_status == STATUS_QUIT) break;
4443 if (data.devices_status == STATUS_BYPASS) break;
4444 }
4445
4446 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4447
4448 if (data.devices_status == STATUS_CRACKED) break;
4449 if (data.devices_status == STATUS_ABORTED) break;
4450 if (data.devices_status == STATUS_QUIT) break;
4451 if (data.devices_status == STATUS_BYPASS) break;
4452 }
4453
4454 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4455
4456 if (data.devices_status == STATUS_CRACKED) break;
4457 if (data.devices_status == STATUS_ABORTED) break;
4458 if (data.devices_status == STATUS_QUIT) break;
4459 if (data.devices_status == STATUS_BYPASS) break;
4460
4461 // we need 2 flushing because we have two independant caches and it can occur
4462 // that one buffer is already at threshold plus for that length also exists
4463 // more data in the 2nd buffer so it would overflow
4464
4465 //
4466 // flush session 1
4467 //
4468
4469 {
4470 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4471 {
4472 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4473
4474 const uint pw_cache_cnt = pw_cache->cnt;
4475
4476 if (pw_cache_cnt == 0) continue;
4477
4478 pw_cache->cnt = 0;
4479
4480 uint pws_cnt = device_param->pws_cnt;
4481
4482 pw_t *pw = device_param->pws_buf + pws_cnt;
4483
4484 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4485
4486 pw->pw_len = pw_len;
4487
4488 uint pw_cnt = device_param->pw_cnt;
4489
4490 pw_cnt += pw_cache_cnt;
4491
4492 device_param->pw_cnt = pw_cnt;
4493
4494 pws_cnt++;
4495
4496 device_param->pws_cnt = pws_cnt;
4497
4498 if (pws_cnt == device_param->kernel_power_user) break;
4499 }
4500
4501 const uint pw_cnt = device_param->pw_cnt;
4502 const uint pws_cnt = device_param->pws_cnt;
4503
4504 if (pws_cnt)
4505 {
4506 run_copy (device_param, pws_cnt);
4507
4508 run_cracker (device_param, pw_cnt, pws_cnt);
4509
4510 device_param->pw_cnt = 0;
4511 device_param->pws_cnt = 0;
4512 }
4513
4514 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4515
4516 if (data.devices_status == STATUS_CRACKED) break;
4517 if (data.devices_status == STATUS_ABORTED) break;
4518 if (data.devices_status == STATUS_QUIT) break;
4519 if (data.devices_status == STATUS_BYPASS) break;
4520 }
4521
4522 //
4523 // flush session 2
4524 //
4525
4526 {
4527 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4528 {
4529 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4530
4531 const uint pw_cache_cnt = pw_cache->cnt;
4532
4533 if (pw_cache_cnt == 0) continue;
4534
4535 pw_cache->cnt = 0;
4536
4537 uint pws_cnt = device_param->pws_cnt;
4538
4539 pw_t *pw = device_param->pws_buf + pws_cnt;
4540
4541 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4542
4543 pw->pw_len = pw_len;
4544
4545 uint pw_cnt = device_param->pw_cnt;
4546
4547 pw_cnt += pw_cache_cnt;
4548
4549 device_param->pw_cnt = pw_cnt;
4550
4551 pws_cnt++;
4552
4553 device_param->pws_cnt = pws_cnt;
4554 }
4555
4556 const uint pw_cnt = device_param->pw_cnt;
4557 const uint pws_cnt = device_param->pws_cnt;
4558
4559 if (pws_cnt)
4560 {
4561 run_copy (device_param, pws_cnt);
4562
4563 run_cracker (device_param, pw_cnt, pws_cnt);
4564
4565 device_param->pw_cnt = 0;
4566 device_param->pws_cnt = 0;
4567 }
4568
4569 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4570
4571 if (data.devices_status == STATUS_CRACKED) break;
4572 if (data.devices_status == STATUS_ABORTED) break;
4573 if (data.devices_status == STATUS_QUIT) break;
4574 if (data.devices_status == STATUS_BYPASS) break;
4575 }
4576
4577 if (words_fin == 0) break;
4578
4579 device_param->words_done = words_fin;
4580 }
4581
4582 if (attack_mode == ATTACK_MODE_COMBI)
4583 {
4584 fclose (device_param->combs_fp);
4585 }
4586
4587 free (wl_data->buf);
4588 free (wl_data);
4589
4590 fclose (fd);
4591 }
4592
4593 return NULL;
4594 }
4595
4596 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4597 {
4598 salt_t *salt_buf = &data.salts_buf[salt_pos];
4599
4600 device_param->kernel_params_buf32[24] = salt_pos;
4601 device_param->kernel_params_buf32[27] = 1;
4602 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4603 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4604 device_param->kernel_params_buf32[30] = 0;
4605 device_param->kernel_params_buf32[31] = 1;
4606
4607 char *dictfile_old = data.dictfile;
4608
4609 const char *weak_hash_check = "weak-hash-check";
4610
4611 data.dictfile = (char *) weak_hash_check;
4612
4613 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4614
4615 data.kernel_rules_buf[0].cmds[0] = 0;
4616
4617 /**
4618 * run the kernel
4619 */
4620
4621 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4622 {
4623 run_kernel (KERN_RUN_1, device_param, 1);
4624 }
4625 else
4626 {
4627 run_kernel (KERN_RUN_1, device_param, 1);
4628
4629 const uint iter = salt_buf->salt_iter;
4630
4631 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4632 {
4633 uint loop_left = iter - loop_pos;
4634
4635 loop_left = MIN (loop_left, kernel_loops);
4636
4637 device_param->kernel_params_buf32[25] = loop_pos;
4638 device_param->kernel_params_buf32[26] = loop_left;
4639
4640 run_kernel (KERN_RUN_2, device_param, 1);
4641 }
4642
4643 run_kernel (KERN_RUN_3, device_param, 1);
4644 }
4645
4646 /**
4647 * result
4648 */
4649
4650 check_cracked (device_param, salt_pos);
4651
4652 /**
4653 * cleanup
4654 */
4655
4656 device_param->kernel_params_buf32[24] = 0;
4657 device_param->kernel_params_buf32[25] = 0;
4658 device_param->kernel_params_buf32[26] = 0;
4659 device_param->kernel_params_buf32[27] = 0;
4660 device_param->kernel_params_buf32[28] = 0;
4661 device_param->kernel_params_buf32[29] = 0;
4662 device_param->kernel_params_buf32[30] = 0;
4663 device_param->kernel_params_buf32[31] = 0;
4664
4665 data.dictfile = dictfile_old;
4666
4667 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4668 }
4669
4670 // hlfmt hashcat
4671
4672 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4673 {
4674 if (data.username == 0)
4675 {
4676 *hashbuf_pos = line_buf;
4677 *hashbuf_len = line_len;
4678 }
4679 else
4680 {
4681 char *pos = line_buf;
4682 int len = line_len;
4683
4684 for (int i = 0; i < line_len; i++, pos++, len--)
4685 {
4686 if (line_buf[i] == data.separator)
4687 {
4688 pos++;
4689
4690 len--;
4691
4692 break;
4693 }
4694 }
4695
4696 *hashbuf_pos = pos;
4697 *hashbuf_len = len;
4698 }
4699 }
4700
4701 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4702 {
4703 char *pos = NULL;
4704 int len = 0;
4705
4706 int sep_cnt = 0;
4707
4708 for (int i = 0; i < line_len; i++)
4709 {
4710 if (line_buf[i] == data.separator)
4711 {
4712 sep_cnt++;
4713
4714 continue;
4715 }
4716
4717 if (sep_cnt == 0)
4718 {
4719 if (pos == NULL) pos = line_buf + i;
4720
4721 len++;
4722 }
4723 }
4724
4725 *userbuf_pos = pos;
4726 *userbuf_len = len;
4727 }
4728
4729 // hlfmt pwdump
4730
4731 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4732 {
4733 int sep_cnt = 0;
4734
4735 int sep2_len = 0;
4736 int sep3_len = 0;
4737
4738 for (int i = 0; i < line_len; i++)
4739 {
4740 if (line_buf[i] == ':')
4741 {
4742 sep_cnt++;
4743
4744 continue;
4745 }
4746
4747 if (sep_cnt == 2) sep2_len++;
4748 if (sep_cnt == 3) sep3_len++;
4749 }
4750
4751 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4752
4753 return 0;
4754 }
4755
4756 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4757 {
4758 char *pos = NULL;
4759 int len = 0;
4760
4761 int sep_cnt = 0;
4762
4763 for (int i = 0; i < line_len; i++)
4764 {
4765 if (line_buf[i] == ':')
4766 {
4767 sep_cnt++;
4768
4769 continue;
4770 }
4771
4772 if (data.hash_mode == 1000)
4773 {
4774 if (sep_cnt == 3)
4775 {
4776 if (pos == NULL) pos = line_buf + i;
4777
4778 len++;
4779 }
4780 }
4781 else if (data.hash_mode == 3000)
4782 {
4783 if (sep_cnt == 2)
4784 {
4785 if (pos == NULL) pos = line_buf + i;
4786
4787 len++;
4788 }
4789 }
4790 }
4791
4792 *hashbuf_pos = pos;
4793 *hashbuf_len = len;
4794 }
4795
4796 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4797 {
4798 char *pos = NULL;
4799 int len = 0;
4800
4801 int sep_cnt = 0;
4802
4803 for (int i = 0; i < line_len; i++)
4804 {
4805 if (line_buf[i] == ':')
4806 {
4807 sep_cnt++;
4808
4809 continue;
4810 }
4811
4812 if (sep_cnt == 0)
4813 {
4814 if (pos == NULL) pos = line_buf + i;
4815
4816 len++;
4817 }
4818 }
4819
4820 *userbuf_pos = pos;
4821 *userbuf_len = len;
4822 }
4823
4824 // hlfmt passwd
4825
4826 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4827 {
4828 int sep_cnt = 0;
4829
4830 char sep5_first = 0;
4831 char sep6_first = 0;
4832
4833 for (int i = 0; i < line_len; i++)
4834 {
4835 if (line_buf[i] == ':')
4836 {
4837 sep_cnt++;
4838
4839 continue;
4840 }
4841
4842 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4843 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4844 }
4845
4846 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4847
4848 return 0;
4849 }
4850
4851 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4852 {
4853 char *pos = NULL;
4854 int len = 0;
4855
4856 int sep_cnt = 0;
4857
4858 for (int i = 0; i < line_len; i++)
4859 {
4860 if (line_buf[i] == ':')
4861 {
4862 sep_cnt++;
4863
4864 continue;
4865 }
4866
4867 if (sep_cnt == 1)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874
4875 *hashbuf_pos = pos;
4876 *hashbuf_len = len;
4877 }
4878
4879 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4880 {
4881 char *pos = NULL;
4882 int len = 0;
4883
4884 int sep_cnt = 0;
4885
4886 for (int i = 0; i < line_len; i++)
4887 {
4888 if (line_buf[i] == ':')
4889 {
4890 sep_cnt++;
4891
4892 continue;
4893 }
4894
4895 if (sep_cnt == 0)
4896 {
4897 if (pos == NULL) pos = line_buf + i;
4898
4899 len++;
4900 }
4901 }
4902
4903 *userbuf_pos = pos;
4904 *userbuf_len = len;
4905 }
4906
4907 // hlfmt shadow
4908
4909 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4910 {
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':') sep_cnt++;
4916 }
4917
4918 if (sep_cnt == 8) return 1;
4919
4920 return 0;
4921 }
4922
4923 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4924 {
4925 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4926 }
4927
4928 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4929 {
4930 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4931 }
4932
4933 // hlfmt main
4934
4935 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4936 {
4937 switch (hashfile_format)
4938 {
4939 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4940 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4941 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4942 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4943 }
4944 }
4945
4946 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4947 {
4948 switch (hashfile_format)
4949 {
4950 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4951 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4952 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4953 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4954 }
4955 }
4956
4957 static uint hlfmt_detect (FILE *fp, uint max_check)
4958 {
4959 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4960
4961 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4962 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4963
4964 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4965
4966 uint num_check = 0;
4967
4968 while (!feof (fp))
4969 {
4970 char line_buf[BUFSIZ] = { 0 };
4971
4972 int line_len = fgetl (fp, line_buf);
4973
4974 if (line_len == 0) continue;
4975
4976 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4977 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4978 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4979
4980 if (num_check == max_check) break;
4981
4982 num_check++;
4983 }
4984
4985 uint hashlist_format = HLFMT_HASHCAT;
4986
4987 for (int i = 1; i < HLFMTS_CNT; i++)
4988 {
4989 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4990
4991 hashlist_format = i;
4992 }
4993
4994 free (formats_cnt);
4995
4996 return hashlist_format;
4997 }
4998
4999 /**
5000 * some further helper function
5001 */
5002
5003 // wrapper around mymalloc for ADL
5004
5005 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5006 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5007 {
5008 return mymalloc (iSize);
5009 }
5010 #endif
5011
5012 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5013 {
5014 u64 collisions = 0;
5015
5016 const uint dgst_pos0 = data.dgst_pos0;
5017 const uint dgst_pos1 = data.dgst_pos1;
5018 const uint dgst_pos2 = data.dgst_pos2;
5019 const uint dgst_pos3 = data.dgst_pos3;
5020
5021 memset (bitmap_a, 0, bitmap_size);
5022 memset (bitmap_b, 0, bitmap_size);
5023 memset (bitmap_c, 0, bitmap_size);
5024 memset (bitmap_d, 0, bitmap_size);
5025
5026 for (uint i = 0; i < digests_cnt; i++)
5027 {
5028 uint *digest_ptr = (uint *) digests_buf_ptr;
5029
5030 digests_buf_ptr += dgst_size;
5031
5032 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5033 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5034 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5035 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5036
5037 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5038 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5039 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5040 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5041
5042 if (bitmap_a[idx0] & val0) collisions++;
5043 if (bitmap_b[idx1] & val1) collisions++;
5044 if (bitmap_c[idx2] & val2) collisions++;
5045 if (bitmap_d[idx3] & val3) collisions++;
5046
5047 bitmap_a[idx0] |= val0;
5048 bitmap_b[idx1] |= val1;
5049 bitmap_c[idx2] |= val2;
5050 bitmap_d[idx3] |= val3;
5051
5052 if (collisions >= collisions_max) return 0x7fffffff;
5053 }
5054
5055 return collisions;
5056 }
5057
5058 /**
5059 * main
5060 */
5061
5062 int main (int argc, char **argv)
5063 {
5064 /**
5065 * To help users a bit
5066 */
5067
5068 char *compute = getenv ("COMPUTE");
5069
5070 if (compute)
5071 {
5072 char display[100] = { 0 };
5073
5074 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5075
5076 putenv (display);
5077 }
5078 else
5079 {
5080 if (getenv ("DISPLAY") == NULL)
5081 putenv ((char *) "DISPLAY=:0");
5082 }
5083
5084 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5085 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5086
5087 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5088 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5089
5090 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5091 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5092
5093 /**
5094 * Real init
5095 */
5096
5097 memset (&data, 0, sizeof (hc_global_data_t));
5098
5099 time_t proc_start;
5100
5101 time (&proc_start);
5102
5103 data.proc_start = proc_start;
5104
5105 int myargc = argc;
5106 char **myargv = argv;
5107
5108 hc_thread_mutex_init (mux_dispatcher);
5109 hc_thread_mutex_init (mux_counter);
5110 hc_thread_mutex_init (mux_display);
5111 hc_thread_mutex_init (mux_adl);
5112
5113 /**
5114 * commandline parameters
5115 */
5116
5117 uint usage = USAGE;
5118 uint version = VERSION;
5119 uint quiet = QUIET;
5120 uint benchmark = BENCHMARK;
5121 uint benchmark_mode = BENCHMARK_MODE;
5122 uint show = SHOW;
5123 uint left = LEFT;
5124 uint username = USERNAME;
5125 uint remove = REMOVE;
5126 uint remove_timer = REMOVE_TIMER;
5127 u64 skip = SKIP;
5128 u64 limit = LIMIT;
5129 uint keyspace = KEYSPACE;
5130 uint potfile_disable = POTFILE_DISABLE;
5131 uint debug_mode = DEBUG_MODE;
5132 char *debug_file = NULL;
5133 char *induction_dir = NULL;
5134 char *outfile_check_dir = NULL;
5135 uint force = FORCE;
5136 uint runtime = RUNTIME;
5137 uint hash_mode = HASH_MODE;
5138 uint attack_mode = ATTACK_MODE;
5139 uint markov_disable = MARKOV_DISABLE;
5140 uint markov_classic = MARKOV_CLASSIC;
5141 uint markov_threshold = MARKOV_THRESHOLD;
5142 char *markov_hcstat = NULL;
5143 char *outfile = NULL;
5144 uint outfile_format = OUTFILE_FORMAT;
5145 uint outfile_autohex = OUTFILE_AUTOHEX;
5146 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5147 uint restore = RESTORE;
5148 uint restore_timer = RESTORE_TIMER;
5149 uint restore_disable = RESTORE_DISABLE;
5150 uint status = STATUS;
5151 uint status_timer = STATUS_TIMER;
5152 uint status_automat = STATUS_AUTOMAT;
5153 uint loopback = LOOPBACK;
5154 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5155 char *session = NULL;
5156 uint hex_charset = HEX_CHARSET;
5157 uint hex_salt = HEX_SALT;
5158 uint hex_wordlist = HEX_WORDLIST;
5159 uint rp_gen = RP_GEN;
5160 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5161 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5162 uint rp_gen_seed = RP_GEN_SEED;
5163 char *rule_buf_l = (char *) RULE_BUF_L;
5164 char *rule_buf_r = (char *) RULE_BUF_R;
5165 uint increment = INCREMENT;
5166 uint increment_min = INCREMENT_MIN;
5167 uint increment_max = INCREMENT_MAX;
5168 #ifndef OSX
5169 char *cpu_affinity = NULL;
5170 #endif
5171 OCL_PTR *ocl = NULL;
5172 char *opencl_devices = NULL;
5173 char *opencl_platforms = NULL;
5174 char *opencl_device_types = NULL;
5175 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5176 char *truecrypt_keyfiles = NULL;
5177 uint workload_profile = WORKLOAD_PROFILE;
5178 uint kernel_accel = KERNEL_ACCEL;
5179 uint kernel_loops = KERNEL_LOOPS;
5180 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5181 #ifdef HAVE_HWMON
5182 uint gpu_temp_abort = GPU_TEMP_ABORT;
5183 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5184 #ifdef HAVE_ADL
5185 uint powertune_enable = POWERTUNE_ENABLE;
5186 #endif
5187 #endif
5188 uint logfile_disable = LOGFILE_DISABLE;
5189 uint segment_size = SEGMENT_SIZE;
5190 uint scrypt_tmto = SCRYPT_TMTO;
5191 char separator = SEPARATOR;
5192 uint bitmap_min = BITMAP_MIN;
5193 uint bitmap_max = BITMAP_MAX;
5194 char *custom_charset_1 = NULL;
5195 char *custom_charset_2 = NULL;
5196 char *custom_charset_3 = NULL;
5197 char *custom_charset_4 = NULL;
5198
5199 #define IDX_HELP 'h'
5200 #define IDX_VERSION 'V'
5201 #define IDX_VERSION_LOWER 'v'
5202 #define IDX_QUIET 0xff02
5203 #define IDX_SHOW 0xff03
5204 #define IDX_LEFT 0xff04
5205 #define IDX_REMOVE 0xff05
5206 #define IDX_REMOVE_TIMER 0xff37
5207 #define IDX_SKIP 's'
5208 #define IDX_LIMIT 'l'
5209 #define IDX_KEYSPACE 0xff35
5210 #define IDX_POTFILE_DISABLE 0xff06
5211 #define IDX_DEBUG_MODE 0xff43
5212 #define IDX_DEBUG_FILE 0xff44
5213 #define IDX_INDUCTION_DIR 0xff46
5214 #define IDX_OUTFILE_CHECK_DIR 0xff47
5215 #define IDX_USERNAME 0xff07
5216 #define IDX_FORCE 0xff08
5217 #define IDX_RUNTIME 0xff09
5218 #define IDX_BENCHMARK 'b'
5219 #define IDX_BENCHMARK_MODE 0xff32
5220 #define IDX_HASH_MODE 'm'
5221 #define IDX_ATTACK_MODE 'a'
5222 #define IDX_RP_FILE 'r'
5223 #define IDX_RP_GEN 'g'
5224 #define IDX_RP_GEN_FUNC_MIN 0xff10
5225 #define IDX_RP_GEN_FUNC_MAX 0xff11
5226 #define IDX_RP_GEN_SEED 0xff34
5227 #define IDX_RULE_BUF_L 'j'
5228 #define IDX_RULE_BUF_R 'k'
5229 #define IDX_INCREMENT 'i'
5230 #define IDX_INCREMENT_MIN 0xff12
5231 #define IDX_INCREMENT_MAX 0xff13
5232 #define IDX_OUTFILE 'o'
5233 #define IDX_OUTFILE_FORMAT 0xff14
5234 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5235 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5236 #define IDX_RESTORE 0xff15
5237 #define IDX_RESTORE_DISABLE 0xff27
5238 #define IDX_STATUS 0xff17
5239 #define IDX_STATUS_TIMER 0xff18
5240 #define IDX_STATUS_AUTOMAT 0xff50
5241 #define IDX_LOOPBACK 0xff38
5242 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5243 #define IDX_SESSION 0xff19
5244 #define IDX_HEX_CHARSET 0xff20
5245 #define IDX_HEX_SALT 0xff21
5246 #define IDX_HEX_WORDLIST 0xff40
5247 #define IDX_MARKOV_DISABLE 0xff22
5248 #define IDX_MARKOV_CLASSIC 0xff23
5249 #define IDX_MARKOV_THRESHOLD 't'
5250 #define IDX_MARKOV_HCSTAT 0xff24
5251 #define IDX_CPU_AFFINITY 0xff25
5252 #define IDX_OPENCL_DEVICES 'd'
5253 #define IDX_OPENCL_PLATFORMS 0xff72
5254 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5255 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5256 #define IDX_WORKLOAD_PROFILE 'w'
5257 #define IDX_KERNEL_ACCEL 'n'
5258 #define IDX_KERNEL_LOOPS 'u'
5259 #define IDX_GPU_TEMP_DISABLE 0xff29
5260 #define IDX_GPU_TEMP_ABORT 0xff30
5261 #define IDX_GPU_TEMP_RETAIN 0xff31
5262 #define IDX_POWERTUNE_ENABLE 0xff41
5263 #define IDX_LOGFILE_DISABLE 0xff51
5264 #define IDX_TRUECRYPT_KEYFILES 0xff52
5265 #define IDX_SCRYPT_TMTO 0xff61
5266 #define IDX_SEGMENT_SIZE 'c'
5267 #define IDX_SEPARATOR 'p'
5268 #define IDX_BITMAP_MIN 0xff70
5269 #define IDX_BITMAP_MAX 0xff71
5270 #define IDX_CUSTOM_CHARSET_1 '1'
5271 #define IDX_CUSTOM_CHARSET_2 '2'
5272 #define IDX_CUSTOM_CHARSET_3 '3'
5273 #define IDX_CUSTOM_CHARSET_4 '4'
5274
5275 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5276
5277 struct option long_options[] =
5278 {
5279 {"help", no_argument, 0, IDX_HELP},
5280 {"version", no_argument, 0, IDX_VERSION},
5281 {"quiet", no_argument, 0, IDX_QUIET},
5282 {"show", no_argument, 0, IDX_SHOW},
5283 {"left", no_argument, 0, IDX_LEFT},
5284 {"username", no_argument, 0, IDX_USERNAME},
5285 {"remove", no_argument, 0, IDX_REMOVE},
5286 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5287 {"skip", required_argument, 0, IDX_SKIP},
5288 {"limit", required_argument, 0, IDX_LIMIT},
5289 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5290 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5291 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5292 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5293 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5294 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5295 {"force", no_argument, 0, IDX_FORCE},
5296 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5297 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5298 {"restore", no_argument, 0, IDX_RESTORE},
5299 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5300 {"status", no_argument, 0, IDX_STATUS},
5301 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5302 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5303 {"loopback", no_argument, 0, IDX_LOOPBACK},
5304 {"weak-hash-threshold",
5305 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5306 {"session", required_argument, 0, IDX_SESSION},
5307 {"runtime", required_argument, 0, IDX_RUNTIME},
5308 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5309 {"generate-rules-func-min",
5310 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5311 {"generate-rules-func-max",
5312 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5313 {"generate-rules-seed",
5314 required_argument, 0, IDX_RP_GEN_SEED},
5315 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5316 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5317 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5318 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5319 {"rules-file", required_argument, 0, IDX_RP_FILE},
5320 {"outfile", required_argument, 0, IDX_OUTFILE},
5321 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5322 {"outfile-autohex-disable",
5323 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5324 {"outfile-check-timer",
5325 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5326 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5327 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5328 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5329 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5330 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5331 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5332 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5333 #ifndef OSX
5334 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5335 #endif
5336 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5337 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5338 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5339 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5340 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5341 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5342 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5343 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5344 #ifdef HAVE_HWMON
5345 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5346 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5347 #ifdef HAVE_ADL
5348 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5349 #endif
5350 #endif // HAVE_HWMON
5351 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5352 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5353 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5354 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5355 // deprecated
5356 {"seperator", required_argument, 0, IDX_SEPARATOR},
5357 {"separator", required_argument, 0, IDX_SEPARATOR},
5358 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5359 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5360 {"increment", no_argument, 0, IDX_INCREMENT},
5361 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5362 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5363 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5364 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5365 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5366 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5367
5368 {0, 0, 0, 0}
5369 };
5370
5371 uint rp_files_cnt = 0;
5372
5373 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5374
5375 int option_index = 0;
5376 int c = -1;
5377
5378 optind = 1;
5379 optopt = 0;
5380
5381 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5382 {
5383 switch (c)
5384 {
5385 case IDX_HELP: usage = 1; break;
5386 case IDX_VERSION:
5387 case IDX_VERSION_LOWER: version = 1; break;
5388 case IDX_RESTORE: restore = 1; break;
5389 case IDX_SESSION: session = optarg; break;
5390 case IDX_SHOW: show = 1; break;
5391 case IDX_LEFT: left = 1; break;
5392 case '?': return (-1);
5393 }
5394 }
5395
5396 if (optopt != 0)
5397 {
5398 log_error ("ERROR: Invalid argument specified");
5399
5400 return (-1);
5401 }
5402
5403 /**
5404 * exit functions
5405 */
5406
5407 if (version)
5408 {
5409 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5410
5411 return (0);
5412 }
5413
5414 if (usage)
5415 {
5416 usage_big_print (PROGNAME);
5417
5418 return (0);
5419 }
5420
5421 /**
5422 * session needs to be set, always!
5423 */
5424
5425 if (session == NULL) session = (char *) PROGNAME;
5426
5427 /**
5428 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5429 */
5430
5431 char *exec_path = get_exec_path ();
5432
5433 #ifdef LINUX
5434
5435 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5436 char *resolved_exec_path = realpath (exec_path, NULL);
5437
5438 char *install_dir = get_install_dir (resolved_exec_path);
5439 char *profile_dir = NULL;
5440 char *session_dir = NULL;
5441 char *shared_dir = NULL;
5442
5443 if (strcmp (install_dir, resolved_install_folder) == 0)
5444 {
5445 struct passwd *pw = getpwuid (getuid ());
5446
5447 const char *homedir = pw->pw_dir;
5448
5449 profile_dir = get_profile_dir (homedir);
5450 session_dir = get_session_dir (profile_dir);
5451 shared_dir = strdup (SHARED_FOLDER);
5452
5453 mkdir (profile_dir, 0700);
5454 mkdir (session_dir, 0700);
5455 }
5456 else
5457 {
5458 profile_dir = install_dir;
5459 session_dir = install_dir;
5460 shared_dir = install_dir;
5461 }
5462
5463 myfree (resolved_install_folder);
5464 myfree (resolved_exec_path);
5465
5466 #else
5467
5468 char *install_dir = get_install_dir (exec_path);
5469 char *profile_dir = install_dir;
5470 char *session_dir = install_dir;
5471 char *shared_dir = install_dir;
5472
5473 #endif
5474
5475 data.install_dir = install_dir;
5476 data.profile_dir = profile_dir;
5477 data.session_dir = session_dir;
5478 data.shared_dir = shared_dir;
5479
5480 myfree (exec_path);
5481
5482 /**
5483 * kernel cache, we need to make sure folder exist
5484 */
5485
5486 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5487
5488 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5489
5490 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5491
5492 mkdir (kernels_folder, 0700);
5493
5494 myfree (kernels_folder);
5495
5496 /**
5497 * session
5498 */
5499
5500 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5501
5502 data.session = session;
5503
5504 char *eff_restore_file = (char *) mymalloc (session_size);
5505 char *new_restore_file = (char *) mymalloc (session_size);
5506
5507 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5508 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5509
5510 data.eff_restore_file = eff_restore_file;
5511 data.new_restore_file = new_restore_file;
5512
5513 if (((show == 1) || (left == 1)) && (restore == 1))
5514 {
5515 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5516 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5517
5518 return (-1);
5519 }
5520
5521 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5522 if ((show == 1) || (left == 1))
5523 {
5524 restore_disable = 1;
5525
5526 restore = 0;
5527 }
5528
5529 data.restore_disable = restore_disable;
5530
5531 restore_data_t *rd = init_restore (argc, argv);
5532
5533 data.rd = rd;
5534
5535 /**
5536 * restore file
5537 */
5538
5539 if (restore == 1)
5540 {
5541 read_restore (eff_restore_file, rd);
5542
5543 if (rd->version_bin < RESTORE_MIN)
5544 {
5545 log_error ("ERROR: Incompatible restore-file version");
5546
5547 return (-1);
5548 }
5549
5550 myargc = rd->argc;
5551 myargv = rd->argv;
5552
5553 #ifdef _POSIX
5554 rd->pid = getpid ();
5555 #elif _WIN
5556 rd->pid = GetCurrentProcessId ();
5557 #endif
5558 }
5559
5560 uint hash_mode_chgd = 0;
5561 uint runtime_chgd = 0;
5562 uint kernel_loops_chgd = 0;
5563 uint kernel_accel_chgd = 0;
5564 uint attack_mode_chgd = 0;
5565 uint outfile_format_chgd = 0;
5566 uint rp_gen_seed_chgd = 0;
5567 uint remove_timer_chgd = 0;
5568 uint increment_min_chgd = 0;
5569 uint increment_max_chgd = 0;
5570 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5571 uint gpu_temp_retain_chgd = 0;
5572 uint gpu_temp_abort_chgd = 0;
5573 #endif
5574
5575 optind = 1;
5576 optopt = 0;
5577 option_index = 0;
5578
5579 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5580 {
5581 switch (c)
5582 {
5583 //case IDX_HELP: usage = 1; break;
5584 //case IDX_VERSION: version = 1; break;
5585 //case IDX_RESTORE: restore = 1; break;
5586 case IDX_QUIET: quiet = 1; break;
5587 //case IDX_SHOW: show = 1; break;
5588 case IDX_SHOW: break;
5589 //case IDX_LEFT: left = 1; break;
5590 case IDX_LEFT: break;
5591 case IDX_USERNAME: username = 1; break;
5592 case IDX_REMOVE: remove = 1; break;
5593 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5594 remove_timer_chgd = 1; break;
5595 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5596 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5597 case IDX_DEBUG_FILE: debug_file = optarg; break;
5598 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5599 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5600 case IDX_FORCE: force = 1; break;
5601 case IDX_SKIP: skip = atoll (optarg); break;
5602 case IDX_LIMIT: limit = atoll (optarg); break;
5603 case IDX_KEYSPACE: keyspace = 1; break;
5604 case IDX_BENCHMARK: benchmark = 1; break;
5605 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5606 case IDX_RESTORE: break;
5607 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5608 case IDX_STATUS: status = 1; break;
5609 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5610 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5611 case IDX_LOOPBACK: loopback = 1; break;
5612 case IDX_WEAK_HASH_THRESHOLD:
5613 weak_hash_threshold = atoi (optarg); break;
5614 //case IDX_SESSION: session = optarg; break;
5615 case IDX_SESSION: break;
5616 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5617 hash_mode_chgd = 1; break;
5618 case IDX_RUNTIME: runtime = atoi (optarg);
5619 runtime_chgd = 1; break;
5620 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5621 attack_mode_chgd = 1; break;
5622 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5623 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5624 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5625 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5626 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5627 rp_gen_seed_chgd = 1; break;
5628 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5629 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5630 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5631 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5632 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5633 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5634 case IDX_OUTFILE: outfile = optarg; break;
5635 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5636 outfile_format_chgd = 1; break;
5637 case IDX_OUTFILE_AUTOHEX_DISABLE:
5638 outfile_autohex = 0; break;
5639 case IDX_OUTFILE_CHECK_TIMER:
5640 outfile_check_timer = atoi (optarg); break;
5641 case IDX_HEX_CHARSET: hex_charset = 1; break;
5642 case IDX_HEX_SALT: hex_salt = 1; break;
5643 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5644 #ifndef OSX
5645 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5646 #endif
5647 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5648 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5649 case IDX_OPENCL_DEVICE_TYPES:
5650 opencl_device_types = optarg; break;
5651 case IDX_OPENCL_VECTOR_WIDTH:
5652 opencl_vector_width = atoi (optarg); break;
5653 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5654 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5655 kernel_accel_chgd = 1; break;
5656 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5657 kernel_loops_chgd = 1; break;
5658 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5659 #ifdef HAVE_HWMON
5660 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5661 #ifdef HAVE_ADL
5662 gpu_temp_abort_chgd = 1;
5663 #endif
5664 break;
5665 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5666 #ifdef HAVE_ADL
5667 gpu_temp_retain_chgd = 1;
5668 #endif
5669 break;
5670 #ifdef HAVE_ADL
5671 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5672 #endif
5673 #endif // HAVE_HWMON
5674 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5675 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5676 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5677 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5678 case IDX_SEPARATOR: separator = optarg[0]; break;
5679 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5680 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5681 case IDX_INCREMENT: increment = 1; break;
5682 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5683 increment_min_chgd = 1; break;
5684 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5685 increment_max_chgd = 1; break;
5686 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5687 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5688 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5689 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5690
5691 default:
5692 log_error ("ERROR: Invalid argument specified");
5693 return (-1);
5694 }
5695 }
5696
5697 if (optopt != 0)
5698 {
5699 log_error ("ERROR: Invalid argument specified");
5700
5701 return (-1);
5702 }
5703
5704 /**
5705 * Inform user things getting started,
5706 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5707 * - we do not need to check algorithm_pos
5708 */
5709
5710 if (quiet == 0)
5711 {
5712 if (benchmark == 1)
5713 {
5714 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5715
5716 log_info ("");
5717 }
5718 else if (restore == 1)
5719 {
5720 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5721
5722 log_info ("");
5723 }
5724 else
5725 {
5726 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5727
5728 log_info ("");
5729 }
5730 }
5731
5732 /**
5733 * sanity check
5734 */
5735
5736 if (attack_mode > 7)
5737 {
5738 log_error ("ERROR: Invalid attack-mode specified");
5739
5740 return (-1);
5741 }
5742
5743 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5744 {
5745 log_error ("ERROR: Invalid runtime specified");
5746
5747 return (-1);
5748 }
5749
5750 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5751 {
5752 log_error ("ERROR: Invalid hash-type specified");
5753
5754 return (-1);
5755 }
5756
5757 // renamed hash modes
5758
5759 if (hash_mode_chgd)
5760 {
5761 int n = -1;
5762
5763 switch (hash_mode)
5764 {
5765 case 123: n = 124;
5766 break;
5767 }
5768
5769 if (n >= 0)
5770 {
5771 log_error ("Old -m specified, use -m %d instead", n);
5772
5773 return (-1);
5774 }
5775 }
5776
5777 if (username == 1)
5778 {
5779 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5780 {
5781 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5782
5783 return (-1);
5784 }
5785 }
5786
5787 if (outfile_format > 16)
5788 {
5789 log_error ("ERROR: Invalid outfile-format specified");
5790
5791 return (-1);
5792 }
5793
5794 if (left == 1)
5795 {
5796 if (outfile_format_chgd == 1)
5797 {
5798 if (outfile_format > 1)
5799 {
5800 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5801
5802 return (-1);
5803 }
5804 }
5805 else
5806 {
5807 outfile_format = OUTFILE_FMT_HASH;
5808 }
5809 }
5810
5811 if (show == 1)
5812 {
5813 if (outfile_format_chgd == 1)
5814 {
5815 if ((outfile_format > 7) && (outfile_format < 16))
5816 {
5817 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5818
5819 return (-1);
5820 }
5821 }
5822 }
5823
5824 if (increment_min < INCREMENT_MIN)
5825 {
5826 log_error ("ERROR: Invalid increment-min specified");
5827
5828 return (-1);
5829 }
5830
5831 if (increment_max > INCREMENT_MAX)
5832 {
5833 log_error ("ERROR: Invalid increment-max specified");
5834
5835 return (-1);
5836 }
5837
5838 if (increment_min > increment_max)
5839 {
5840 log_error ("ERROR: Invalid increment-min specified");
5841
5842 return (-1);
5843 }
5844
5845 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5846 {
5847 log_error ("ERROR: increment is not allowed in attack-mode 0");
5848
5849 return (-1);
5850 }
5851
5852 if ((increment == 0) && (increment_min_chgd == 1))
5853 {
5854 log_error ("ERROR: increment-min is only supported together with increment switch");
5855
5856 return (-1);
5857 }
5858
5859 if ((increment == 0) && (increment_max_chgd == 1))
5860 {
5861 log_error ("ERROR: increment-max is only supported together with increment switch");
5862
5863 return (-1);
5864 }
5865
5866 if (rp_files_cnt && rp_gen)
5867 {
5868 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5869
5870 return (-1);
5871 }
5872
5873 if (rp_files_cnt || rp_gen)
5874 {
5875 if (attack_mode != ATTACK_MODE_STRAIGHT)
5876 {
5877 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5878
5879 return (-1);
5880 }
5881 }
5882
5883 if (rp_gen_func_min > rp_gen_func_max)
5884 {
5885 log_error ("ERROR: Invalid rp-gen-func-min specified");
5886
5887 return (-1);
5888 }
5889
5890 if (kernel_accel_chgd == 1)
5891 {
5892 if (workload_profile != WORKLOAD_PROFILE)
5893 {
5894 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5895
5896 return (-1);
5897 }
5898
5899 if (kernel_accel < 1)
5900 {
5901 log_error ("ERROR: Invalid kernel-accel specified");
5902
5903 return (-1);
5904 }
5905
5906 if (kernel_accel > 800)
5907 {
5908 log_error ("ERROR: Invalid kernel-accel specified");
5909
5910 return (-1);
5911 }
5912 }
5913
5914 if (kernel_loops_chgd == 1)
5915 {
5916 if (workload_profile != WORKLOAD_PROFILE)
5917 {
5918 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5919
5920 return (-1);
5921 }
5922
5923 if (kernel_loops < 1)
5924 {
5925 log_error ("ERROR: Invalid kernel-loops specified");
5926
5927 return (-1);
5928 }
5929
5930 if (kernel_loops > 1024)
5931 {
5932 log_error ("ERROR: Invalid kernel-loops specified");
5933
5934 return (-1);
5935 }
5936 }
5937
5938 if (benchmark == 1)
5939 {
5940 if (workload_profile != WORKLOAD_PROFILE)
5941 {
5942 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5943
5944 return (-1);
5945 }
5946 }
5947
5948 if ((workload_profile < 1) || (workload_profile > 3))
5949 {
5950 log_error ("ERROR: workload-profile %i not available", workload_profile);
5951
5952 return (-1);
5953 }
5954
5955 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5956 {
5957 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5958
5959 return (-1);
5960 }
5961
5962 if (show == 1 || left == 1)
5963 {
5964 attack_mode = ATTACK_MODE_NONE;
5965
5966 if (remove == 1)
5967 {
5968 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5969
5970 return (-1);
5971 }
5972
5973 if (potfile_disable == 1)
5974 {
5975 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5976
5977 return (-1);
5978 }
5979 }
5980
5981 uint attack_kern = ATTACK_KERN_NONE;
5982
5983 switch (attack_mode)
5984 {
5985 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5986 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5987 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5988 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5989 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5990 }
5991
5992 if (benchmark == 0)
5993 {
5994 if (keyspace == 1)
5995 {
5996 int num_additional_params = 1;
5997
5998 if (attack_kern == ATTACK_KERN_COMBI)
5999 {
6000 num_additional_params = 2;
6001 }
6002
6003 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6004
6005 if (keyspace_wordlist_specified == 0) optind--;
6006 }
6007
6008 if (attack_kern == ATTACK_KERN_NONE)
6009 {
6010 if ((optind + 1) != myargc)
6011 {
6012 usage_mini_print (myargv[0]);
6013
6014 return (-1);
6015 }
6016 }
6017 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6018 {
6019 if ((optind + 1) > myargc)
6020 {
6021 usage_mini_print (myargv[0]);
6022
6023 return (-1);
6024 }
6025 }
6026 else if (attack_kern == ATTACK_KERN_COMBI)
6027 {
6028 if ((optind + 3) != myargc)
6029 {
6030 usage_mini_print (myargv[0]);
6031
6032 return (-1);
6033 }
6034 }
6035 else if (attack_kern == ATTACK_KERN_BF)
6036 {
6037 if ((optind + 1) > myargc)
6038 {
6039 usage_mini_print (myargv[0]);
6040
6041 return (-1);
6042 }
6043 }
6044 else
6045 {
6046 usage_mini_print (myargv[0]);
6047
6048 return (-1);
6049 }
6050 }
6051 else
6052 {
6053 if (myargv[optind] != 0)
6054 {
6055 log_error ("ERROR: Invalid argument for benchmark mode specified");
6056
6057 return (-1);
6058 }
6059
6060 if (attack_mode_chgd == 1)
6061 {
6062 if (attack_mode != ATTACK_MODE_BF)
6063 {
6064 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6065
6066 return (-1);
6067 }
6068 }
6069
6070 if (benchmark_mode == 0)
6071 {
6072 // nothing to do
6073 }
6074 else if (benchmark_mode == 1)
6075 {
6076 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6077 {
6078 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6079
6080 return (-1);
6081 }
6082 }
6083 else
6084 {
6085 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 if (skip != 0 && limit != 0)
6092 {
6093 limit += skip;
6094 }
6095
6096 if (keyspace == 1)
6097 {
6098 if (show == 1)
6099 {
6100 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6101
6102 return (-1);
6103 }
6104 else if (left == 1)
6105 {
6106 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6107
6108 return (-1);
6109 }
6110
6111 potfile_disable = 1;
6112
6113 restore_disable = 1;
6114
6115 restore = 0;
6116
6117 weak_hash_threshold = 0;
6118
6119 quiet = 1;
6120 }
6121
6122 if (remove_timer_chgd == 1)
6123 {
6124 if (remove == 0)
6125 {
6126 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6127
6128 return (-1);
6129 }
6130
6131 if (remove_timer < 1)
6132 {
6133 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6134
6135 return (-1);
6136 }
6137 }
6138
6139 if (loopback == 1)
6140 {
6141 if (attack_mode == ATTACK_MODE_BF)
6142 {
6143 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6144
6145 return (-1);
6146 }
6147 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6148 {
6149 if ((rp_files_cnt == 0) && (rp_gen == 0))
6150 {
6151 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6152
6153 return (-1);
6154 }
6155 }
6156 }
6157
6158 if (debug_mode > 0)
6159 {
6160 if (attack_mode != ATTACK_MODE_STRAIGHT)
6161 {
6162 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6163
6164 return (-1);
6165 }
6166
6167 if ((rp_files_cnt == 0) && (rp_gen == 0))
6168 {
6169 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6170
6171 return (-1);
6172 }
6173 }
6174
6175 if (debug_mode > 4)
6176 {
6177 log_error ("ERROR: Invalid debug-mode specified");
6178
6179 return (-1);
6180 }
6181
6182 if (debug_file != NULL)
6183 {
6184 if (debug_mode < 1)
6185 {
6186 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6187
6188 return (-1);
6189 }
6190 }
6191
6192 if (induction_dir != NULL)
6193 {
6194 if (attack_mode == ATTACK_MODE_BF)
6195 {
6196 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6197
6198 return (-1);
6199 }
6200 }
6201
6202 if (attack_mode != ATTACK_MODE_STRAIGHT)
6203 {
6204 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6205 {
6206 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6207
6208 return (-1);
6209 }
6210
6211 weak_hash_threshold = 0;
6212 }
6213
6214 /**
6215 * induction directory
6216 */
6217
6218 char *induction_directory = NULL;
6219
6220 if (attack_mode != ATTACK_MODE_BF)
6221 {
6222 if (induction_dir == NULL)
6223 {
6224 induction_directory = (char *) mymalloc (session_size);
6225
6226 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6227
6228 // create induction folder if it does not already exist
6229
6230 if (keyspace == 0)
6231 {
6232 if (rmdir (induction_directory) == -1)
6233 {
6234 if (errno == ENOENT)
6235 {
6236 // good, we can ignore
6237 }
6238 else if (errno == ENOTEMPTY)
6239 {
6240 char *induction_directory_mv = (char *) mymalloc (session_size);
6241
6242 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6243
6244 if (rename (induction_directory, induction_directory_mv) != 0)
6245 {
6246 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (mkdir (induction_directory, 0700) == -1)
6260 {
6261 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6262
6263 return (-1);
6264 }
6265 }
6266 }
6267 else
6268 {
6269 induction_directory = induction_dir;
6270 }
6271 }
6272
6273 data.induction_directory = induction_directory;
6274
6275 /**
6276 * loopback
6277 */
6278
6279 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6280
6281 char *loopback_file = (char *) mymalloc (loopback_size);
6282
6283 /**
6284 * outfile-check directory
6285 */
6286
6287 char *outfile_check_directory = NULL;
6288
6289 if (outfile_check_dir == NULL)
6290 {
6291 outfile_check_directory = (char *) mymalloc (session_size);
6292
6293 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6294 }
6295 else
6296 {
6297 outfile_check_directory = outfile_check_dir;
6298 }
6299
6300 data.outfile_check_directory = outfile_check_directory;
6301
6302 if (keyspace == 0)
6303 {
6304 struct stat outfile_check_stat;
6305
6306 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6307 {
6308 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6309
6310 if (is_dir == 0)
6311 {
6312 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6313
6314 return (-1);
6315 }
6316 }
6317 else if (outfile_check_dir == NULL)
6318 {
6319 if (mkdir (outfile_check_directory, 0700) == -1)
6320 {
6321 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6322
6323 return (-1);
6324 }
6325 }
6326 }
6327
6328 /**
6329 * special other stuff
6330 */
6331
6332 if (hash_mode == 9710)
6333 {
6334 outfile_format = 5;
6335 outfile_format_chgd = 1;
6336 }
6337
6338 if (hash_mode == 9810)
6339 {
6340 outfile_format = 5;
6341 outfile_format_chgd = 1;
6342 }
6343
6344 if (hash_mode == 10410)
6345 {
6346 outfile_format = 5;
6347 outfile_format_chgd = 1;
6348 }
6349
6350 /**
6351 * store stuff
6352 */
6353
6354 data.hash_mode = hash_mode;
6355 data.restore = restore;
6356 data.restore_timer = restore_timer;
6357 data.restore_disable = restore_disable;
6358 data.status = status;
6359 data.status_timer = status_timer;
6360 data.status_automat = status_automat;
6361 data.loopback = loopback;
6362 data.runtime = runtime;
6363 data.remove = remove;
6364 data.remove_timer = remove_timer;
6365 data.debug_mode = debug_mode;
6366 data.debug_file = debug_file;
6367 data.username = username;
6368 data.quiet = quiet;
6369 data.outfile = outfile;
6370 data.outfile_format = outfile_format;
6371 data.outfile_autohex = outfile_autohex;
6372 data.hex_charset = hex_charset;
6373 data.hex_salt = hex_salt;
6374 data.hex_wordlist = hex_wordlist;
6375 data.separator = separator;
6376 data.rp_files = rp_files;
6377 data.rp_files_cnt = rp_files_cnt;
6378 data.rp_gen = rp_gen;
6379 data.rp_gen_seed = rp_gen_seed;
6380 data.force = force;
6381 data.benchmark = benchmark;
6382 data.skip = skip;
6383 data.limit = limit;
6384 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6385 data.powertune_enable = powertune_enable;
6386 #endif
6387 data.logfile_disable = logfile_disable;
6388 data.truecrypt_keyfiles = truecrypt_keyfiles;
6389 data.scrypt_tmto = scrypt_tmto;
6390
6391 /**
6392 * cpu affinity
6393 */
6394
6395 #ifndef OSX
6396 if (cpu_affinity)
6397 {
6398 set_cpu_affinity (cpu_affinity);
6399 }
6400 #endif
6401
6402 if (rp_gen_seed_chgd == 0)
6403 {
6404 srand (proc_start);
6405 }
6406 else
6407 {
6408 srand (rp_gen_seed);
6409 }
6410
6411 /**
6412 * logfile init
6413 */
6414
6415 if (logfile_disable == 0)
6416 {
6417 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6418
6419 char *logfile = (char *) mymalloc (logfile_size);
6420
6421 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6422
6423 data.logfile = logfile;
6424
6425 char *topid = logfile_generate_topid ();
6426
6427 data.topid = topid;
6428 }
6429
6430 // logfile_append() checks for logfile_disable internally to make it easier from here
6431
6432 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6433 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6434 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6435 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6436 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6437 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6438 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6439 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6440 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6441 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6442
6443 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6444 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6445 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6446 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6447 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6448 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6449 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6450 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6451
6452 logfile_top_msg ("START");
6453
6454 logfile_top_uint (attack_mode);
6455 logfile_top_uint (attack_kern);
6456 logfile_top_uint (benchmark);
6457 logfile_top_uint (benchmark_mode);
6458 logfile_top_uint (bitmap_min);
6459 logfile_top_uint (bitmap_max);
6460 logfile_top_uint (debug_mode);
6461 logfile_top_uint (force);
6462 logfile_top_uint (kernel_accel);
6463 logfile_top_uint (kernel_loops);
6464 logfile_top_uint (gpu_temp_disable);
6465 #ifdef HAVE_HWMON
6466 logfile_top_uint (gpu_temp_abort);
6467 logfile_top_uint (gpu_temp_retain);
6468 #endif
6469 logfile_top_uint (hash_mode);
6470 logfile_top_uint (hex_charset);
6471 logfile_top_uint (hex_salt);
6472 logfile_top_uint (hex_wordlist);
6473 logfile_top_uint (increment);
6474 logfile_top_uint (increment_max);
6475 logfile_top_uint (increment_min);
6476 logfile_top_uint (keyspace);
6477 logfile_top_uint (left);
6478 logfile_top_uint (logfile_disable);
6479 logfile_top_uint (loopback);
6480 logfile_top_uint (markov_classic);
6481 logfile_top_uint (markov_disable);
6482 logfile_top_uint (markov_threshold);
6483 logfile_top_uint (outfile_autohex);
6484 logfile_top_uint (outfile_check_timer);
6485 logfile_top_uint (outfile_format);
6486 logfile_top_uint (potfile_disable);
6487 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6488 logfile_top_uint (powertune_enable);
6489 #endif
6490 logfile_top_uint (scrypt_tmto);
6491 logfile_top_uint (quiet);
6492 logfile_top_uint (remove);
6493 logfile_top_uint (remove_timer);
6494 logfile_top_uint (restore);
6495 logfile_top_uint (restore_disable);
6496 logfile_top_uint (restore_timer);
6497 logfile_top_uint (rp_gen);
6498 logfile_top_uint (rp_gen_func_max);
6499 logfile_top_uint (rp_gen_func_min);
6500 logfile_top_uint (rp_gen_seed);
6501 logfile_top_uint (runtime);
6502 logfile_top_uint (segment_size);
6503 logfile_top_uint (show);
6504 logfile_top_uint (status);
6505 logfile_top_uint (status_automat);
6506 logfile_top_uint (status_timer);
6507 logfile_top_uint (usage);
6508 logfile_top_uint (username);
6509 logfile_top_uint (version);
6510 logfile_top_uint (weak_hash_threshold);
6511 logfile_top_uint (workload_profile);
6512 logfile_top_uint64 (limit);
6513 logfile_top_uint64 (skip);
6514 logfile_top_char (separator);
6515 #ifndef OSX
6516 logfile_top_string (cpu_affinity);
6517 #endif
6518 logfile_top_string (custom_charset_1);
6519 logfile_top_string (custom_charset_2);
6520 logfile_top_string (custom_charset_3);
6521 logfile_top_string (custom_charset_4);
6522 logfile_top_string (debug_file);
6523 logfile_top_string (opencl_devices);
6524 logfile_top_string (opencl_platforms);
6525 logfile_top_string (opencl_device_types);
6526 logfile_top_uint (opencl_vector_width);
6527 logfile_top_string (induction_dir);
6528 logfile_top_string (markov_hcstat);
6529 logfile_top_string (outfile);
6530 logfile_top_string (outfile_check_dir);
6531 logfile_top_string (rule_buf_l);
6532 logfile_top_string (rule_buf_r);
6533 logfile_top_string (session);
6534 logfile_top_string (truecrypt_keyfiles);
6535
6536 /**
6537 * Init OpenCL library loader
6538 */
6539
6540 if (keyspace == 0)
6541 {
6542 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6543
6544 ocl_init (ocl);
6545
6546 data.ocl = ocl;
6547 }
6548
6549 /**
6550 * OpenCL platform selection
6551 */
6552
6553 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6554
6555 /**
6556 * OpenCL device selection
6557 */
6558
6559 u32 devices_filter = setup_devices_filter (opencl_devices);
6560
6561 /**
6562 * OpenCL device type selection
6563 */
6564
6565 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6566
6567 /**
6568 * benchmark
6569 */
6570
6571 if (benchmark == 1)
6572 {
6573 /**
6574 * disable useless stuff for benchmark
6575 */
6576
6577 restore_timer = 0;
6578 status_timer = 0;
6579 restore_disable = 1;
6580 potfile_disable = 1;
6581 weak_hash_threshold = 0;
6582
6583 data.restore_timer = restore_timer;
6584 data.status_timer = status_timer;
6585 data.restore_disable = restore_disable;
6586
6587 if (benchmark_mode == 1)
6588 {
6589 markov_disable = 1;
6590 }
6591
6592 /**
6593 * force attack mode to be bruteforce
6594 */
6595
6596 attack_mode = ATTACK_MODE_BF;
6597 attack_kern = ATTACK_KERN_BF;
6598
6599 if (runtime_chgd == 0)
6600 {
6601 runtime = 8;
6602
6603 if (benchmark_mode == 1) runtime = 17;
6604
6605 data.runtime = runtime;
6606 }
6607 }
6608
6609 /**
6610 * config
6611 */
6612
6613 uint hash_type = 0;
6614 uint salt_type = 0;
6615 uint attack_exec = 0;
6616 uint opts_type = 0;
6617 uint kern_type = 0;
6618 uint dgst_size = 0;
6619 uint esalt_size = 0;
6620 uint opti_type = 0;
6621 uint dgst_pos0 = -1;
6622 uint dgst_pos1 = -1;
6623 uint dgst_pos2 = -1;
6624 uint dgst_pos3 = -1;
6625
6626 int (*parse_func) (char *, uint, hash_t *);
6627 int (*sort_by_digest) (const void *, const void *);
6628
6629 uint algorithm_pos = 0;
6630 uint algorithm_max = 1;
6631
6632 uint *algorithms = default_benchmark_algorithms;
6633
6634 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6635
6636 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6637 {
6638 /*
6639 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6640 * the following algos are skipped entirely
6641 */
6642
6643 if (algorithm_pos > 0)
6644 {
6645 local_free (rd);
6646
6647 rd = init_restore (argc, argv);
6648
6649 data.rd = rd;
6650 }
6651
6652 /**
6653 * update hash_mode in case of multihash benchmark
6654 */
6655
6656 if (benchmark == 1)
6657 {
6658 if (hash_mode_chgd == 0)
6659 {
6660 hash_mode = algorithms[algorithm_pos];
6661
6662 data.hash_mode = hash_mode;
6663 }
6664
6665 quiet = 1;
6666
6667 data.quiet = quiet;
6668 }
6669
6670 switch (hash_mode)
6671 {
6672 case 0: hash_type = HASH_TYPE_MD5;
6673 salt_type = SALT_TYPE_NONE;
6674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6675 opts_type = OPTS_TYPE_PT_GENERATE_LE
6676 | OPTS_TYPE_PT_ADD80
6677 | OPTS_TYPE_PT_ADDBITS14;
6678 kern_type = KERN_TYPE_MD5;
6679 dgst_size = DGST_SIZE_4_4;
6680 parse_func = md5_parse_hash;
6681 sort_by_digest = sort_by_digest_4_4;
6682 opti_type = OPTI_TYPE_ZERO_BYTE
6683 | OPTI_TYPE_PRECOMPUTE_INIT
6684 | OPTI_TYPE_PRECOMPUTE_MERKLE
6685 | OPTI_TYPE_MEET_IN_MIDDLE
6686 | OPTI_TYPE_EARLY_SKIP
6687 | OPTI_TYPE_NOT_ITERATED
6688 | OPTI_TYPE_NOT_SALTED
6689 | OPTI_TYPE_RAW_HASH;
6690 dgst_pos0 = 0;
6691 dgst_pos1 = 3;
6692 dgst_pos2 = 2;
6693 dgst_pos3 = 1;
6694 break;
6695
6696 case 10: hash_type = HASH_TYPE_MD5;
6697 salt_type = SALT_TYPE_INTERN;
6698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6699 opts_type = OPTS_TYPE_PT_GENERATE_LE
6700 | OPTS_TYPE_ST_ADD80
6701 | OPTS_TYPE_ST_ADDBITS14;
6702 kern_type = KERN_TYPE_MD5_PWSLT;
6703 dgst_size = DGST_SIZE_4_4;
6704 parse_func = md5s_parse_hash;
6705 sort_by_digest = sort_by_digest_4_4;
6706 opti_type = OPTI_TYPE_ZERO_BYTE
6707 | OPTI_TYPE_PRECOMPUTE_INIT
6708 | OPTI_TYPE_PRECOMPUTE_MERKLE
6709 | OPTI_TYPE_MEET_IN_MIDDLE
6710 | OPTI_TYPE_EARLY_SKIP
6711 | OPTI_TYPE_NOT_ITERATED
6712 | OPTI_TYPE_APPENDED_SALT
6713 | OPTI_TYPE_RAW_HASH;
6714 dgst_pos0 = 0;
6715 dgst_pos1 = 3;
6716 dgst_pos2 = 2;
6717 dgst_pos3 = 1;
6718 break;
6719
6720 case 11: hash_type = HASH_TYPE_MD5;
6721 salt_type = SALT_TYPE_INTERN;
6722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6723 opts_type = OPTS_TYPE_PT_GENERATE_LE
6724 | OPTS_TYPE_ST_ADD80
6725 | OPTS_TYPE_ST_ADDBITS14;
6726 kern_type = KERN_TYPE_MD5_PWSLT;
6727 dgst_size = DGST_SIZE_4_4;
6728 parse_func = joomla_parse_hash;
6729 sort_by_digest = sort_by_digest_4_4;
6730 opti_type = OPTI_TYPE_ZERO_BYTE
6731 | OPTI_TYPE_PRECOMPUTE_INIT
6732 | OPTI_TYPE_PRECOMPUTE_MERKLE
6733 | OPTI_TYPE_MEET_IN_MIDDLE
6734 | OPTI_TYPE_EARLY_SKIP
6735 | OPTI_TYPE_NOT_ITERATED
6736 | OPTI_TYPE_APPENDED_SALT
6737 | OPTI_TYPE_RAW_HASH;
6738 dgst_pos0 = 0;
6739 dgst_pos1 = 3;
6740 dgst_pos2 = 2;
6741 dgst_pos3 = 1;
6742 break;
6743
6744 case 12: hash_type = HASH_TYPE_MD5;
6745 salt_type = SALT_TYPE_INTERN;
6746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6747 opts_type = OPTS_TYPE_PT_GENERATE_LE
6748 | OPTS_TYPE_ST_ADD80
6749 | OPTS_TYPE_ST_ADDBITS14;
6750 kern_type = KERN_TYPE_MD5_PWSLT;
6751 dgst_size = DGST_SIZE_4_4;
6752 parse_func = postgresql_parse_hash;
6753 sort_by_digest = sort_by_digest_4_4;
6754 opti_type = OPTI_TYPE_ZERO_BYTE
6755 | OPTI_TYPE_PRECOMPUTE_INIT
6756 | OPTI_TYPE_PRECOMPUTE_MERKLE
6757 | OPTI_TYPE_MEET_IN_MIDDLE
6758 | OPTI_TYPE_EARLY_SKIP
6759 | OPTI_TYPE_NOT_ITERATED
6760 | OPTI_TYPE_APPENDED_SALT
6761 | OPTI_TYPE_RAW_HASH;
6762 dgst_pos0 = 0;
6763 dgst_pos1 = 3;
6764 dgst_pos2 = 2;
6765 dgst_pos3 = 1;
6766 break;
6767
6768 case 20: hash_type = HASH_TYPE_MD5;
6769 salt_type = SALT_TYPE_INTERN;
6770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6771 opts_type = OPTS_TYPE_PT_GENERATE_LE
6772 | OPTS_TYPE_PT_ADD80
6773 | OPTS_TYPE_PT_ADDBITS14;
6774 kern_type = KERN_TYPE_MD5_SLTPW;
6775 dgst_size = DGST_SIZE_4_4;
6776 parse_func = md5s_parse_hash;
6777 sort_by_digest = sort_by_digest_4_4;
6778 opti_type = OPTI_TYPE_ZERO_BYTE
6779 | OPTI_TYPE_PRECOMPUTE_INIT
6780 | OPTI_TYPE_PRECOMPUTE_MERKLE
6781 | OPTI_TYPE_EARLY_SKIP
6782 | OPTI_TYPE_NOT_ITERATED
6783 | OPTI_TYPE_PREPENDED_SALT
6784 | OPTI_TYPE_RAW_HASH;
6785 dgst_pos0 = 0;
6786 dgst_pos1 = 3;
6787 dgst_pos2 = 2;
6788 dgst_pos3 = 1;
6789 break;
6790
6791 case 21: hash_type = HASH_TYPE_MD5;
6792 salt_type = SALT_TYPE_INTERN;
6793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6794 opts_type = OPTS_TYPE_PT_GENERATE_LE
6795 | OPTS_TYPE_PT_ADD80
6796 | OPTS_TYPE_PT_ADDBITS14;
6797 kern_type = KERN_TYPE_MD5_SLTPW;
6798 dgst_size = DGST_SIZE_4_4;
6799 parse_func = osc_parse_hash;
6800 sort_by_digest = sort_by_digest_4_4;
6801 opti_type = OPTI_TYPE_ZERO_BYTE
6802 | OPTI_TYPE_PRECOMPUTE_INIT
6803 | OPTI_TYPE_PRECOMPUTE_MERKLE
6804 | OPTI_TYPE_EARLY_SKIP
6805 | OPTI_TYPE_NOT_ITERATED
6806 | OPTI_TYPE_PREPENDED_SALT
6807 | OPTI_TYPE_RAW_HASH;
6808 dgst_pos0 = 0;
6809 dgst_pos1 = 3;
6810 dgst_pos2 = 2;
6811 dgst_pos3 = 1;
6812 break;
6813
6814 case 22: hash_type = HASH_TYPE_MD5;
6815 salt_type = SALT_TYPE_EMBEDDED;
6816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6817 opts_type = OPTS_TYPE_PT_GENERATE_LE
6818 | OPTS_TYPE_PT_ADD80
6819 | OPTS_TYPE_PT_ADDBITS14;
6820 kern_type = KERN_TYPE_MD5_SLTPW;
6821 dgst_size = DGST_SIZE_4_4;
6822 parse_func = netscreen_parse_hash;
6823 sort_by_digest = sort_by_digest_4_4;
6824 opti_type = OPTI_TYPE_ZERO_BYTE
6825 | OPTI_TYPE_PRECOMPUTE_INIT
6826 | OPTI_TYPE_PRECOMPUTE_MERKLE
6827 | OPTI_TYPE_EARLY_SKIP
6828 | OPTI_TYPE_NOT_ITERATED
6829 | OPTI_TYPE_PREPENDED_SALT
6830 | OPTI_TYPE_RAW_HASH;
6831 dgst_pos0 = 0;
6832 dgst_pos1 = 3;
6833 dgst_pos2 = 2;
6834 dgst_pos3 = 1;
6835 break;
6836
6837 case 23: hash_type = HASH_TYPE_MD5;
6838 salt_type = SALT_TYPE_EMBEDDED;
6839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6840 opts_type = OPTS_TYPE_PT_GENERATE_LE
6841 | OPTS_TYPE_PT_ADD80
6842 | OPTS_TYPE_PT_ADDBITS14;
6843 kern_type = KERN_TYPE_MD5_SLTPW;
6844 dgst_size = DGST_SIZE_4_4;
6845 parse_func = skype_parse_hash;
6846 sort_by_digest = sort_by_digest_4_4;
6847 opti_type = OPTI_TYPE_ZERO_BYTE
6848 | OPTI_TYPE_PRECOMPUTE_INIT
6849 | OPTI_TYPE_PRECOMPUTE_MERKLE
6850 | OPTI_TYPE_EARLY_SKIP
6851 | OPTI_TYPE_NOT_ITERATED
6852 | OPTI_TYPE_PREPENDED_SALT
6853 | OPTI_TYPE_RAW_HASH;
6854 dgst_pos0 = 0;
6855 dgst_pos1 = 3;
6856 dgst_pos2 = 2;
6857 dgst_pos3 = 1;
6858 break;
6859
6860 case 30: hash_type = HASH_TYPE_MD5;
6861 salt_type = SALT_TYPE_INTERN;
6862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6863 opts_type = OPTS_TYPE_PT_GENERATE_LE
6864 | OPTS_TYPE_PT_UNICODE
6865 | OPTS_TYPE_ST_ADD80
6866 | OPTS_TYPE_ST_ADDBITS14;
6867 kern_type = KERN_TYPE_MD5_PWUSLT;
6868 dgst_size = DGST_SIZE_4_4;
6869 parse_func = md5s_parse_hash;
6870 sort_by_digest = sort_by_digest_4_4;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_MEET_IN_MIDDLE
6875 | OPTI_TYPE_EARLY_SKIP
6876 | OPTI_TYPE_NOT_ITERATED
6877 | OPTI_TYPE_APPENDED_SALT
6878 | OPTI_TYPE_RAW_HASH;
6879 dgst_pos0 = 0;
6880 dgst_pos1 = 3;
6881 dgst_pos2 = 2;
6882 dgst_pos3 = 1;
6883 break;
6884
6885 case 40: hash_type = HASH_TYPE_MD5;
6886 salt_type = SALT_TYPE_INTERN;
6887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6888 opts_type = OPTS_TYPE_PT_GENERATE_LE
6889 | OPTS_TYPE_PT_ADD80
6890 | OPTS_TYPE_PT_ADDBITS14
6891 | OPTS_TYPE_PT_UNICODE;
6892 kern_type = KERN_TYPE_MD5_SLTPWU;
6893 dgst_size = DGST_SIZE_4_4;
6894 parse_func = md5s_parse_hash;
6895 sort_by_digest = sort_by_digest_4_4;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_EARLY_SKIP
6900 | OPTI_TYPE_NOT_ITERATED
6901 | OPTI_TYPE_PREPENDED_SALT
6902 | OPTI_TYPE_RAW_HASH;
6903 dgst_pos0 = 0;
6904 dgst_pos1 = 3;
6905 dgst_pos2 = 2;
6906 dgst_pos3 = 1;
6907 break;
6908
6909 case 50: hash_type = HASH_TYPE_MD5;
6910 salt_type = SALT_TYPE_INTERN;
6911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6912 opts_type = OPTS_TYPE_PT_GENERATE_LE
6913 | OPTS_TYPE_ST_ADD80
6914 | OPTS_TYPE_ST_ADDBITS14;
6915 kern_type = KERN_TYPE_HMACMD5_PW;
6916 dgst_size = DGST_SIZE_4_4;
6917 parse_func = hmacmd5_parse_hash;
6918 sort_by_digest = sort_by_digest_4_4;
6919 opti_type = OPTI_TYPE_ZERO_BYTE
6920 | OPTI_TYPE_NOT_ITERATED;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 60: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_PT_ADD80
6932 | OPTS_TYPE_PT_ADDBITS14;
6933 kern_type = KERN_TYPE_HMACMD5_SLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = hmacmd5_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_NOT_ITERATED;
6939 dgst_pos0 = 0;
6940 dgst_pos1 = 3;
6941 dgst_pos2 = 2;
6942 dgst_pos3 = 1;
6943 break;
6944
6945 case 100: hash_type = HASH_TYPE_SHA1;
6946 salt_type = SALT_TYPE_NONE;
6947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6948 opts_type = OPTS_TYPE_PT_GENERATE_BE
6949 | OPTS_TYPE_PT_ADD80
6950 | OPTS_TYPE_PT_ADDBITS15;
6951 kern_type = KERN_TYPE_SHA1;
6952 dgst_size = DGST_SIZE_4_5;
6953 parse_func = sha1_parse_hash;
6954 sort_by_digest = sort_by_digest_4_5;
6955 opti_type = OPTI_TYPE_ZERO_BYTE
6956 | OPTI_TYPE_PRECOMPUTE_INIT
6957 | OPTI_TYPE_PRECOMPUTE_MERKLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_NOT_SALTED
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 3;
6963 dgst_pos1 = 4;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 101: hash_type = HASH_TYPE_SHA1;
6969 salt_type = SALT_TYPE_NONE;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_BE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS15;
6974 kern_type = KERN_TYPE_SHA1;
6975 dgst_size = DGST_SIZE_4_5;
6976 parse_func = sha1b64_parse_hash;
6977 sort_by_digest = sort_by_digest_4_5;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_NOT_SALTED
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 3;
6986 dgst_pos1 = 4;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 110: hash_type = HASH_TYPE_SHA1;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_BE
6995 | OPTS_TYPE_ST_ADD80
6996 | OPTS_TYPE_ST_ADDBITS15;
6997 kern_type = KERN_TYPE_SHA1_PWSLT;
6998 dgst_size = DGST_SIZE_4_5;
6999 parse_func = sha1s_parse_hash;
7000 sort_by_digest = sort_by_digest_4_5;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_APPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 3;
7009 dgst_pos1 = 4;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 111: hash_type = HASH_TYPE_SHA1;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_BE
7018 | OPTS_TYPE_ST_ADD80
7019 | OPTS_TYPE_ST_ADDBITS15;
7020 kern_type = KERN_TYPE_SHA1_PWSLT;
7021 dgst_size = DGST_SIZE_4_5;
7022 parse_func = sha1b64s_parse_hash;
7023 sort_by_digest = sort_by_digest_4_5;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_APPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 3;
7032 dgst_pos1 = 4;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 112: hash_type = HASH_TYPE_SHA1;
7038 salt_type = SALT_TYPE_INTERN;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_BE
7041 | OPTS_TYPE_ST_ADD80
7042 | OPTS_TYPE_ST_ADDBITS15
7043 | OPTS_TYPE_ST_HEX;
7044 kern_type = KERN_TYPE_SHA1_PWSLT;
7045 dgst_size = DGST_SIZE_4_5;
7046 parse_func = oracles_parse_hash;
7047 sort_by_digest = sort_by_digest_4_5;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 3;
7056 dgst_pos1 = 4;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 120: hash_type = HASH_TYPE_SHA1;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_BE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS15;
7067 kern_type = KERN_TYPE_SHA1_SLTPW;
7068 dgst_size = DGST_SIZE_4_5;
7069 parse_func = sha1s_parse_hash;
7070 sort_by_digest = sort_by_digest_4_5;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_PREPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 3;
7079 dgst_pos1 = 4;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 121: hash_type = HASH_TYPE_SHA1;
7085 salt_type = SALT_TYPE_INTERN;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_BE
7088 | OPTS_TYPE_PT_ADD80
7089 | OPTS_TYPE_PT_ADDBITS15
7090 | OPTS_TYPE_ST_LOWER;
7091 kern_type = KERN_TYPE_SHA1_SLTPW;
7092 dgst_size = DGST_SIZE_4_5;
7093 parse_func = smf_parse_hash;
7094 sort_by_digest = sort_by_digest_4_5;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_PRECOMPUTE_INIT
7097 | OPTI_TYPE_PRECOMPUTE_MERKLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_PREPENDED_SALT
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 3;
7103 dgst_pos1 = 4;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 122: hash_type = HASH_TYPE_SHA1;
7109 salt_type = SALT_TYPE_EMBEDDED;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_BE
7112 | OPTS_TYPE_PT_ADD80
7113 | OPTS_TYPE_PT_ADDBITS15
7114 | OPTS_TYPE_ST_HEX;
7115 kern_type = KERN_TYPE_SHA1_SLTPW;
7116 dgst_size = DGST_SIZE_4_5;
7117 parse_func = osx1_parse_hash;
7118 sort_by_digest = sort_by_digest_4_5;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_PRECOMPUTE_INIT
7121 | OPTI_TYPE_PRECOMPUTE_MERKLE
7122 | OPTI_TYPE_EARLY_SKIP
7123 | OPTI_TYPE_NOT_ITERATED
7124 | OPTI_TYPE_PREPENDED_SALT
7125 | OPTI_TYPE_RAW_HASH;
7126 dgst_pos0 = 3;
7127 dgst_pos1 = 4;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 124: hash_type = HASH_TYPE_SHA1;
7133 salt_type = SALT_TYPE_EMBEDDED;
7134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7135 opts_type = OPTS_TYPE_PT_GENERATE_BE
7136 | OPTS_TYPE_PT_ADD80
7137 | OPTS_TYPE_PT_ADDBITS15;
7138 kern_type = KERN_TYPE_SHA1_SLTPW;
7139 dgst_size = DGST_SIZE_4_5;
7140 parse_func = djangosha1_parse_hash;
7141 sort_by_digest = sort_by_digest_4_5;
7142 opti_type = OPTI_TYPE_ZERO_BYTE
7143 | OPTI_TYPE_PRECOMPUTE_INIT
7144 | OPTI_TYPE_PRECOMPUTE_MERKLE
7145 | OPTI_TYPE_EARLY_SKIP
7146 | OPTI_TYPE_NOT_ITERATED
7147 | OPTI_TYPE_PREPENDED_SALT
7148 | OPTI_TYPE_RAW_HASH;
7149 dgst_pos0 = 3;
7150 dgst_pos1 = 4;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 130: hash_type = HASH_TYPE_SHA1;
7156 salt_type = SALT_TYPE_INTERN;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_BE
7159 | OPTS_TYPE_PT_UNICODE
7160 | OPTS_TYPE_ST_ADD80
7161 | OPTS_TYPE_ST_ADDBITS15;
7162 kern_type = KERN_TYPE_SHA1_PWUSLT;
7163 dgst_size = DGST_SIZE_4_5;
7164 parse_func = sha1s_parse_hash;
7165 sort_by_digest = sort_by_digest_4_5;
7166 opti_type = OPTI_TYPE_ZERO_BYTE
7167 | OPTI_TYPE_PRECOMPUTE_INIT
7168 | OPTI_TYPE_PRECOMPUTE_MERKLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_APPENDED_SALT
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 131: hash_type = HASH_TYPE_SHA1;
7180 salt_type = SALT_TYPE_EMBEDDED;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_BE
7183 | OPTS_TYPE_PT_UNICODE
7184 | OPTS_TYPE_PT_UPPER
7185 | OPTS_TYPE_ST_ADD80
7186 | OPTS_TYPE_ST_ADDBITS15
7187 | OPTS_TYPE_ST_HEX;
7188 kern_type = KERN_TYPE_SHA1_PWUSLT;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = mssql2000_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_APPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 132: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_EMBEDDED;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_PT_UNICODE
7210 | OPTS_TYPE_ST_ADD80
7211 | OPTS_TYPE_ST_ADDBITS15
7212 | OPTS_TYPE_ST_HEX;
7213 kern_type = KERN_TYPE_SHA1_PWUSLT;
7214 dgst_size = DGST_SIZE_4_5;
7215 parse_func = mssql2005_parse_hash;
7216 sort_by_digest = sort_by_digest_4_5;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_APPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 4;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 133: hash_type = HASH_TYPE_SHA1;
7231 salt_type = SALT_TYPE_EMBEDDED;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_PT_UNICODE
7235 | OPTS_TYPE_ST_ADD80
7236 | OPTS_TYPE_ST_ADDBITS15;
7237 kern_type = KERN_TYPE_SHA1_PWUSLT;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = peoplesoft_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 140: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15
7260 | OPTS_TYPE_PT_UNICODE;
7261 kern_type = KERN_TYPE_SHA1_SLTPWU;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = sha1s_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 141: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_EMBEDDED;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15
7284 | OPTS_TYPE_PT_UNICODE
7285 | OPTS_TYPE_ST_BASE64;
7286 kern_type = KERN_TYPE_SHA1_SLTPWU;
7287 dgst_size = DGST_SIZE_4_5;
7288 parse_func = episerver_parse_hash;
7289 sort_by_digest = sort_by_digest_4_5;
7290 opti_type = OPTI_TYPE_ZERO_BYTE
7291 | OPTI_TYPE_PRECOMPUTE_INIT
7292 | OPTI_TYPE_PRECOMPUTE_MERKLE
7293 | OPTI_TYPE_EARLY_SKIP
7294 | OPTI_TYPE_NOT_ITERATED
7295 | OPTI_TYPE_PREPENDED_SALT
7296 | OPTI_TYPE_RAW_HASH;
7297 dgst_pos0 = 3;
7298 dgst_pos1 = 4;
7299 dgst_pos2 = 2;
7300 dgst_pos3 = 1;
7301 break;
7302
7303 case 150: hash_type = HASH_TYPE_SHA1;
7304 salt_type = SALT_TYPE_INTERN;
7305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7306 opts_type = OPTS_TYPE_PT_GENERATE_BE
7307 | OPTS_TYPE_ST_ADD80
7308 | OPTS_TYPE_ST_ADDBITS15;
7309 kern_type = KERN_TYPE_HMACSHA1_PW;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = hmacsha1_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_NOT_ITERATED;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 160: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_INTERN;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_ADD80
7326 | OPTS_TYPE_PT_ADDBITS15;
7327 kern_type = KERN_TYPE_HMACSHA1_SLT;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = hmacsha1_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_NOT_ITERATED;
7333 dgst_pos0 = 3;
7334 dgst_pos1 = 4;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 1;
7337 break;
7338
7339 case 190: hash_type = HASH_TYPE_SHA1;
7340 salt_type = SALT_TYPE_NONE;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_BE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS15;
7345 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = sha1linkedin_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_NOT_SALTED;
7354 dgst_pos0 = 0;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 3;
7357 dgst_pos3 = 2;
7358 break;
7359
7360 case 200: hash_type = HASH_TYPE_MYSQL;
7361 salt_type = SALT_TYPE_NONE;
7362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7363 opts_type = 0;
7364 kern_type = KERN_TYPE_MYSQL;
7365 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7366 parse_func = mysql323_parse_hash;
7367 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7368 opti_type = OPTI_TYPE_ZERO_BYTE;
7369 dgst_pos0 = 0;
7370 dgst_pos1 = 1;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 3;
7373 break;
7374
7375 case 300: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_NONE;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_ADD80
7380 | OPTS_TYPE_PT_ADDBITS15;
7381 kern_type = KERN_TYPE_MYSQL41;
7382 dgst_size = DGST_SIZE_4_5;
7383 parse_func = sha1_parse_hash;
7384 sort_by_digest = sort_by_digest_4_5;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED
7390 | OPTI_TYPE_NOT_SALTED;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 400: hash_type = HASH_TYPE_MD5;
7398 salt_type = SALT_TYPE_EMBEDDED;
7399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7401 kern_type = KERN_TYPE_PHPASS;
7402 dgst_size = DGST_SIZE_4_4;
7403 parse_func = phpass_parse_hash;
7404 sort_by_digest = sort_by_digest_4_4;
7405 opti_type = OPTI_TYPE_ZERO_BYTE;
7406 dgst_pos0 = 0;
7407 dgst_pos1 = 1;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 3;
7410 break;
7411
7412 case 500: hash_type = HASH_TYPE_MD5;
7413 salt_type = SALT_TYPE_EMBEDDED;
7414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7416 kern_type = KERN_TYPE_MD5CRYPT;
7417 dgst_size = DGST_SIZE_4_4;
7418 parse_func = md5crypt_parse_hash;
7419 sort_by_digest = sort_by_digest_4_4;
7420 opti_type = OPTI_TYPE_ZERO_BYTE;
7421 dgst_pos0 = 0;
7422 dgst_pos1 = 1;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 3;
7425 break;
7426
7427 case 501: hash_type = HASH_TYPE_MD5;
7428 salt_type = SALT_TYPE_EMBEDDED;
7429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_LE
7431 | OPTS_TYPE_HASH_COPY;
7432 kern_type = KERN_TYPE_MD5CRYPT;
7433 dgst_size = DGST_SIZE_4_4;
7434 parse_func = juniper_parse_hash;
7435 sort_by_digest = sort_by_digest_4_4;
7436 opti_type = OPTI_TYPE_ZERO_BYTE;
7437 dgst_pos0 = 0;
7438 dgst_pos1 = 1;
7439 dgst_pos2 = 2;
7440 dgst_pos3 = 3;
7441 break;
7442
7443 case 900: hash_type = HASH_TYPE_MD4;
7444 salt_type = SALT_TYPE_NONE;
7445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7446 opts_type = OPTS_TYPE_PT_GENERATE_LE
7447 | OPTS_TYPE_PT_ADD80
7448 | OPTS_TYPE_PT_ADDBITS14;
7449 kern_type = KERN_TYPE_MD4;
7450 dgst_size = DGST_SIZE_4_4;
7451 parse_func = md4_parse_hash;
7452 sort_by_digest = sort_by_digest_4_4;
7453 opti_type = OPTI_TYPE_ZERO_BYTE
7454 | OPTI_TYPE_PRECOMPUTE_INIT
7455 | OPTI_TYPE_PRECOMPUTE_MERKLE
7456 | OPTI_TYPE_MEET_IN_MIDDLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_NOT_SALTED
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 0;
7462 dgst_pos1 = 3;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 1000: hash_type = HASH_TYPE_MD4;
7468 salt_type = SALT_TYPE_NONE;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_LE
7471 | OPTS_TYPE_PT_ADD80
7472 | OPTS_TYPE_PT_ADDBITS14
7473 | OPTS_TYPE_PT_UNICODE;
7474 kern_type = KERN_TYPE_MD4_PWU;
7475 dgst_size = DGST_SIZE_4_4;
7476 parse_func = md4_parse_hash;
7477 sort_by_digest = sort_by_digest_4_4;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_MEET_IN_MIDDLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_NOT_SALTED
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 0;
7487 dgst_pos1 = 3;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 1100: hash_type = HASH_TYPE_MD4;
7493 salt_type = SALT_TYPE_INTERN;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_LE
7496 | OPTS_TYPE_PT_ADD80
7497 | OPTS_TYPE_PT_ADDBITS14
7498 | OPTS_TYPE_PT_UNICODE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_UNICODE
7501 | OPTS_TYPE_ST_LOWER;
7502 kern_type = KERN_TYPE_MD44_PWUSLT;
7503 dgst_size = DGST_SIZE_4_4;
7504 parse_func = dcc_parse_hash;
7505 sort_by_digest = sort_by_digest_4_4;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 1400: hash_type = HASH_TYPE_SHA256;
7518 salt_type = SALT_TYPE_NONE;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_BE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS15;
7523 kern_type = KERN_TYPE_SHA256;
7524 dgst_size = DGST_SIZE_4_8;
7525 parse_func = sha256_parse_hash;
7526 sort_by_digest = sort_by_digest_4_8;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_NOT_SALTED
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 3;
7535 dgst_pos1 = 7;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 6;
7538 break;
7539
7540 case 1410: hash_type = HASH_TYPE_SHA256;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_BE
7544 | OPTS_TYPE_ST_ADD80
7545 | OPTS_TYPE_ST_ADDBITS15;
7546 kern_type = KERN_TYPE_SHA256_PWSLT;
7547 dgst_size = DGST_SIZE_4_8;
7548 parse_func = sha256s_parse_hash;
7549 sort_by_digest = sort_by_digest_4_8;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_PRECOMPUTE_INIT
7552 | OPTI_TYPE_PRECOMPUTE_MERKLE
7553 | OPTI_TYPE_EARLY_SKIP
7554 | OPTI_TYPE_NOT_ITERATED
7555 | OPTI_TYPE_APPENDED_SALT
7556 | OPTI_TYPE_RAW_HASH;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 7;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 6;
7561 break;
7562
7563 case 1420: hash_type = HASH_TYPE_SHA256;
7564 salt_type = SALT_TYPE_INTERN;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_SHA256_SLTPW;
7570 dgst_size = DGST_SIZE_4_8;
7571 parse_func = sha256s_parse_hash;
7572 sort_by_digest = sort_by_digest_4_8;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_PRECOMPUTE_MERKLE
7576 | OPTI_TYPE_EARLY_SKIP
7577 | OPTI_TYPE_NOT_ITERATED
7578 | OPTI_TYPE_PREPENDED_SALT
7579 | OPTI_TYPE_RAW_HASH;
7580 dgst_pos0 = 3;
7581 dgst_pos1 = 7;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 6;
7584 break;
7585
7586 case 1421: hash_type = HASH_TYPE_SHA256;
7587 salt_type = SALT_TYPE_EMBEDDED;
7588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_BE
7590 | OPTS_TYPE_PT_ADD80
7591 | OPTS_TYPE_PT_ADDBITS15;
7592 kern_type = KERN_TYPE_SHA256_SLTPW;
7593 dgst_size = DGST_SIZE_4_8;
7594 parse_func = hmailserver_parse_hash;
7595 sort_by_digest = sort_by_digest_4_8;
7596 opti_type = OPTI_TYPE_ZERO_BYTE
7597 | OPTI_TYPE_PRECOMPUTE_INIT
7598 | OPTI_TYPE_PRECOMPUTE_MERKLE
7599 | OPTI_TYPE_EARLY_SKIP
7600 | OPTI_TYPE_NOT_ITERATED
7601 | OPTI_TYPE_PREPENDED_SALT
7602 | OPTI_TYPE_RAW_HASH;
7603 dgst_pos0 = 3;
7604 dgst_pos1 = 7;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 6;
7607 break;
7608
7609 case 1430: hash_type = HASH_TYPE_SHA256;
7610 salt_type = SALT_TYPE_INTERN;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_BE
7613 | OPTS_TYPE_PT_UNICODE
7614 | OPTS_TYPE_ST_ADD80
7615 | OPTS_TYPE_ST_ADDBITS15;
7616 kern_type = KERN_TYPE_SHA256_PWUSLT;
7617 dgst_size = DGST_SIZE_4_8;
7618 parse_func = sha256s_parse_hash;
7619 sort_by_digest = sort_by_digest_4_8;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_APPENDED_SALT
7626 | OPTI_TYPE_RAW_HASH;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 7;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 6;
7631 break;
7632
7633 case 1440: hash_type = HASH_TYPE_SHA256;
7634 salt_type = SALT_TYPE_INTERN;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS15
7639 | OPTS_TYPE_PT_UNICODE;
7640 kern_type = KERN_TYPE_SHA256_SLTPWU;
7641 dgst_size = DGST_SIZE_4_8;
7642 parse_func = sha256s_parse_hash;
7643 sort_by_digest = sort_by_digest_4_8;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_PREPENDED_SALT
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 3;
7652 dgst_pos1 = 7;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 6;
7655 break;
7656
7657 case 1441: hash_type = HASH_TYPE_SHA256;
7658 salt_type = SALT_TYPE_EMBEDDED;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS15
7663 | OPTS_TYPE_PT_UNICODE
7664 | OPTS_TYPE_ST_BASE64;
7665 kern_type = KERN_TYPE_SHA256_SLTPWU;
7666 dgst_size = DGST_SIZE_4_8;
7667 parse_func = episerver4_parse_hash;
7668 sort_by_digest = sort_by_digest_4_8;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_PRECOMPUTE_INIT
7671 | OPTI_TYPE_PRECOMPUTE_MERKLE
7672 | OPTI_TYPE_EARLY_SKIP
7673 | OPTI_TYPE_NOT_ITERATED
7674 | OPTI_TYPE_PREPENDED_SALT
7675 | OPTI_TYPE_RAW_HASH;
7676 dgst_pos0 = 3;
7677 dgst_pos1 = 7;
7678 dgst_pos2 = 2;
7679 dgst_pos3 = 6;
7680 break;
7681
7682 case 1450: hash_type = HASH_TYPE_SHA256;
7683 salt_type = SALT_TYPE_INTERN;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_BE
7686 | OPTS_TYPE_ST_ADD80;
7687 kern_type = KERN_TYPE_HMACSHA256_PW;
7688 dgst_size = DGST_SIZE_4_8;
7689 parse_func = hmacsha256_parse_hash;
7690 sort_by_digest = sort_by_digest_4_8;
7691 opti_type = OPTI_TYPE_ZERO_BYTE
7692 | OPTI_TYPE_NOT_ITERATED;
7693 dgst_pos0 = 3;
7694 dgst_pos1 = 7;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 6;
7697 break;
7698
7699 case 1460: hash_type = HASH_TYPE_SHA256;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_BE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS15;
7705 kern_type = KERN_TYPE_HMACSHA256_SLT;
7706 dgst_size = DGST_SIZE_4_8;
7707 parse_func = hmacsha256_parse_hash;
7708 sort_by_digest = sort_by_digest_4_8;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_NOT_ITERATED;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 7;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 6;
7715 break;
7716
7717 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7718 salt_type = SALT_TYPE_EMBEDDED;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_LE
7721 | OPTS_TYPE_PT_BITSLICE;
7722 kern_type = KERN_TYPE_DESCRYPT;
7723 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7724 parse_func = descrypt_parse_hash;
7725 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7728 dgst_pos0 = 0;
7729 dgst_pos1 = 1;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 3;
7732 break;
7733
7734 case 1600: hash_type = HASH_TYPE_MD5;
7735 salt_type = SALT_TYPE_EMBEDDED;
7736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7738 kern_type = KERN_TYPE_APR1CRYPT;
7739 dgst_size = DGST_SIZE_4_4;
7740 parse_func = md5apr1_parse_hash;
7741 sort_by_digest = sort_by_digest_4_4;
7742 opti_type = OPTI_TYPE_ZERO_BYTE;
7743 dgst_pos0 = 0;
7744 dgst_pos1 = 1;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 3;
7747 break;
7748
7749 case 1700: hash_type = HASH_TYPE_SHA512;
7750 salt_type = SALT_TYPE_NONE;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA512;
7756 dgst_size = DGST_SIZE_8_8;
7757 parse_func = sha512_parse_hash;
7758 sort_by_digest = sort_by_digest_8_8;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_PRECOMPUTE_MERKLE
7762 | OPTI_TYPE_EARLY_SKIP
7763 | OPTI_TYPE_NOT_ITERATED
7764 | OPTI_TYPE_NOT_SALTED
7765 | OPTI_TYPE_USES_BITS_64
7766 | OPTI_TYPE_RAW_HASH;
7767 dgst_pos0 = 14;
7768 dgst_pos1 = 15;
7769 dgst_pos2 = 6;
7770 dgst_pos3 = 7;
7771 break;
7772
7773 case 1710: hash_type = HASH_TYPE_SHA512;
7774 salt_type = SALT_TYPE_INTERN;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_ST_ADD80
7778 | OPTS_TYPE_ST_ADDBITS15;
7779 kern_type = KERN_TYPE_SHA512_PWSLT;
7780 dgst_size = DGST_SIZE_8_8;
7781 parse_func = sha512s_parse_hash;
7782 sort_by_digest = sort_by_digest_8_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_APPENDED_SALT
7789 | OPTI_TYPE_USES_BITS_64
7790 | OPTI_TYPE_RAW_HASH;
7791 dgst_pos0 = 14;
7792 dgst_pos1 = 15;
7793 dgst_pos2 = 6;
7794 dgst_pos3 = 7;
7795 break;
7796
7797 case 1711: hash_type = HASH_TYPE_SHA512;
7798 salt_type = SALT_TYPE_EMBEDDED;
7799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7800 opts_type = OPTS_TYPE_PT_GENERATE_BE
7801 | OPTS_TYPE_ST_ADD80
7802 | OPTS_TYPE_ST_ADDBITS15;
7803 kern_type = KERN_TYPE_SHA512_PWSLT;
7804 dgst_size = DGST_SIZE_8_8;
7805 parse_func = sha512b64s_parse_hash;
7806 sort_by_digest = sort_by_digest_8_8;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_APPENDED_SALT
7813 | OPTI_TYPE_USES_BITS_64
7814 | OPTI_TYPE_RAW_HASH;
7815 dgst_pos0 = 14;
7816 dgst_pos1 = 15;
7817 dgst_pos2 = 6;
7818 dgst_pos3 = 7;
7819 break;
7820
7821 case 1720: hash_type = HASH_TYPE_SHA512;
7822 salt_type = SALT_TYPE_INTERN;
7823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_BE
7825 | OPTS_TYPE_PT_ADD80
7826 | OPTS_TYPE_PT_ADDBITS15;
7827 kern_type = KERN_TYPE_SHA512_SLTPW;
7828 dgst_size = DGST_SIZE_8_8;
7829 parse_func = sha512s_parse_hash;
7830 sort_by_digest = sort_by_digest_8_8;
7831 opti_type = OPTI_TYPE_ZERO_BYTE
7832 | OPTI_TYPE_PRECOMPUTE_INIT
7833 | OPTI_TYPE_PRECOMPUTE_MERKLE
7834 | OPTI_TYPE_EARLY_SKIP
7835 | OPTI_TYPE_NOT_ITERATED
7836 | OPTI_TYPE_PREPENDED_SALT
7837 | OPTI_TYPE_USES_BITS_64
7838 | OPTI_TYPE_RAW_HASH;
7839 dgst_pos0 = 14;
7840 dgst_pos1 = 15;
7841 dgst_pos2 = 6;
7842 dgst_pos3 = 7;
7843 break;
7844
7845 case 1722: hash_type = HASH_TYPE_SHA512;
7846 salt_type = SALT_TYPE_EMBEDDED;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_ADD80
7850 | OPTS_TYPE_PT_ADDBITS15
7851 | OPTS_TYPE_ST_HEX;
7852 kern_type = KERN_TYPE_SHA512_SLTPW;
7853 dgst_size = DGST_SIZE_8_8;
7854 parse_func = osx512_parse_hash;
7855 sort_by_digest = sort_by_digest_8_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_PREPENDED_SALT
7862 | OPTI_TYPE_USES_BITS_64
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 14;
7865 dgst_pos1 = 15;
7866 dgst_pos2 = 6;
7867 dgst_pos3 = 7;
7868 break;
7869
7870 case 1730: hash_type = HASH_TYPE_SHA512;
7871 salt_type = SALT_TYPE_INTERN;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_UNICODE
7875 | OPTS_TYPE_ST_ADD80
7876 | OPTS_TYPE_ST_ADDBITS15;
7877 kern_type = KERN_TYPE_SHA512_PWSLTU;
7878 dgst_size = DGST_SIZE_8_8;
7879 parse_func = sha512s_parse_hash;
7880 sort_by_digest = sort_by_digest_8_8;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_APPENDED_SALT
7887 | OPTI_TYPE_USES_BITS_64
7888 | OPTI_TYPE_RAW_HASH;
7889 dgst_pos0 = 14;
7890 dgst_pos1 = 15;
7891 dgst_pos2 = 6;
7892 dgst_pos3 = 7;
7893 break;
7894
7895 case 1731: hash_type = HASH_TYPE_SHA512;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_BE
7899 | OPTS_TYPE_PT_UNICODE
7900 | OPTS_TYPE_ST_ADD80
7901 | OPTS_TYPE_ST_ADDBITS15
7902 | OPTS_TYPE_ST_HEX;
7903 kern_type = KERN_TYPE_SHA512_PWSLTU;
7904 dgst_size = DGST_SIZE_8_8;
7905 parse_func = mssql2012_parse_hash;
7906 sort_by_digest = sort_by_digest_8_8;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_EARLY_SKIP
7911 | OPTI_TYPE_NOT_ITERATED
7912 | OPTI_TYPE_APPENDED_SALT
7913 | OPTI_TYPE_USES_BITS_64
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 14;
7916 dgst_pos1 = 15;
7917 dgst_pos2 = 6;
7918 dgst_pos3 = 7;
7919 break;
7920
7921 case 1740: hash_type = HASH_TYPE_SHA512;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15
7927 | OPTS_TYPE_PT_UNICODE;
7928 kern_type = KERN_TYPE_SHA512_SLTPWU;
7929 dgst_size = DGST_SIZE_8_8;
7930 parse_func = sha512s_parse_hash;
7931 sort_by_digest = sort_by_digest_8_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_USES_BITS_64
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 14;
7941 dgst_pos1 = 15;
7942 dgst_pos2 = 6;
7943 dgst_pos3 = 7;
7944 break;
7945
7946 case 1750: hash_type = HASH_TYPE_SHA512;
7947 salt_type = SALT_TYPE_INTERN;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_ST_ADD80;
7951 kern_type = KERN_TYPE_HMACSHA512_PW;
7952 dgst_size = DGST_SIZE_8_8;
7953 parse_func = hmacsha512_parse_hash;
7954 sort_by_digest = sort_by_digest_8_8;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_USES_BITS_64
7957 | OPTI_TYPE_NOT_ITERATED;
7958 dgst_pos0 = 14;
7959 dgst_pos1 = 15;
7960 dgst_pos2 = 6;
7961 dgst_pos3 = 7;
7962 break;
7963
7964 case 1760: hash_type = HASH_TYPE_SHA512;
7965 salt_type = SALT_TYPE_INTERN;
7966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7967 opts_type = OPTS_TYPE_PT_GENERATE_BE
7968 | OPTS_TYPE_PT_ADD80
7969 | OPTS_TYPE_PT_ADDBITS15;
7970 kern_type = KERN_TYPE_HMACSHA512_SLT;
7971 dgst_size = DGST_SIZE_8_8;
7972 parse_func = hmacsha512_parse_hash;
7973 sort_by_digest = sort_by_digest_8_8;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_USES_BITS_64
7976 | OPTI_TYPE_NOT_ITERATED;
7977 dgst_pos0 = 14;
7978 dgst_pos1 = 15;
7979 dgst_pos2 = 6;
7980 dgst_pos3 = 7;
7981 break;
7982
7983 case 1800: hash_type = HASH_TYPE_SHA512;
7984 salt_type = SALT_TYPE_EMBEDDED;
7985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7986 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7987 kern_type = KERN_TYPE_SHA512CRYPT;
7988 dgst_size = DGST_SIZE_8_8;
7989 parse_func = sha512crypt_parse_hash;
7990 sort_by_digest = sort_by_digest_8_8;
7991 opti_type = OPTI_TYPE_ZERO_BYTE
7992 | OPTI_TYPE_USES_BITS_64;
7993 dgst_pos0 = 0;
7994 dgst_pos1 = 1;
7995 dgst_pos2 = 2;
7996 dgst_pos3 = 3;
7997 break;
7998
7999 case 2100: hash_type = HASH_TYPE_DCC2;
8000 salt_type = SALT_TYPE_EMBEDDED;
8001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_ST_LOWER
8004 | OPTS_TYPE_ST_UNICODE;
8005 kern_type = KERN_TYPE_DCC2;
8006 dgst_size = DGST_SIZE_4_4;
8007 parse_func = dcc2_parse_hash;
8008 sort_by_digest = sort_by_digest_4_4;
8009 opti_type = OPTI_TYPE_ZERO_BYTE;
8010 dgst_pos0 = 0;
8011 dgst_pos1 = 1;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 3;
8014 break;
8015
8016 case 2400: hash_type = HASH_TYPE_MD5;
8017 salt_type = SALT_TYPE_NONE;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8020 kern_type = KERN_TYPE_MD5PIX;
8021 dgst_size = DGST_SIZE_4_4;
8022 parse_func = md5pix_parse_hash;
8023 sort_by_digest = sort_by_digest_4_4;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_NOT_SALTED;
8030 dgst_pos0 = 0;
8031 dgst_pos1 = 3;
8032 dgst_pos2 = 2;
8033 dgst_pos3 = 1;
8034 break;
8035
8036 case 2410: hash_type = HASH_TYPE_MD5;
8037 salt_type = SALT_TYPE_INTERN;
8038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8040 kern_type = KERN_TYPE_MD5ASA;
8041 dgst_size = DGST_SIZE_4_4;
8042 parse_func = md5asa_parse_hash;
8043 sort_by_digest = sort_by_digest_4_4;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED;
8049 dgst_pos0 = 0;
8050 dgst_pos1 = 3;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 1;
8053 break;
8054
8055 case 2500: hash_type = HASH_TYPE_WPA;
8056 salt_type = SALT_TYPE_EMBEDDED;
8057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8059 kern_type = KERN_TYPE_WPA;
8060 dgst_size = DGST_SIZE_4_4;
8061 parse_func = wpa_parse_hash;
8062 sort_by_digest = sort_by_digest_4_4;
8063 opti_type = OPTI_TYPE_ZERO_BYTE;
8064 dgst_pos0 = 0;
8065 dgst_pos1 = 1;
8066 dgst_pos2 = 2;
8067 dgst_pos3 = 3;
8068 break;
8069
8070 case 2600: hash_type = HASH_TYPE_MD5;
8071 salt_type = SALT_TYPE_VIRTUAL;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_LE
8074 | OPTS_TYPE_PT_ADD80
8075 | OPTS_TYPE_PT_ADDBITS14
8076 | OPTS_TYPE_ST_ADD80;
8077 kern_type = KERN_TYPE_MD55_PWSLT1;
8078 dgst_size = DGST_SIZE_4_4;
8079 parse_func = md5md5_parse_hash;
8080 sort_by_digest = sort_by_digest_4_4;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP;
8085 dgst_pos0 = 0;
8086 dgst_pos1 = 3;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 1;
8089 break;
8090
8091 case 2611: hash_type = HASH_TYPE_MD5;
8092 salt_type = SALT_TYPE_INTERN;
8093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_LE
8095 | OPTS_TYPE_PT_ADD80
8096 | OPTS_TYPE_PT_ADDBITS14
8097 | OPTS_TYPE_ST_ADD80;
8098 kern_type = KERN_TYPE_MD55_PWSLT1;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = vb3_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP;
8106 dgst_pos0 = 0;
8107 dgst_pos1 = 3;
8108 dgst_pos2 = 2;
8109 dgst_pos3 = 1;
8110 break;
8111
8112 case 2612: hash_type = HASH_TYPE_MD5;
8113 salt_type = SALT_TYPE_EMBEDDED;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_LE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS14
8118 | OPTS_TYPE_ST_ADD80
8119 | OPTS_TYPE_ST_HEX;
8120 kern_type = KERN_TYPE_MD55_PWSLT1;
8121 dgst_size = DGST_SIZE_4_4;
8122 parse_func = phps_parse_hash;
8123 sort_by_digest = sort_by_digest_4_4;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP;
8128 dgst_pos0 = 0;
8129 dgst_pos1 = 3;
8130 dgst_pos2 = 2;
8131 dgst_pos3 = 1;
8132 break;
8133
8134 case 2711: hash_type = HASH_TYPE_MD5;
8135 salt_type = SALT_TYPE_INTERN;
8136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE
8138 | OPTS_TYPE_PT_ADD80
8139 | OPTS_TYPE_PT_ADDBITS14
8140 | OPTS_TYPE_ST_ADD80;
8141 kern_type = KERN_TYPE_MD55_PWSLT2;
8142 dgst_size = DGST_SIZE_4_4;
8143 parse_func = vb30_parse_hash;
8144 sort_by_digest = sort_by_digest_4_4;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_EARLY_SKIP;
8148 dgst_pos0 = 0;
8149 dgst_pos1 = 3;
8150 dgst_pos2 = 2;
8151 dgst_pos3 = 1;
8152 break;
8153
8154 case 2811: hash_type = HASH_TYPE_MD5;
8155 salt_type = SALT_TYPE_INTERN;
8156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8157 opts_type = OPTS_TYPE_PT_GENERATE_LE
8158 | OPTS_TYPE_PT_ADD80
8159 | OPTS_TYPE_PT_ADDBITS14;
8160 kern_type = KERN_TYPE_MD55_SLTPW;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = ipb2_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_EARLY_SKIP;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 3;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 1;
8171 break;
8172
8173 case 3000: hash_type = HASH_TYPE_LM;
8174 salt_type = SALT_TYPE_NONE;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE
8177 | OPTS_TYPE_PT_UPPER
8178 | OPTS_TYPE_PT_BITSLICE;
8179 kern_type = KERN_TYPE_LM;
8180 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8181 parse_func = lm_parse_hash;
8182 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8185 dgst_pos0 = 0;
8186 dgst_pos1 = 1;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 3;
8189 break;
8190
8191 case 3100: hash_type = HASH_TYPE_ORACLEH;
8192 salt_type = SALT_TYPE_INTERN;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_UPPER
8196 | OPTS_TYPE_ST_UPPER;
8197 kern_type = KERN_TYPE_ORACLEH;
8198 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8199 parse_func = oracleh_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8201 opti_type = OPTI_TYPE_ZERO_BYTE;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 3200: hash_type = HASH_TYPE_BCRYPT;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE
8212 | OPTS_TYPE_ST_GENERATE_LE;
8213 kern_type = KERN_TYPE_BCRYPT;
8214 dgst_size = DGST_SIZE_4_6;
8215 parse_func = bcrypt_parse_hash;
8216 sort_by_digest = sort_by_digest_4_6;
8217 opti_type = OPTI_TYPE_ZERO_BYTE;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 1;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 3;
8222 break;
8223
8224 case 3710: hash_type = HASH_TYPE_MD5;
8225 salt_type = SALT_TYPE_INTERN;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE
8228 | OPTS_TYPE_PT_ADD80
8229 | OPTS_TYPE_PT_ADDBITS14;
8230 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = md5s_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_PRECOMPUTE_INIT
8236 | OPTI_TYPE_PRECOMPUTE_MERKLE
8237 | OPTI_TYPE_EARLY_SKIP;
8238 dgst_pos0 = 0;
8239 dgst_pos1 = 3;
8240 dgst_pos2 = 2;
8241 dgst_pos3 = 1;
8242 break;
8243
8244 case 3711: hash_type = HASH_TYPE_MD5;
8245 salt_type = SALT_TYPE_EMBEDDED;
8246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8247 opts_type = OPTS_TYPE_PT_GENERATE_LE
8248 | OPTS_TYPE_PT_ADD80
8249 | OPTS_TYPE_PT_ADDBITS14;
8250 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8251 dgst_size = DGST_SIZE_4_4;
8252 parse_func = mediawiki_b_parse_hash;
8253 sort_by_digest = sort_by_digest_4_4;
8254 opti_type = OPTI_TYPE_ZERO_BYTE
8255 | OPTI_TYPE_PRECOMPUTE_INIT
8256 | OPTI_TYPE_PRECOMPUTE_MERKLE
8257 | OPTI_TYPE_EARLY_SKIP;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 3800: hash_type = HASH_TYPE_MD5;
8265 salt_type = SALT_TYPE_INTERN;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE
8268 | OPTS_TYPE_ST_ADDBITS14;
8269 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8270 dgst_size = DGST_SIZE_4_4;
8271 parse_func = md5s_parse_hash;
8272 sort_by_digest = sort_by_digest_4_4;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_PRECOMPUTE_INIT
8275 | OPTI_TYPE_PRECOMPUTE_MERKLE
8276 | OPTI_TYPE_EARLY_SKIP
8277 | OPTI_TYPE_NOT_ITERATED
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 4300: hash_type = HASH_TYPE_MD5;
8286 salt_type = SALT_TYPE_VIRTUAL;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS14
8291 | OPTS_TYPE_ST_ADD80;
8292 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8293 dgst_size = DGST_SIZE_4_4;
8294 parse_func = md5md5_parse_hash;
8295 sort_by_digest = sort_by_digest_4_4;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP;
8300 dgst_pos0 = 0;
8301 dgst_pos1 = 3;
8302 dgst_pos2 = 2;
8303 dgst_pos3 = 1;
8304 break;
8305
8306
8307 case 4400: hash_type = HASH_TYPE_MD5;
8308 salt_type = SALT_TYPE_NONE;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_BE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS15;
8313 kern_type = KERN_TYPE_MD5_SHA1;
8314 dgst_size = DGST_SIZE_4_4;
8315 parse_func = md5_parse_hash;
8316 sort_by_digest = sort_by_digest_4_4;
8317 opti_type = OPTI_TYPE_ZERO_BYTE
8318 | OPTI_TYPE_PRECOMPUTE_INIT
8319 | OPTI_TYPE_PRECOMPUTE_MERKLE
8320 | OPTI_TYPE_EARLY_SKIP
8321 | OPTI_TYPE_NOT_ITERATED
8322 | OPTI_TYPE_NOT_SALTED
8323 | OPTI_TYPE_RAW_HASH;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 4500: hash_type = HASH_TYPE_SHA1;
8331 salt_type = SALT_TYPE_NONE;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_BE
8334 | OPTS_TYPE_PT_ADD80
8335 | OPTS_TYPE_PT_ADDBITS15;
8336 kern_type = KERN_TYPE_SHA11;
8337 dgst_size = DGST_SIZE_4_5;
8338 parse_func = sha1_parse_hash;
8339 sort_by_digest = sort_by_digest_4_5;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_PRECOMPUTE_MERKLE
8343 | OPTI_TYPE_EARLY_SKIP
8344 | OPTI_TYPE_NOT_SALTED;
8345 dgst_pos0 = 3;
8346 dgst_pos1 = 4;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 4700: hash_type = HASH_TYPE_SHA1;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_LE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS14;
8357 kern_type = KERN_TYPE_SHA1_MD5;
8358 dgst_size = DGST_SIZE_4_5;
8359 parse_func = sha1_parse_hash;
8360 sort_by_digest = sort_by_digest_4_5;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP
8365 | OPTI_TYPE_NOT_ITERATED
8366 | OPTI_TYPE_NOT_SALTED
8367 | OPTI_TYPE_RAW_HASH;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 4;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 4800: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADDBITS14;
8379 kern_type = KERN_TYPE_MD5_CHAP;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = chap_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_MEET_IN_MIDDLE
8387 | OPTI_TYPE_EARLY_SKIP
8388 | OPTI_TYPE_NOT_ITERATED
8389 | OPTI_TYPE_RAW_HASH;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 4900: hash_type = HASH_TYPE_SHA1;
8397 salt_type = SALT_TYPE_INTERN;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8400 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8401 dgst_size = DGST_SIZE_4_5;
8402 parse_func = sha1s_parse_hash;
8403 sort_by_digest = sort_by_digest_4_5;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_PRECOMPUTE_INIT
8406 | OPTI_TYPE_PRECOMPUTE_MERKLE
8407 | OPTI_TYPE_EARLY_SKIP;
8408 dgst_pos0 = 3;
8409 dgst_pos1 = 4;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414 case 5000: hash_type = HASH_TYPE_KECCAK;
8415 salt_type = SALT_TYPE_EMBEDDED;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_PT_ADD01;
8419 kern_type = KERN_TYPE_KECCAK;
8420 dgst_size = DGST_SIZE_8_25;
8421 parse_func = keccak_parse_hash;
8422 sort_by_digest = sort_by_digest_8_25;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_USES_BITS_64
8425 | OPTI_TYPE_RAW_HASH;
8426 dgst_pos0 = 2;
8427 dgst_pos1 = 3;
8428 dgst_pos2 = 4;
8429 dgst_pos3 = 5;
8430 break;
8431
8432 case 5100: hash_type = HASH_TYPE_MD5H;
8433 salt_type = SALT_TYPE_NONE;
8434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_LE
8436 | OPTS_TYPE_PT_ADD80
8437 | OPTS_TYPE_PT_ADDBITS14;
8438 kern_type = KERN_TYPE_MD5H;
8439 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8440 parse_func = md5half_parse_hash;
8441 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_RAW_HASH;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 1;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 3;
8448 break;
8449
8450 case 5200: hash_type = HASH_TYPE_SHA256;
8451 salt_type = SALT_TYPE_EMBEDDED;
8452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8454 kern_type = KERN_TYPE_PSAFE3;
8455 dgst_size = DGST_SIZE_4_8;
8456 parse_func = psafe3_parse_hash;
8457 sort_by_digest = sort_by_digest_4_8;
8458 opti_type = OPTI_TYPE_ZERO_BYTE;
8459 dgst_pos0 = 0;
8460 dgst_pos1 = 1;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 3;
8463 break;
8464
8465 case 5300: hash_type = HASH_TYPE_MD5;
8466 salt_type = SALT_TYPE_EMBEDDED;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_ST_ADD80;
8470 kern_type = KERN_TYPE_IKEPSK_MD5;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = ikepsk_md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 5400: hash_type = HASH_TYPE_SHA1;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_BE
8485 | OPTS_TYPE_ST_ADD80;
8486 kern_type = KERN_TYPE_IKEPSK_SHA1;
8487 dgst_size = DGST_SIZE_4_5;
8488 parse_func = ikepsk_sha1_parse_hash;
8489 sort_by_digest = sort_by_digest_4_5;
8490 opti_type = OPTI_TYPE_ZERO_BYTE;
8491 dgst_pos0 = 3;
8492 dgst_pos1 = 4;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 5500: hash_type = HASH_TYPE_NETNTLM;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_PT_ADD80
8502 | OPTS_TYPE_PT_ADDBITS14
8503 | OPTS_TYPE_PT_UNICODE
8504 | OPTS_TYPE_ST_HEX;
8505 kern_type = KERN_TYPE_NETNTLMv1;
8506 dgst_size = DGST_SIZE_4_4;
8507 parse_func = netntlmv1_parse_hash;
8508 sort_by_digest = sort_by_digest_4_4;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8511 dgst_pos0 = 0;
8512 dgst_pos1 = 1;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 3;
8515 break;
8516
8517 case 5600: hash_type = HASH_TYPE_MD5;
8518 salt_type = SALT_TYPE_EMBEDDED;
8519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520 opts_type = OPTS_TYPE_PT_GENERATE_LE
8521 | OPTS_TYPE_PT_ADD80
8522 | OPTS_TYPE_PT_ADDBITS14
8523 | OPTS_TYPE_PT_UNICODE;
8524 kern_type = KERN_TYPE_NETNTLMv2;
8525 dgst_size = DGST_SIZE_4_4;
8526 parse_func = netntlmv2_parse_hash;
8527 sort_by_digest = sort_by_digest_4_4;
8528 opti_type = OPTI_TYPE_ZERO_BYTE;
8529 dgst_pos0 = 0;
8530 dgst_pos1 = 3;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 1;
8533 break;
8534
8535 case 5700: hash_type = HASH_TYPE_SHA256;
8536 salt_type = SALT_TYPE_NONE;
8537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_BE
8539 | OPTS_TYPE_PT_ADD80
8540 | OPTS_TYPE_PT_ADDBITS15;
8541 kern_type = KERN_TYPE_SHA256;
8542 dgst_size = DGST_SIZE_4_8;
8543 parse_func = cisco4_parse_hash;
8544 sort_by_digest = sort_by_digest_4_8;
8545 opti_type = OPTI_TYPE_ZERO_BYTE
8546 | OPTI_TYPE_PRECOMPUTE_INIT
8547 | OPTI_TYPE_PRECOMPUTE_MERKLE
8548 | OPTI_TYPE_EARLY_SKIP
8549 | OPTI_TYPE_NOT_ITERATED
8550 | OPTI_TYPE_NOT_SALTED
8551 | OPTI_TYPE_RAW_HASH;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 7;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 6;
8556 break;
8557
8558 case 5800: hash_type = HASH_TYPE_SHA1;
8559 salt_type = SALT_TYPE_INTERN;
8560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8562 | OPTS_TYPE_ST_ADD80;
8563 kern_type = KERN_TYPE_ANDROIDPIN;
8564 dgst_size = DGST_SIZE_4_5;
8565 parse_func = androidpin_parse_hash;
8566 sort_by_digest = sort_by_digest_4_5;
8567 opti_type = OPTI_TYPE_ZERO_BYTE;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 1;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 3;
8572 break;
8573
8574 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8575 salt_type = SALT_TYPE_NONE;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADD80;
8579 kern_type = KERN_TYPE_RIPEMD160;
8580 dgst_size = DGST_SIZE_4_5;
8581 parse_func = ripemd160_parse_hash;
8582 sort_by_digest = sort_by_digest_4_5;
8583 opti_type = OPTI_TYPE_ZERO_BYTE;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 1;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 3;
8588 break;
8589
8590 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8591 salt_type = SALT_TYPE_NONE;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_BE
8594 | OPTS_TYPE_PT_ADD80;
8595 kern_type = KERN_TYPE_WHIRLPOOL;
8596 dgst_size = DGST_SIZE_4_16;
8597 parse_func = whirlpool_parse_hash;
8598 sort_by_digest = sort_by_digest_4_16;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 1;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 3;
8604 break;
8605
8606 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8610 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8611 dgst_size = DGST_SIZE_4_5;
8612 parse_func = truecrypt_parse_hash_2k;
8613 sort_by_digest = sort_by_digest_4_5;
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8625 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8626 dgst_size = DGST_SIZE_4_5;
8627 parse_func = truecrypt_parse_hash_2k;
8628 sort_by_digest = sort_by_digest_4_5;
8629 opti_type = OPTI_TYPE_ZERO_BYTE;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 1;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 3;
8634 break;
8635
8636 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8637 salt_type = SALT_TYPE_EMBEDDED;
8638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8640 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8641 dgst_size = DGST_SIZE_4_5;
8642 parse_func = truecrypt_parse_hash_2k;
8643 sort_by_digest = sort_by_digest_4_5;
8644 opti_type = OPTI_TYPE_ZERO_BYTE;
8645 dgst_pos0 = 0;
8646 dgst_pos1 = 1;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 3;
8649 break;
8650
8651 case 6221: hash_type = HASH_TYPE_SHA512;
8652 salt_type = SALT_TYPE_EMBEDDED;
8653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8655 kern_type = KERN_TYPE_TCSHA512_XTS512;
8656 dgst_size = DGST_SIZE_8_8;
8657 parse_func = truecrypt_parse_hash_1k;
8658 sort_by_digest = sort_by_digest_8_8;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_USES_BITS_64;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 6222: hash_type = HASH_TYPE_SHA512;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8671 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8672 dgst_size = DGST_SIZE_8_8;
8673 parse_func = truecrypt_parse_hash_1k;
8674 sort_by_digest = sort_by_digest_8_8;
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_USES_BITS_64;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6223: hash_type = HASH_TYPE_SHA512;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8688 dgst_size = DGST_SIZE_8_8;
8689 parse_func = truecrypt_parse_hash_1k;
8690 sort_by_digest = sort_by_digest_8_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_USES_BITS_64;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 1;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 3;
8697 break;
8698
8699 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8700 salt_type = SALT_TYPE_EMBEDDED;
8701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8703 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8704 dgst_size = DGST_SIZE_4_8;
8705 parse_func = truecrypt_parse_hash_1k;
8706 sort_by_digest = sort_by_digest_4_8;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8718 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8719 dgst_size = DGST_SIZE_4_8;
8720 parse_func = truecrypt_parse_hash_1k;
8721 sort_by_digest = sort_by_digest_4_8;
8722 opti_type = OPTI_TYPE_ZERO_BYTE;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 1;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 3;
8727 break;
8728
8729 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8730 salt_type = SALT_TYPE_EMBEDDED;
8731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8733 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8734 dgst_size = DGST_SIZE_4_8;
8735 parse_func = truecrypt_parse_hash_1k;
8736 sort_by_digest = sort_by_digest_4_8;
8737 opti_type = OPTI_TYPE_ZERO_BYTE;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8748 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = truecrypt_parse_hash_1k;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8763 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = truecrypt_parse_hash_1k;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8778 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8779 dgst_size = DGST_SIZE_4_5;
8780 parse_func = truecrypt_parse_hash_1k;
8781 sort_by_digest = sort_by_digest_4_5;
8782 opti_type = OPTI_TYPE_ZERO_BYTE;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 1;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 3;
8787 break;
8788
8789 case 6300: hash_type = HASH_TYPE_MD5;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8793 kern_type = KERN_TYPE_MD5AIX;
8794 dgst_size = DGST_SIZE_4_4;
8795 parse_func = md5aix_parse_hash;
8796 sort_by_digest = sort_by_digest_4_4;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 6400: hash_type = HASH_TYPE_SHA256;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8808 kern_type = KERN_TYPE_SHA256AIX;
8809 dgst_size = DGST_SIZE_4_8;
8810 parse_func = sha256aix_parse_hash;
8811 sort_by_digest = sort_by_digest_4_8;
8812 opti_type = OPTI_TYPE_ZERO_BYTE;
8813 dgst_pos0 = 0;
8814 dgst_pos1 = 1;
8815 dgst_pos2 = 2;
8816 dgst_pos3 = 3;
8817 break;
8818
8819 case 6500: hash_type = HASH_TYPE_SHA512;
8820 salt_type = SALT_TYPE_EMBEDDED;
8821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8822 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8823 kern_type = KERN_TYPE_SHA512AIX;
8824 dgst_size = DGST_SIZE_8_8;
8825 parse_func = sha512aix_parse_hash;
8826 sort_by_digest = sort_by_digest_8_8;
8827 opti_type = OPTI_TYPE_ZERO_BYTE
8828 | OPTI_TYPE_USES_BITS_64;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 1;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 3;
8833 break;
8834
8835 case 6600: hash_type = HASH_TYPE_AES;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8839 kern_type = KERN_TYPE_AGILEKEY;
8840 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8841 parse_func = agilekey_parse_hash;
8842 sort_by_digest = sort_by_digest_4_5;
8843 opti_type = OPTI_TYPE_ZERO_BYTE;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6700: hash_type = HASH_TYPE_SHA1;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8854 kern_type = KERN_TYPE_SHA1AIX;
8855 dgst_size = DGST_SIZE_4_5;
8856 parse_func = sha1aix_parse_hash;
8857 sort_by_digest = sort_by_digest_4_5;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6800: hash_type = HASH_TYPE_AES;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8869 kern_type = KERN_TYPE_LASTPASS;
8870 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8871 parse_func = lastpass_parse_hash;
8872 sort_by_digest = sort_by_digest_4_8;
8873 opti_type = OPTI_TYPE_ZERO_BYTE;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6900: hash_type = HASH_TYPE_GOST;
8881 salt_type = SALT_TYPE_NONE;
8882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_GOST;
8885 dgst_size = DGST_SIZE_4_8;
8886 parse_func = gost_parse_hash;
8887 sort_by_digest = sort_by_digest_4_8;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 7100: hash_type = HASH_TYPE_SHA512;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8899 kern_type = KERN_TYPE_PBKDF2_SHA512;
8900 dgst_size = DGST_SIZE_8_16;
8901 parse_func = sha512osx_parse_hash;
8902 sort_by_digest = sort_by_digest_8_16;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_USES_BITS_64;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 7200: hash_type = HASH_TYPE_SHA512;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8915 kern_type = KERN_TYPE_PBKDF2_SHA512;
8916 dgst_size = DGST_SIZE_8_16;
8917 parse_func = sha512grub_parse_hash;
8918 sort_by_digest = sort_by_digest_8_16;
8919 opti_type = OPTI_TYPE_ZERO_BYTE
8920 | OPTI_TYPE_USES_BITS_64;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 7300: hash_type = HASH_TYPE_SHA1;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_BE
8931 | OPTS_TYPE_ST_ADD80
8932 | OPTS_TYPE_ST_ADDBITS15;
8933 kern_type = KERN_TYPE_RAKP;
8934 dgst_size = DGST_SIZE_4_5;
8935 parse_func = rakp_parse_hash;
8936 sort_by_digest = sort_by_digest_4_5;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_NOT_ITERATED;
8939 dgst_pos0 = 3;
8940 dgst_pos1 = 4;
8941 dgst_pos2 = 2;
8942 dgst_pos3 = 1;
8943 break;
8944
8945 case 7400: hash_type = HASH_TYPE_SHA256;
8946 salt_type = SALT_TYPE_EMBEDDED;
8947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8948 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8949 kern_type = KERN_TYPE_SHA256CRYPT;
8950 dgst_size = DGST_SIZE_4_8;
8951 parse_func = sha256crypt_parse_hash;
8952 sort_by_digest = sort_by_digest_4_8;
8953 opti_type = OPTI_TYPE_ZERO_BYTE;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 1;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 3;
8958 break;
8959
8960 case 7500: hash_type = HASH_TYPE_KRB5PA;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8964 kern_type = KERN_TYPE_KRB5PA;
8965 dgst_size = DGST_SIZE_4_4;
8966 parse_func = krb5pa_parse_hash;
8967 sort_by_digest = sort_by_digest_4_4;
8968 opti_type = OPTI_TYPE_ZERO_BYTE
8969 | OPTI_TYPE_NOT_ITERATED;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 7600: hash_type = HASH_TYPE_SHA1;
8977 salt_type = SALT_TYPE_INTERN;
8978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_BE
8980 | OPTS_TYPE_PT_ADD80
8981 | OPTS_TYPE_PT_ADDBITS15;
8982 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8983 dgst_size = DGST_SIZE_4_5;
8984 parse_func = redmine_parse_hash;
8985 sort_by_digest = sort_by_digest_4_5;
8986 opti_type = OPTI_TYPE_ZERO_BYTE
8987 | OPTI_TYPE_PRECOMPUTE_INIT
8988 | OPTI_TYPE_EARLY_SKIP
8989 | OPTI_TYPE_NOT_ITERATED
8990 | OPTI_TYPE_PREPENDED_SALT;
8991 dgst_pos0 = 3;
8992 dgst_pos1 = 4;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 1;
8995 break;
8996
8997 case 7700: hash_type = HASH_TYPE_SAPB;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE
9001 | OPTS_TYPE_PT_UPPER
9002 | OPTS_TYPE_ST_UPPER;
9003 kern_type = KERN_TYPE_SAPB;
9004 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9005 parse_func = sapb_parse_hash;
9006 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9007 opti_type = OPTI_TYPE_ZERO_BYTE
9008 | OPTI_TYPE_PRECOMPUTE_INIT
9009 | OPTI_TYPE_NOT_ITERATED;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 7800: hash_type = HASH_TYPE_SAPG;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_BE
9020 | OPTS_TYPE_ST_ADD80
9021 | OPTS_TYPE_ST_UPPER;
9022 kern_type = KERN_TYPE_SAPG;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = sapg_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE
9027 | OPTI_TYPE_PRECOMPUTE_INIT
9028 | OPTI_TYPE_NOT_ITERATED;
9029 dgst_pos0 = 3;
9030 dgst_pos1 = 4;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 1;
9033 break;
9034
9035 case 7900: hash_type = HASH_TYPE_SHA512;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9039 kern_type = KERN_TYPE_DRUPAL7;
9040 dgst_size = DGST_SIZE_8_8;
9041 parse_func = drupal7_parse_hash;
9042 sort_by_digest = sort_by_digest_8_8;
9043 opti_type = OPTI_TYPE_ZERO_BYTE
9044 | OPTI_TYPE_USES_BITS_64;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 1;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 3;
9049 break;
9050
9051 case 8000: hash_type = HASH_TYPE_SHA256;
9052 salt_type = SALT_TYPE_EMBEDDED;
9053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9054 opts_type = OPTS_TYPE_PT_GENERATE_BE
9055 | OPTS_TYPE_PT_UNICODE
9056 | OPTS_TYPE_ST_ADD80
9057 | OPTS_TYPE_ST_HEX;
9058 kern_type = KERN_TYPE_SYBASEASE;
9059 dgst_size = DGST_SIZE_4_8;
9060 parse_func = sybasease_parse_hash;
9061 sort_by_digest = sort_by_digest_4_8;
9062 opti_type = OPTI_TYPE_ZERO_BYTE
9063 | OPTI_TYPE_PRECOMPUTE_INIT
9064 | OPTI_TYPE_EARLY_SKIP
9065 | OPTI_TYPE_NOT_ITERATED
9066 | OPTI_TYPE_RAW_HASH;
9067 dgst_pos0 = 3;
9068 dgst_pos1 = 7;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 6;
9071 break;
9072
9073 case 8100: hash_type = HASH_TYPE_SHA1;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9077 kern_type = KERN_TYPE_NETSCALER;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = netscaler_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_PRECOMPUTE_INIT
9083 | OPTI_TYPE_PRECOMPUTE_MERKLE
9084 | OPTI_TYPE_EARLY_SKIP
9085 | OPTI_TYPE_NOT_ITERATED
9086 | OPTI_TYPE_PREPENDED_SALT
9087 | OPTI_TYPE_RAW_HASH;
9088 dgst_pos0 = 3;
9089 dgst_pos1 = 4;
9090 dgst_pos2 = 2;
9091 dgst_pos3 = 1;
9092 break;
9093
9094 case 8200: hash_type = HASH_TYPE_SHA256;
9095 salt_type = SALT_TYPE_EMBEDDED;
9096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9098 kern_type = KERN_TYPE_CLOUDKEY;
9099 dgst_size = DGST_SIZE_4_8;
9100 parse_func = cloudkey_parse_hash;
9101 sort_by_digest = sort_by_digest_4_8;
9102 opti_type = OPTI_TYPE_ZERO_BYTE;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 8300: hash_type = HASH_TYPE_SHA1;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE
9113 | OPTS_TYPE_ST_HEX
9114 | OPTS_TYPE_ST_ADD80;
9115 kern_type = KERN_TYPE_NSEC3;
9116 dgst_size = DGST_SIZE_4_5;
9117 parse_func = nsec3_parse_hash;
9118 sort_by_digest = sort_by_digest_4_5;
9119 opti_type = OPTI_TYPE_ZERO_BYTE;
9120 dgst_pos0 = 3;
9121 dgst_pos1 = 4;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 1;
9124 break;
9125
9126 case 8400: hash_type = HASH_TYPE_SHA1;
9127 salt_type = SALT_TYPE_INTERN;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_BE
9130 | OPTS_TYPE_PT_ADD80
9131 | OPTS_TYPE_PT_ADDBITS15;
9132 kern_type = KERN_TYPE_WBB3;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = wbb3_parse_hash;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_PRECOMPUTE_INIT
9138 | OPTI_TYPE_NOT_ITERATED;
9139 dgst_pos0 = 3;
9140 dgst_pos1 = 4;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 1;
9143 break;
9144
9145 case 8500: hash_type = HASH_TYPE_DESRACF;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE
9149 | OPTS_TYPE_ST_UPPER;
9150 kern_type = KERN_TYPE_RACF;
9151 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9152 parse_func = racf_parse_hash;
9153 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9154 opti_type = OPTI_TYPE_ZERO_BYTE
9155 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 8600: hash_type = HASH_TYPE_LOTUS5;
9163 salt_type = SALT_TYPE_NONE;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_LOTUS5;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = lotus5_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_EARLY_SKIP
9171 | OPTI_TYPE_NOT_ITERATED
9172 | OPTI_TYPE_NOT_SALTED
9173 | OPTI_TYPE_RAW_HASH;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 8700: hash_type = HASH_TYPE_LOTUS6;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_LOTUS6;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = lotus6_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_EARLY_SKIP
9189 | OPTI_TYPE_NOT_ITERATED
9190 | OPTI_TYPE_RAW_HASH;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_ANDROIDFDE;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = androidfde_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 8900: hash_type = HASH_TYPE_SCRYPT;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9216 kern_type = KERN_TYPE_SCRYPT;
9217 dgst_size = DGST_SIZE_4_8;
9218 parse_func = scrypt_parse_hash;
9219 sort_by_digest = sort_by_digest_4_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 9000: hash_type = HASH_TYPE_SHA1;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE
9231 | OPTS_TYPE_ST_GENERATE_LE;
9232 kern_type = KERN_TYPE_PSAFE2;
9233 dgst_size = DGST_SIZE_4_5;
9234 parse_func = psafe2_parse_hash;
9235 sort_by_digest = sort_by_digest_4_5;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 9100: hash_type = HASH_TYPE_LOTUS8;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_LOTUS8;
9248 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9249 parse_func = lotus8_parse_hash;
9250 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 9200: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9262 kern_type = KERN_TYPE_PBKDF2_SHA256;
9263 dgst_size = DGST_SIZE_4_32;
9264 parse_func = cisco8_parse_hash;
9265 sort_by_digest = sort_by_digest_4_32;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 9300: hash_type = HASH_TYPE_SCRYPT;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_SCRYPT;
9278 dgst_size = DGST_SIZE_4_8;
9279 parse_func = cisco9_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9292 kern_type = KERN_TYPE_OFFICE2007;
9293 dgst_size = DGST_SIZE_4_4;
9294 parse_func = office2007_parse_hash;
9295 sort_by_digest = sort_by_digest_4_4;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9307 kern_type = KERN_TYPE_OFFICE2010;
9308 dgst_size = DGST_SIZE_4_4;
9309 parse_func = office2010_parse_hash;
9310 sort_by_digest = sort_by_digest_4_4;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_OFFICE2013;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = office2013_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE
9337 | OPTS_TYPE_PT_ADD80
9338 | OPTS_TYPE_PT_UNICODE;
9339 kern_type = KERN_TYPE_OLDOFFICE01;
9340 dgst_size = DGST_SIZE_4_4;
9341 parse_func = oldoffice01_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_PT_ADD80;
9357 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = oldoffice01cm1_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_NOT_ITERATED;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE
9374 | OPTS_TYPE_PT_ADD80
9375 | OPTS_TYPE_PT_UNICODE
9376 | OPTS_TYPE_PT_NEVERCRACK;
9377 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9378 dgst_size = DGST_SIZE_4_4;
9379 parse_func = oldoffice01cm2_parse_hash;
9380 sort_by_digest = sort_by_digest_4_4;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_PRECOMPUTE_INIT
9383 | OPTI_TYPE_NOT_ITERATED;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_BE
9394 | OPTS_TYPE_PT_ADD80
9395 | OPTS_TYPE_PT_UNICODE;
9396 kern_type = KERN_TYPE_OLDOFFICE34;
9397 dgst_size = DGST_SIZE_4_4;
9398 parse_func = oldoffice34_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4;
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_NOT_ITERATED;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = oldoffice34cm1_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_NOT_ITERATED;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_BE
9430 | OPTS_TYPE_PT_ADD80
9431 | OPTS_TYPE_PT_UNICODE
9432 | OPTS_TYPE_PT_NEVERCRACK;
9433 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9434 dgst_size = DGST_SIZE_4_4;
9435 parse_func = oldoffice34cm2_parse_hash;
9436 sort_by_digest = sort_by_digest_4_4;
9437 opti_type = OPTI_TYPE_ZERO_BYTE
9438 | OPTI_TYPE_PRECOMPUTE_INIT
9439 | OPTI_TYPE_NOT_ITERATED;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 9900: hash_type = HASH_TYPE_MD5;
9447 salt_type = SALT_TYPE_NONE;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9450 kern_type = KERN_TYPE_RADMIN2;
9451 dgst_size = DGST_SIZE_4_4;
9452 parse_func = radmin2_parse_hash;
9453 sort_by_digest = sort_by_digest_4_4;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_EARLY_SKIP
9457 | OPTI_TYPE_NOT_ITERATED
9458 | OPTI_TYPE_NOT_SALTED;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 3;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 1;
9463 break;
9464
9465 case 10000: hash_type = HASH_TYPE_SHA256;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9469 kern_type = KERN_TYPE_PBKDF2_SHA256;
9470 dgst_size = DGST_SIZE_4_32;
9471 parse_func = djangopbkdf2_parse_hash;
9472 sort_by_digest = sort_by_digest_4_32;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 10100: hash_type = HASH_TYPE_SIPHASH;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_SIPHASH;
9485 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9486 parse_func = siphash_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_NOT_ITERATED
9490 | OPTI_TYPE_RAW_HASH;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 10200: hash_type = HASH_TYPE_MD5;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE
9501 | OPTS_TYPE_ST_ADD80
9502 | OPTS_TYPE_ST_ADDBITS14;
9503 kern_type = KERN_TYPE_HMACMD5_PW;
9504 dgst_size = DGST_SIZE_4_4;
9505 parse_func = crammd5_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4;
9507 opti_type = OPTI_TYPE_ZERO_BYTE
9508 | OPTI_TYPE_NOT_ITERATED;
9509 dgst_pos0 = 0;
9510 dgst_pos1 = 3;
9511 dgst_pos2 = 2;
9512 dgst_pos3 = 1;
9513 break;
9514
9515 case 10300: hash_type = HASH_TYPE_SHA1;
9516 salt_type = SALT_TYPE_EMBEDDED;
9517 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9518 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9519 kern_type = KERN_TYPE_SAPH_SHA1;
9520 dgst_size = DGST_SIZE_4_5;
9521 parse_func = saph_sha1_parse_hash;
9522 sort_by_digest = sort_by_digest_4_5;
9523 opti_type = OPTI_TYPE_ZERO_BYTE;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 10400: hash_type = HASH_TYPE_PDFU16;
9531 salt_type = SALT_TYPE_EMBEDDED;
9532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9534 kern_type = KERN_TYPE_PDF11;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = pdf11_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_NOT_ITERATED;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 10410: hash_type = HASH_TYPE_PDFU16;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9550 kern_type = KERN_TYPE_PDF11CM1;
9551 dgst_size = DGST_SIZE_4_4;
9552 parse_func = pdf11cm1_parse_hash;
9553 sort_by_digest = sort_by_digest_4_4;
9554 opti_type = OPTI_TYPE_ZERO_BYTE
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 10420: hash_type = HASH_TYPE_PDFU16;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9566 kern_type = KERN_TYPE_PDF11CM2;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = pdf11cm2_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_NOT_ITERATED;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 10500: hash_type = HASH_TYPE_PDFU16;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9582 kern_type = KERN_TYPE_PDF14;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = pdf14_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_NOT_ITERATED;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 10600: hash_type = HASH_TYPE_SHA256;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_BE
9598 | OPTS_TYPE_ST_ADD80
9599 | OPTS_TYPE_ST_ADDBITS15
9600 | OPTS_TYPE_HASH_COPY;
9601 kern_type = KERN_TYPE_SHA256_PWSLT;
9602 dgst_size = DGST_SIZE_4_8;
9603 parse_func = pdf17l3_parse_hash;
9604 sort_by_digest = sort_by_digest_4_8;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_PRECOMPUTE_MERKLE
9608 | OPTI_TYPE_EARLY_SKIP
9609 | OPTI_TYPE_NOT_ITERATED
9610 | OPTI_TYPE_APPENDED_SALT
9611 | OPTI_TYPE_RAW_HASH;
9612 dgst_pos0 = 3;
9613 dgst_pos1 = 7;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 6;
9616 break;
9617
9618 case 10700: hash_type = HASH_TYPE_PDFU32;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE
9622 | OPTS_TYPE_HASH_COPY;
9623 kern_type = KERN_TYPE_PDF17L8;
9624 dgst_size = DGST_SIZE_4_8;
9625 parse_func = pdf17l8_parse_hash;
9626 sort_by_digest = sort_by_digest_4_8;
9627 opti_type = OPTI_TYPE_ZERO_BYTE
9628 | OPTI_TYPE_NOT_ITERATED;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 10800: hash_type = HASH_TYPE_SHA384;
9636 salt_type = SALT_TYPE_NONE;
9637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_BE
9639 | OPTS_TYPE_PT_ADD80
9640 | OPTS_TYPE_PT_ADDBITS15;
9641 kern_type = KERN_TYPE_SHA384;
9642 dgst_size = DGST_SIZE_8_8;
9643 parse_func = sha384_parse_hash;
9644 sort_by_digest = sort_by_digest_8_8;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_PRECOMPUTE_INIT
9647 | OPTI_TYPE_PRECOMPUTE_MERKLE
9648 | OPTI_TYPE_EARLY_SKIP
9649 | OPTI_TYPE_NOT_ITERATED
9650 | OPTI_TYPE_NOT_SALTED
9651 | OPTI_TYPE_USES_BITS_64
9652 | OPTI_TYPE_RAW_HASH;
9653 dgst_pos0 = 6;
9654 dgst_pos1 = 7;
9655 dgst_pos2 = 4;
9656 dgst_pos3 = 5;
9657 break;
9658
9659 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE
9663 | OPTS_TYPE_ST_BASE64
9664 | OPTS_TYPE_HASH_COPY;
9665 kern_type = KERN_TYPE_PBKDF2_SHA256;
9666 dgst_size = DGST_SIZE_4_32;
9667 parse_func = pbkdf2_sha256_parse_hash;
9668 sort_by_digest = sort_by_digest_4_32;
9669 opti_type = OPTI_TYPE_ZERO_BYTE;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 11000: hash_type = HASH_TYPE_MD5;
9677 salt_type = SALT_TYPE_INTERN;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE
9680 | OPTS_TYPE_PT_ADD80;
9681 kern_type = KERN_TYPE_PRESTASHOP;
9682 dgst_size = DGST_SIZE_4_4;
9683 parse_func = prestashop_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4;
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_PRECOMPUTE_INIT
9687 | OPTI_TYPE_NOT_ITERATED
9688 | OPTI_TYPE_PREPENDED_SALT;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 3;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 11100: hash_type = HASH_TYPE_MD5;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE
9699 | OPTS_TYPE_ST_ADD80;
9700 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = postgresql_auth_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_PRECOMPUTE_INIT
9706 | OPTI_TYPE_PRECOMPUTE_MERKLE
9707 | OPTI_TYPE_EARLY_SKIP;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 3;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 1;
9712 break;
9713
9714 case 11200: hash_type = HASH_TYPE_SHA1;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_BE
9718 | OPTS_TYPE_PT_ADD80
9719 | OPTS_TYPE_ST_HEX;
9720 kern_type = KERN_TYPE_MYSQL_AUTH;
9721 dgst_size = DGST_SIZE_4_5;
9722 parse_func = mysql_auth_parse_hash;
9723 sort_by_digest = sort_by_digest_4_5;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_EARLY_SKIP;
9726 dgst_pos0 = 3;
9727 dgst_pos1 = 4;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 1;
9730 break;
9731
9732 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE
9736 | OPTS_TYPE_ST_HEX
9737 | OPTS_TYPE_ST_ADD80;
9738 kern_type = KERN_TYPE_BITCOIN_WALLET;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = bitcoin_wallet_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 11400: hash_type = HASH_TYPE_MD5;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_HASH_COPY;
9755 kern_type = KERN_TYPE_SIP_AUTH;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = sip_auth_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 3;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 1;
9764 break;
9765
9766 case 11500: hash_type = HASH_TYPE_CRC32;
9767 salt_type = SALT_TYPE_INTERN;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_ST_GENERATE_LE
9771 | OPTS_TYPE_ST_HEX;
9772 kern_type = KERN_TYPE_CRC32;
9773 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9774 parse_func = crc32_parse_hash;
9775 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9776 opti_type = OPTI_TYPE_ZERO_BYTE;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 11600: hash_type = HASH_TYPE_AES;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE
9787 | OPTS_TYPE_PT_NEVERCRACK;
9788 kern_type = KERN_TYPE_SEVEN_ZIP;
9789 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9790 parse_func = seven_zip_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9792 opti_type = OPTI_TYPE_ZERO_BYTE;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9800 salt_type = SALT_TYPE_NONE;
9801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE
9803 | OPTS_TYPE_PT_ADD01;
9804 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9805 dgst_size = DGST_SIZE_4_8;
9806 parse_func = gost2012sbog_256_parse_hash;
9807 sort_by_digest = sort_by_digest_4_8;
9808 opti_type = OPTI_TYPE_ZERO_BYTE;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9816 salt_type = SALT_TYPE_NONE;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE
9819 | OPTS_TYPE_PT_ADD01;
9820 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9821 dgst_size = DGST_SIZE_4_16;
9822 parse_func = gost2012sbog_512_parse_hash;
9823 sort_by_digest = sort_by_digest_4_16;
9824 opti_type = OPTI_TYPE_ZERO_BYTE;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_LE
9835 | OPTS_TYPE_ST_BASE64
9836 | OPTS_TYPE_HASH_COPY;
9837 kern_type = KERN_TYPE_PBKDF2_MD5;
9838 dgst_size = DGST_SIZE_4_32;
9839 parse_func = pbkdf2_md5_parse_hash;
9840 sort_by_digest = sort_by_digest_4_32;
9841 opti_type = OPTI_TYPE_ZERO_BYTE;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 1;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 3;
9846 break;
9847
9848 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_BASE64
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PBKDF2_SHA1;
9855 dgst_size = DGST_SIZE_4_32;
9856 parse_func = pbkdf2_sha1_parse_hash;
9857 sort_by_digest = sort_by_digest_4_32;
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_ST_BASE64
9870 | OPTS_TYPE_HASH_COPY;
9871 kern_type = KERN_TYPE_PBKDF2_SHA512;
9872 dgst_size = DGST_SIZE_8_16;
9873 parse_func = pbkdf2_sha512_parse_hash;
9874 sort_by_digest = sort_by_digest_8_16;
9875 opti_type = OPTI_TYPE_ZERO_BYTE
9876 | OPTI_TYPE_USES_BITS_64;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9887 kern_type = KERN_TYPE_ECRYPTFS;
9888 dgst_size = DGST_SIZE_8_8;
9889 parse_func = ecryptfs_parse_hash;
9890 sort_by_digest = sort_by_digest_8_8;
9891 opti_type = OPTI_TYPE_ZERO_BYTE
9892 | OPTI_TYPE_USES_BITS_64;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 1;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 3;
9897 break;
9898
9899 case 12300: hash_type = HASH_TYPE_ORACLET;
9900 salt_type = SALT_TYPE_EMBEDDED;
9901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9903 kern_type = KERN_TYPE_ORACLET;
9904 dgst_size = DGST_SIZE_8_16;
9905 parse_func = oraclet_parse_hash;
9906 sort_by_digest = sort_by_digest_8_16;
9907 opti_type = OPTI_TYPE_ZERO_BYTE
9908 | OPTI_TYPE_USES_BITS_64;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 1;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 3;
9913 break;
9914
9915 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9919 kern_type = KERN_TYPE_BSDICRYPT;
9920 dgst_size = DGST_SIZE_4_4;
9921 parse_func = bsdicrypt_parse_hash;
9922 sort_by_digest = sort_by_digest_4_4;
9923 opti_type = OPTI_TYPE_ZERO_BYTE
9924 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 1;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 3;
9929 break;
9930
9931 case 12500: hash_type = HASH_TYPE_RAR3HP;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9935 kern_type = KERN_TYPE_RAR3;
9936 dgst_size = DGST_SIZE_4_4;
9937 parse_func = rar3hp_parse_hash;
9938 sort_by_digest = sort_by_digest_4_4;
9939 opti_type = OPTI_TYPE_ZERO_BYTE;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 12600: hash_type = HASH_TYPE_SHA256;
9947 salt_type = SALT_TYPE_INTERN;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_BE
9950 | OPTS_TYPE_PT_ADD80;
9951 kern_type = KERN_TYPE_CF10;
9952 dgst_size = DGST_SIZE_4_8;
9953 parse_func = cf10_parse_hash;
9954 sort_by_digest = sort_by_digest_4_8;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_PRECOMPUTE_INIT
9957 | OPTI_TYPE_EARLY_SKIP
9958 | OPTI_TYPE_NOT_ITERATED;
9959 dgst_pos0 = 3;
9960 dgst_pos1 = 7;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 6;
9963 break;
9964
9965 case 12700: hash_type = HASH_TYPE_AES;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE
9969 | OPTS_TYPE_HASH_COPY;
9970 kern_type = KERN_TYPE_MYWALLET;
9971 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9972 parse_func = mywallet_parse_hash;
9973 sort_by_digest = sort_by_digest_4_5;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9985 kern_type = KERN_TYPE_MS_DRSR;
9986 dgst_size = DGST_SIZE_4_8;
9987 parse_func = ms_drsr_parse_hash;
9988 sort_by_digest = sort_by_digest_4_8;
9989 opti_type = OPTI_TYPE_ZERO_BYTE;
9990 dgst_pos0 = 0;
9991 dgst_pos1 = 1;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 3;
9994 break;
9995
9996 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9997 salt_type = SALT_TYPE_EMBEDDED;
9998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10000 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10001 dgst_size = DGST_SIZE_4_8;
10002 parse_func = androidfde_samsung_parse_hash;
10003 sort_by_digest = sort_by_digest_4_8;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_RAR5;
10016 dgst_size = DGST_SIZE_4_4;
10017 parse_func = rar5_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 default: usage_mini_print (PROGNAME); return (-1);
10027 }
10028
10029 /**
10030 * transpose
10031 */
10032
10033 data.parse_func = parse_func;
10034
10035 /**
10036 * misc stuff
10037 */
10038
10039 if (hex_salt)
10040 {
10041 if (salt_type == SALT_TYPE_INTERN)
10042 {
10043 opts_type |= OPTS_TYPE_ST_HEX;
10044 }
10045 else
10046 {
10047 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10048
10049 return (-1);
10050 }
10051 }
10052
10053 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10054 | (salt_type == SALT_TYPE_EXTERN)
10055 | (salt_type == SALT_TYPE_EMBEDDED)
10056 | (salt_type == SALT_TYPE_VIRTUAL));
10057
10058 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10059
10060 data.hash_type = hash_type;
10061 data.attack_mode = attack_mode;
10062 data.attack_kern = attack_kern;
10063 data.attack_exec = attack_exec;
10064 data.kern_type = kern_type;
10065 data.opts_type = opts_type;
10066 data.dgst_size = dgst_size;
10067 data.salt_type = salt_type;
10068 data.isSalted = isSalted;
10069 data.sort_by_digest = sort_by_digest;
10070 data.dgst_pos0 = dgst_pos0;
10071 data.dgst_pos1 = dgst_pos1;
10072 data.dgst_pos2 = dgst_pos2;
10073 data.dgst_pos3 = dgst_pos3;
10074
10075 esalt_size = 0;
10076
10077 switch (hash_mode)
10078 {
10079 case 2500: esalt_size = sizeof (wpa_t); break;
10080 case 5300: esalt_size = sizeof (ikepsk_t); break;
10081 case 5400: esalt_size = sizeof (ikepsk_t); break;
10082 case 5500: esalt_size = sizeof (netntlm_t); break;
10083 case 5600: esalt_size = sizeof (netntlm_t); break;
10084 case 6211:
10085 case 6212:
10086 case 6213:
10087 case 6221:
10088 case 6222:
10089 case 6223:
10090 case 6231:
10091 case 6232:
10092 case 6233:
10093 case 6241:
10094 case 6242:
10095 case 6243: esalt_size = sizeof (tc_t); break;
10096 case 6600: esalt_size = sizeof (agilekey_t); break;
10097 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10098 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10099 case 7300: esalt_size = sizeof (rakp_t); break;
10100 case 7500: esalt_size = sizeof (krb5pa_t); break;
10101 case 8200: esalt_size = sizeof (cloudkey_t); break;
10102 case 8800: esalt_size = sizeof (androidfde_t); break;
10103 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10104 case 9400: esalt_size = sizeof (office2007_t); break;
10105 case 9500: esalt_size = sizeof (office2010_t); break;
10106 case 9600: esalt_size = sizeof (office2013_t); break;
10107 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10108 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10109 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10110 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10111 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10112 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10113 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10114 case 10200: esalt_size = sizeof (cram_md5_t); break;
10115 case 10400: esalt_size = sizeof (pdf_t); break;
10116 case 10410: esalt_size = sizeof (pdf_t); break;
10117 case 10420: esalt_size = sizeof (pdf_t); break;
10118 case 10500: esalt_size = sizeof (pdf_t); break;
10119 case 10600: esalt_size = sizeof (pdf_t); break;
10120 case 10700: esalt_size = sizeof (pdf_t); break;
10121 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10122 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10123 case 11400: esalt_size = sizeof (sip_t); break;
10124 case 11600: esalt_size = sizeof (seven_zip_t); break;
10125 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10126 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10127 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10128 case 13000: esalt_size = sizeof (rar5_t); break;
10129 }
10130
10131 data.esalt_size = esalt_size;
10132
10133 /**
10134 * choose dictionary parser
10135 */
10136
10137 if (hash_type == HASH_TYPE_LM)
10138 {
10139 get_next_word_func = get_next_word_lm;
10140 }
10141 else if (opts_type & OPTS_TYPE_PT_UPPER)
10142 {
10143 get_next_word_func = get_next_word_uc;
10144 }
10145 else
10146 {
10147 get_next_word_func = get_next_word_std;
10148 }
10149
10150 /**
10151 * dictstat
10152 */
10153
10154 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10155
10156 #ifdef _POSIX
10157 size_t dictstat_nmemb = 0;
10158 #endif
10159
10160 #ifdef _WIN
10161 uint dictstat_nmemb = 0;
10162 #endif
10163
10164 char dictstat[256] = { 0 };
10165
10166 FILE *dictstat_fp = NULL;
10167
10168 if (keyspace == 0)
10169 {
10170 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10171
10172 dictstat_fp = fopen (dictstat, "rb");
10173
10174 if (dictstat_fp)
10175 {
10176 #ifdef _POSIX
10177 struct stat tmpstat;
10178
10179 fstat (fileno (dictstat_fp), &tmpstat);
10180 #endif
10181
10182 #ifdef _WIN
10183 struct stat64 tmpstat;
10184
10185 _fstat64 (fileno (dictstat_fp), &tmpstat);
10186 #endif
10187
10188 if (tmpstat.st_mtime < COMPTIME)
10189 {
10190 /* with v0.15 the format changed so we have to ensure user is using a good version
10191 since there is no version-header in the dictstat file */
10192
10193 fclose (dictstat_fp);
10194
10195 unlink (dictstat);
10196 }
10197 else
10198 {
10199 while (!feof (dictstat_fp))
10200 {
10201 dictstat_t d;
10202
10203 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10204
10205 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10206
10207 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10208 {
10209 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10210
10211 return -1;
10212 }
10213 }
10214
10215 fclose (dictstat_fp);
10216 }
10217 }
10218 }
10219
10220 /**
10221 * potfile
10222 */
10223
10224 char potfile[256] = { 0 };
10225
10226 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10227
10228 data.pot_fp = NULL;
10229
10230 FILE *out_fp = NULL;
10231 FILE *pot_fp = NULL;
10232
10233 if (show == 1 || left == 1)
10234 {
10235 pot_fp = fopen (potfile, "rb");
10236
10237 if (pot_fp == NULL)
10238 {
10239 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10240
10241 return (-1);
10242 }
10243
10244 if (outfile != NULL)
10245 {
10246 if ((out_fp = fopen (outfile, "ab")) == NULL)
10247 {
10248 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10249
10250 fclose (pot_fp);
10251
10252 return (-1);
10253 }
10254 }
10255 else
10256 {
10257 out_fp = stdout;
10258 }
10259 }
10260 else
10261 {
10262 if (potfile_disable == 0)
10263 {
10264 pot_fp = fopen (potfile, "ab");
10265
10266 if (pot_fp == NULL)
10267 {
10268 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10269
10270 return (-1);
10271 }
10272
10273 data.pot_fp = pot_fp;
10274 }
10275 }
10276
10277 pot_t *pot = NULL;
10278
10279 uint pot_cnt = 0;
10280 uint pot_avail = 0;
10281
10282 if (show == 1 || left == 1)
10283 {
10284 SUPPRESS_OUTPUT = 1;
10285
10286 pot_avail = count_lines (pot_fp);
10287
10288 rewind (pot_fp);
10289
10290 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10291
10292 uint pot_hashes_avail = 0;
10293
10294 uint line_num = 0;
10295
10296 while (!feof (pot_fp))
10297 {
10298 line_num++;
10299
10300 char line_buf[BUFSIZ] = { 0 };
10301
10302 int line_len = fgetl (pot_fp, line_buf);
10303
10304 if (line_len == 0) continue;
10305
10306 char *plain_buf = line_buf + line_len;
10307
10308 pot_t *pot_ptr = &pot[pot_cnt];
10309
10310 hash_t *hashes_buf = &pot_ptr->hash;
10311
10312 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10313 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10314
10315 if (pot_cnt == pot_hashes_avail)
10316 {
10317 uint pos = 0;
10318
10319 for (pos = 0; pos < INCR_POT; pos++)
10320 {
10321 if ((pot_cnt + pos) >= pot_avail) break;
10322
10323 pot_t *tmp_pot = &pot[pot_cnt + pos];
10324
10325 hash_t *tmp_hash = &tmp_pot->hash;
10326
10327 tmp_hash->digest = mymalloc (dgst_size);
10328
10329 if (isSalted)
10330 {
10331 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10332 }
10333
10334 if (esalt_size)
10335 {
10336 tmp_hash->esalt = mymalloc (esalt_size);
10337 }
10338
10339 pot_hashes_avail++;
10340 }
10341 }
10342
10343 int plain_len = 0;
10344
10345 int parser_status;
10346
10347 int iter = MAX_CUT_TRIES;
10348
10349 do
10350 {
10351 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10352 {
10353 if (line_buf[i] == ':')
10354 {
10355 line_len--;
10356
10357 break;
10358 }
10359 }
10360
10361 if (data.hash_mode != 2500)
10362 {
10363 parser_status = parse_func (line_buf, line_len, hashes_buf);
10364 }
10365 else
10366 {
10367 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10368
10369 if (line_len > max_salt_size)
10370 {
10371 parser_status = PARSER_GLOBAL_LENGTH;
10372 }
10373 else
10374 {
10375 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10376
10377 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10378
10379 hashes_buf->salt->salt_len = line_len;
10380
10381 parser_status = PARSER_OK;
10382 }
10383 }
10384
10385 // if NOT parsed without error, we add the ":" to the plain
10386
10387 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10388 {
10389 plain_len++;
10390 plain_buf--;
10391 }
10392
10393 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10394
10395 if (parser_status < PARSER_GLOBAL_ZERO)
10396 {
10397 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10398
10399 continue;
10400 }
10401
10402 if (plain_len >= 255) continue;
10403
10404 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10405
10406 pot_ptr->plain_len = plain_len;
10407
10408 pot_cnt++;
10409 }
10410
10411 fclose (pot_fp);
10412
10413 SUPPRESS_OUTPUT = 0;
10414
10415 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10416 }
10417
10418 /**
10419 * kernel accel and loops auto adjustment
10420 */
10421
10422 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10423 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10424
10425 if (workload_profile == 1)
10426 {
10427 kernel_loops /= 8;
10428 kernel_accel /= 4;
10429
10430 if (kernel_loops == 0) kernel_loops = 8;
10431 if (kernel_accel == 0) kernel_accel = 2;
10432 }
10433 else if (workload_profile == 3)
10434 {
10435 kernel_loops *= 8;
10436 kernel_accel *= 4;
10437
10438 if (kernel_loops > 1024) kernel_loops = 1024;
10439 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10440 }
10441
10442 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10443
10444 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10445 {
10446 kernel_loops = 1024;
10447 }
10448
10449 if (hash_mode == 12500)
10450 {
10451 kernel_loops = ROUNDS_RAR3 / 16;
10452 }
10453
10454 data.kernel_accel = kernel_accel;
10455 data.kernel_loops = kernel_loops;
10456
10457 /**
10458 * word len
10459 */
10460
10461 uint pw_min = PW_MIN;
10462 uint pw_max = PW_MAX;
10463
10464 switch (hash_mode)
10465 {
10466 case 400: if (pw_max > 40) pw_max = 40;
10467 break;
10468 case 500: if (pw_max > 16) pw_max = 16;
10469 break;
10470 case 1500: if (pw_max > 8) pw_max = 8;
10471 break;
10472 case 1600: if (pw_max > 16) pw_max = 16;
10473 break;
10474 case 1800: if (pw_max > 16) pw_max = 16;
10475 break;
10476 case 2100: if (pw_max > 16) pw_max = 16;
10477 break;
10478 case 2500: if (pw_min < 8) pw_min = 8;
10479 break;
10480 case 3000: if (pw_max > 7) pw_max = 7;
10481 break;
10482 case 5200: if (pw_max > 24) pw_max = 24;
10483 break;
10484 case 5800: if (pw_max > 16) pw_max = 16;
10485 break;
10486 case 6300: if (pw_max > 16) pw_max = 16;
10487 break;
10488 case 7400: if (pw_max > 16) pw_max = 16;
10489 break;
10490 case 7900: if (pw_max > 48) pw_max = 48;
10491 break;
10492 case 8500: if (pw_max > 8) pw_max = 8;
10493 break;
10494 case 8600: if (pw_max > 16) pw_max = 16;
10495 break;
10496 case 9710: pw_min = 5;
10497 pw_max = 5;
10498 break;
10499 case 9810: pw_min = 5;
10500 pw_max = 5;
10501 break;
10502 case 10410: pw_min = 5;
10503 pw_max = 5;
10504 break;
10505 case 10300: if (pw_max < 3) pw_min = 3;
10506 if (pw_max > 40) pw_max = 40;
10507 break;
10508 case 10500: if (pw_max < 3) pw_min = 3;
10509 if (pw_max > 40) pw_max = 40;
10510 break;
10511 case 10700: if (pw_max > 16) pw_max = 16;
10512 break;
10513 case 11300: if (pw_max > 40) pw_max = 40;
10514 break;
10515 case 12500: if (pw_max > 20) pw_max = 20;
10516 break;
10517 case 12800: if (pw_max > 24) pw_max = 24;
10518 break;
10519 }
10520
10521 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10522 {
10523 switch (attack_kern)
10524 {
10525 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10526 break;
10527 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10528 break;
10529 }
10530 }
10531
10532 /**
10533 * charsets : keep them together for more easy maintainnce
10534 */
10535
10536 cs_t mp_sys[6] = { { { 0 }, 0 } };
10537 cs_t mp_usr[4] = { { { 0 }, 0 } };
10538
10539 mp_setup_sys (mp_sys);
10540
10541 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10542 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10543 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10544 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10545
10546 /**
10547 * load hashes, part I: find input mode, count hashes
10548 */
10549
10550 uint hashlist_mode = 0;
10551 uint hashlist_format = HLFMT_HASHCAT;
10552
10553 uint hashes_avail = 0;
10554
10555 if (benchmark == 0)
10556 {
10557 struct stat f;
10558
10559 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10560
10561 if ((hash_mode == 2500) ||
10562 (hash_mode == 5200) ||
10563 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10564 (hash_mode == 9000))
10565 {
10566 hashlist_mode = HL_MODE_ARG;
10567
10568 char *hashfile = myargv[optind];
10569
10570 data.hashfile = hashfile;
10571
10572 logfile_top_var_string ("target", hashfile);
10573 }
10574
10575 if (hashlist_mode == HL_MODE_ARG)
10576 {
10577 if (hash_mode == 2500)
10578 {
10579 struct stat st;
10580
10581 if (stat (data.hashfile, &st) == -1)
10582 {
10583 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10584
10585 return (-1);
10586 }
10587
10588 hashes_avail = st.st_size / sizeof (hccap_t);
10589 }
10590 else
10591 {
10592 hashes_avail = 1;
10593 }
10594 }
10595 else if (hashlist_mode == HL_MODE_FILE)
10596 {
10597 char *hashfile = myargv[optind];
10598
10599 data.hashfile = hashfile;
10600
10601 logfile_top_var_string ("target", hashfile);
10602
10603 FILE *fp = NULL;
10604
10605 if ((fp = fopen (hashfile, "rb")) == NULL)
10606 {
10607 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10608
10609 return (-1);
10610 }
10611
10612 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10613
10614 hashes_avail = count_lines (fp);
10615
10616 rewind (fp);
10617
10618 if (hashes_avail == 0)
10619 {
10620 log_error ("ERROR: hashfile is empty or corrupt");
10621
10622 fclose (fp);
10623
10624 return (-1);
10625 }
10626
10627 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10628
10629 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10630 {
10631 log_error ("ERROR: remove not supported in native hashfile-format mode");
10632
10633 fclose (fp);
10634
10635 return (-1);
10636 }
10637
10638 fclose (fp);
10639 }
10640 }
10641 else
10642 {
10643 hashlist_mode = HL_MODE_ARG;
10644
10645 hashes_avail = 1;
10646 }
10647
10648 if (hash_mode == 3000) hashes_avail *= 2;
10649
10650 data.hashlist_mode = hashlist_mode;
10651 data.hashlist_format = hashlist_format;
10652
10653 logfile_top_uint (hashlist_mode);
10654 logfile_top_uint (hashlist_format);
10655
10656 /**
10657 * load hashes, part II: allocate required memory, set pointers
10658 */
10659
10660 hash_t *hashes_buf = NULL;
10661 void *digests_buf = NULL;
10662 salt_t *salts_buf = NULL;
10663 void *esalts_buf = NULL;
10664
10665 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10666
10667 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10668
10669 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10670 {
10671 u32 hash_pos;
10672
10673 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10674 {
10675 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10676
10677 hashes_buf[hash_pos].hash_info = hash_info;
10678
10679 if (username && (remove || show || left))
10680 {
10681 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10682 }
10683
10684 if (benchmark)
10685 {
10686 hash_info->orighash = (char *) mymalloc (256);
10687 }
10688 }
10689 }
10690
10691 if (isSalted)
10692 {
10693 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10694
10695 if (esalt_size)
10696 {
10697 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10698 }
10699 }
10700 else
10701 {
10702 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10703 }
10704
10705 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10706 {
10707 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10708
10709 if (isSalted)
10710 {
10711 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10712
10713 if (esalt_size)
10714 {
10715 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10716 }
10717 }
10718 else
10719 {
10720 hashes_buf[hash_pos].salt = &salts_buf[0];
10721 }
10722 }
10723
10724 /**
10725 * load hashes, part III: parse hashes or generate them if benchmark
10726 */
10727
10728 uint hashes_cnt = 0;
10729
10730 if (benchmark == 0)
10731 {
10732 if (keyspace == 1)
10733 {
10734 // useless to read hash file for keyspace, cheat a little bit w/ optind
10735 }
10736 else if (hashes_avail == 0)
10737 {
10738 }
10739 else if (hashlist_mode == HL_MODE_ARG)
10740 {
10741 char *input_buf = myargv[optind];
10742
10743 uint input_len = strlen (input_buf);
10744
10745 logfile_top_var_string ("target", input_buf);
10746
10747 char *hash_buf = NULL;
10748 int hash_len = 0;
10749
10750 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10751
10752 if (hash_len)
10753 {
10754 if (opts_type & OPTS_TYPE_HASH_COPY)
10755 {
10756 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10757
10758 hash_info_tmp->orighash = mystrdup (hash_buf);
10759 }
10760
10761 if (isSalted)
10762 {
10763 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10764 }
10765
10766 int parser_status = PARSER_OK;
10767
10768 if (hash_mode == 2500)
10769 {
10770 if (hash_len == 0)
10771 {
10772 log_error ("ERROR: hccap file not specified");
10773
10774 return (-1);
10775 }
10776
10777 hashlist_mode = HL_MODE_FILE;
10778
10779 data.hashlist_mode = hashlist_mode;
10780
10781 FILE *fp = fopen (hash_buf, "rb");
10782
10783 if (fp == NULL)
10784 {
10785 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10786
10787 return (-1);
10788 }
10789
10790 if (hashes_avail < 1)
10791 {
10792 log_error ("ERROR: hccap file is empty or corrupt");
10793
10794 fclose (fp);
10795
10796 return (-1);
10797 }
10798
10799 uint hccap_size = sizeof (hccap_t);
10800
10801 char *in = (char *) mymalloc (hccap_size);
10802
10803 while (!feof (fp))
10804 {
10805 int n = fread (in, hccap_size, 1, fp);
10806
10807 if (n != 1)
10808 {
10809 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10810
10811 break;
10812 }
10813
10814 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10815
10816 if (parser_status != PARSER_OK)
10817 {
10818 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10819
10820 continue;
10821 }
10822
10823 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10824
10825 if ((show == 1) || (left == 1))
10826 {
10827 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10828
10829 char *salt_ptr = (char *) tmp_salt->salt_buf;
10830
10831 int cur_pos = tmp_salt->salt_len;
10832 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10833
10834 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10835
10836 u8 *pke_ptr = (u8 *) wpa->pke;
10837
10838 // do the appending task
10839
10840 snprintf (salt_ptr + cur_pos,
10841 rem_len,
10842 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10843 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10844 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10845
10846
10847 // memset () the remaining part of the salt
10848
10849 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10850 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10851
10852 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10853
10854 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10855 }
10856
10857 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10858 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10859
10860 hashes_cnt++;
10861 }
10862
10863 fclose (fp);
10864
10865 myfree (in);
10866 }
10867 else if (hash_mode == 3000)
10868 {
10869 if (hash_len == 32)
10870 {
10871 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10872
10873 hash_t *lm_hash_left = NULL;
10874
10875 if (parser_status == PARSER_OK)
10876 {
10877 lm_hash_left = &hashes_buf[hashes_cnt];
10878
10879 hashes_cnt++;
10880 }
10881 else
10882 {
10883 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10884 }
10885
10886 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10887
10888 hash_t *lm_hash_right = NULL;
10889
10890 if (parser_status == PARSER_OK)
10891 {
10892 lm_hash_right = &hashes_buf[hashes_cnt];
10893
10894 hashes_cnt++;
10895 }
10896 else
10897 {
10898 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10899 }
10900
10901 // show / left
10902
10903 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10904 {
10905 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10906 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10907 }
10908 }
10909 else
10910 {
10911 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10912
10913 if (parser_status == PARSER_OK)
10914 {
10915 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10916 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10917 }
10918
10919 if (parser_status == PARSER_OK)
10920 {
10921 hashes_cnt++;
10922 }
10923 else
10924 {
10925 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10926 }
10927 }
10928 }
10929 else
10930 {
10931 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10932
10933 if (parser_status == PARSER_OK)
10934 {
10935 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10936 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10937 }
10938
10939 if (parser_status == PARSER_OK)
10940 {
10941 hashes_cnt++;
10942 }
10943 else
10944 {
10945 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10946 }
10947 }
10948 }
10949 }
10950 else if (hashlist_mode == HL_MODE_FILE)
10951 {
10952 char *hashfile = data.hashfile;
10953
10954 FILE *fp;
10955
10956 if ((fp = fopen (hashfile, "rb")) == NULL)
10957 {
10958 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10959
10960 return (-1);
10961 }
10962
10963 uint line_num = 0;
10964
10965 while (!feof (fp))
10966 {
10967 line_num++;
10968
10969 char line_buf[BUFSIZ] = { 0 };
10970
10971 int line_len = fgetl (fp, line_buf);
10972
10973 if (line_len == 0) continue;
10974
10975 char *hash_buf = NULL;
10976 int hash_len = 0;
10977
10978 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10979
10980 if (username)
10981 {
10982 char *user_buf = NULL;
10983 int user_len = 0;
10984
10985 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10986
10987 if (remove || show)
10988 {
10989 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10990
10991 *user = (user_t *) mymalloc (sizeof (user_t));
10992
10993 user_t *user_ptr = *user;
10994
10995 if (user_buf != NULL)
10996 {
10997 user_ptr->user_name = mystrdup (user_buf);
10998 }
10999 else
11000 {
11001 user_ptr->user_name = mystrdup ("");
11002 }
11003
11004 user_ptr->user_len = user_len;
11005 }
11006 }
11007
11008 if (opts_type & OPTS_TYPE_HASH_COPY)
11009 {
11010 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11011
11012 hash_info_tmp->orighash = mystrdup (hash_buf);
11013 }
11014
11015 if (isSalted)
11016 {
11017 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11018 }
11019
11020 if (hash_mode == 3000)
11021 {
11022 if (hash_len == 32)
11023 {
11024 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11025
11026 if (parser_status < PARSER_GLOBAL_ZERO)
11027 {
11028 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11029
11030 continue;
11031 }
11032
11033 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11034
11035 hashes_cnt++;
11036
11037 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11038
11039 if (parser_status < PARSER_GLOBAL_ZERO)
11040 {
11041 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11042
11043 continue;
11044 }
11045
11046 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11047
11048 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11049
11050 hashes_cnt++;
11051
11052 // show / left
11053
11054 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11055 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11056 }
11057 else
11058 {
11059 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11060
11061 if (parser_status < PARSER_GLOBAL_ZERO)
11062 {
11063 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11064
11065 continue;
11066 }
11067
11068 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11069
11070 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11071 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11072
11073 hashes_cnt++;
11074 }
11075 }
11076 else
11077 {
11078 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11079
11080 if (parser_status < PARSER_GLOBAL_ZERO)
11081 {
11082 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11083
11084 continue;
11085 }
11086
11087 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11088
11089 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11090 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11091
11092 hashes_cnt++;
11093 }
11094 }
11095
11096 fclose (fp);
11097
11098 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11099
11100 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11101 }
11102 }
11103 else
11104 {
11105 if (isSalted)
11106 {
11107 hashes_buf[0].salt->salt_len = 8;
11108
11109 // special salt handling
11110
11111 switch (hash_mode)
11112 {
11113 case 1500: hashes_buf[0].salt->salt_len = 2;
11114 break;
11115 case 1731: hashes_buf[0].salt->salt_len = 4;
11116 break;
11117 case 2410: hashes_buf[0].salt->salt_len = 4;
11118 break;
11119 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11120 break;
11121 case 3100: hashes_buf[0].salt->salt_len = 1;
11122 break;
11123 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11124 break;
11125 case 5800: hashes_buf[0].salt->salt_len = 16;
11126 break;
11127 case 6800: hashes_buf[0].salt->salt_len = 32;
11128 break;
11129 case 8400: hashes_buf[0].salt->salt_len = 40;
11130 break;
11131 case 8800: hashes_buf[0].salt->salt_len = 16;
11132 break;
11133 case 8900: hashes_buf[0].salt->salt_len = 16;
11134 hashes_buf[0].salt->scrypt_N = 1024;
11135 hashes_buf[0].salt->scrypt_r = 1;
11136 hashes_buf[0].salt->scrypt_p = 1;
11137 break;
11138 case 9100: hashes_buf[0].salt->salt_len = 16;
11139 break;
11140 case 9300: hashes_buf[0].salt->salt_len = 14;
11141 hashes_buf[0].salt->scrypt_N = 16384;
11142 hashes_buf[0].salt->scrypt_r = 1;
11143 hashes_buf[0].salt->scrypt_p = 1;
11144 break;
11145 case 9400: hashes_buf[0].salt->salt_len = 16;
11146 break;
11147 case 9500: hashes_buf[0].salt->salt_len = 16;
11148 break;
11149 case 9600: hashes_buf[0].salt->salt_len = 16;
11150 break;
11151 case 9700: hashes_buf[0].salt->salt_len = 16;
11152 break;
11153 case 9710: hashes_buf[0].salt->salt_len = 16;
11154 break;
11155 case 9720: hashes_buf[0].salt->salt_len = 16;
11156 break;
11157 case 9800: hashes_buf[0].salt->salt_len = 16;
11158 break;
11159 case 9810: hashes_buf[0].salt->salt_len = 16;
11160 break;
11161 case 9820: hashes_buf[0].salt->salt_len = 16;
11162 break;
11163 case 10300: hashes_buf[0].salt->salt_len = 12;
11164 break;
11165 case 11500: hashes_buf[0].salt->salt_len = 4;
11166 break;
11167 case 11600: hashes_buf[0].salt->salt_len = 4;
11168 break;
11169 case 12400: hashes_buf[0].salt->salt_len = 4;
11170 break;
11171 case 12500: hashes_buf[0].salt->salt_len = 8;
11172 break;
11173 case 12600: hashes_buf[0].salt->salt_len = 64;
11174 break;
11175 }
11176
11177 // special esalt handling
11178
11179 switch (hash_mode)
11180 {
11181 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11182 break;
11183 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11184 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11185 break;
11186 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11187 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11188 break;
11189 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11190 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11191 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11192 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11193 break;
11194 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11195 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11196 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11197 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11198 break;
11199 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11200 break;
11201 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11202 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11203 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11204 break;
11205 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11206 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11207 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11208 break;
11209 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11210 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11211 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11212 break;
11213 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11214 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11215 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11216 break;
11217 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11218 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11219 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11220 break;
11221 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11222 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11223 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11224 break;
11225 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11226 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11227 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11228 break;
11229 }
11230 }
11231
11232 // set hashfile
11233
11234 switch (hash_mode)
11235 {
11236 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11237 break;
11238 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11239 break;
11240 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11241 break;
11242 case 6211:
11243 case 6212:
11244 case 6213:
11245 case 6221:
11246 case 6222:
11247 case 6223:
11248 case 6231:
11249 case 6232:
11250 case 6233:
11251 case 6241:
11252 case 6242:
11253 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11254 break;
11255 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11256 break;
11257 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11258 break;
11259 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11260 break;
11261 }
11262
11263 // set default iterations
11264
11265 switch (hash_mode)
11266 {
11267 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11268 break;
11269 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11270 break;
11271 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11272 break;
11273 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11274 break;
11275 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11276 break;
11277 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11278 break;
11279 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11280 break;
11281 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11282 break;
11283 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11284 break;
11285 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11286 break;
11287 case 6211:
11288 case 6212:
11289 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11290 break;
11291 case 6221:
11292 case 6222:
11293 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11294 break;
11295 case 6231:
11296 case 6232:
11297 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11298 break;
11299 case 6241:
11300 case 6242:
11301 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11302 break;
11303 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11304 break;
11305 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11306 break;
11307 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11308 break;
11309 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11310 break;
11311 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11312 break;
11313 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11314 break;
11315 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11316 break;
11317 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11318 break;
11319 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11320 break;
11321 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11322 break;
11323 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11324 break;
11325 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11326 break;
11327 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11328 break;
11329 case 8900: hashes_buf[0].salt->salt_iter = 1;
11330 break;
11331 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11332 break;
11333 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11334 break;
11335 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11336 break;
11337 case 9300: hashes_buf[0].salt->salt_iter = 1;
11338 break;
11339 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11340 break;
11341 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11342 break;
11343 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11344 break;
11345 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11346 break;
11347 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11348 break;
11349 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11350 break;
11351 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11352 break;
11353 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11354 break;
11355 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11356 break;
11357 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11358 break;
11359 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11360 break;
11361 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11362 break;
11363 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11364 break;
11365 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11366 break;
11367 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11368 break;
11369 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11370 break;
11371 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11372 break;
11373 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11374 break;
11375 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11376 break;
11377 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11378 break;
11379 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11380 break;
11381 }
11382
11383 // set special tuning for benchmark-mode 1
11384
11385 if (benchmark_mode == 1)
11386 {
11387 kernel_loops *= 8;
11388 kernel_accel *= 4;
11389
11390 switch (hash_mode)
11391 {
11392 case 400: kernel_loops = ROUNDS_PHPASS;
11393 kernel_accel = 32;
11394 break;
11395 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11396 kernel_accel = 32;
11397 break;
11398 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11399 kernel_accel = 32;
11400 break;
11401 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11402 kernel_accel = 32;
11403 break;
11404 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11405 #ifndef OSX
11406 kernel_accel = 16;
11407 #endif
11408 break;
11409 case 2100: kernel_loops = ROUNDS_DCC2;
11410 kernel_accel = 16;
11411 break;
11412 case 2500: kernel_loops = ROUNDS_WPA2;
11413 #ifndef OSX
11414 kernel_accel = 32;
11415 #endif
11416 break;
11417 case 3200:
11418 #ifndef OSX
11419 kernel_loops = ROUNDS_BCRYPT;
11420 kernel_accel = 8;
11421 #else
11422 kernel_loops = ROUNDS_BCRYPT / 2;
11423 #endif
11424 break;
11425 case 5200: kernel_loops = ROUNDS_PSAFE3;
11426 kernel_accel = 16;
11427 break;
11428 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11429 kernel_accel = 16;
11430 break;
11431 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11432 #ifndef OSX
11433 kernel_accel = 64;
11434 #endif
11435 break;
11436 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11437 kernel_accel = 32;
11438 break;
11439 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11440 kernel_accel = 32;
11441 break;
11442 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11443 kernel_accel = 8;
11444 break;
11445 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11446 kernel_accel = 8;
11447 break;
11448 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11449 kernel_accel = 8;
11450 break;
11451 case 6231:
11452 #ifndef OSX
11453 kernel_loops = ROUNDS_TRUECRYPT_1K;
11454 kernel_accel = 8;
11455 #else
11456 kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
11457 kernel_accel = 1;
11458 #endif
11459 break;
11460 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11461 kernel_accel = 8;
11462 break;
11463 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11464 kernel_accel = 8;
11465 break;
11466 case 6241:
11467 #ifndef OSX
11468 kernel_loops = ROUNDS_TRUECRYPT_1K;
11469 kernel_accel = 128;
11470 #else
11471 kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
11472 kernel_accel = 1;
11473 #endif
11474 break;
11475 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11476 kernel_accel = 64;
11477 break;
11478 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11479 kernel_accel = 64;
11480 break;
11481 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11482 kernel_accel = 32;
11483 break;
11484 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11485 kernel_accel = 128;
11486 break;
11487 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11488 kernel_accel = 128;
11489 break;
11490 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11491 kernel_accel = 32;
11492 break;
11493 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11494 kernel_accel = 64;
11495 break;
11496 case 6800: kernel_loops = ROUNDS_LASTPASS;
11497 #ifndef OSX
11498 kernel_accel = 64;
11499 #endif
11500 break;
11501 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11502 #ifndef OSX
11503 kernel_accel = 8;
11504 #else
11505 kernel_accel = 1;
11506 #endif
11507 break;
11508 case 7200: kernel_loops = ROUNDS_GRUB;
11509 #ifndef OSX
11510 kernel_accel = 16;
11511 #else
11512 kernel_accel = 2;
11513 #endif
11514 break;
11515 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11516 kernel_accel = 8;
11517 break;
11518 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11519 #ifndef OSX
11520 kernel_accel = 8;
11521 #endif
11522 break;
11523 case 8200:
11524 #ifndef OSX
11525 kernel_loops = ROUNDS_CLOUDKEY;
11526 kernel_accel = 8;
11527 #else
11528 kernel_accel = 1;
11529 #endif
11530 break;
11531 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11532 kernel_accel = 32;
11533 break;
11534 case 8900: kernel_loops = 1;
11535 kernel_accel = 64;
11536 break;
11537 case 9000: kernel_loops = ROUNDS_PSAFE2;
11538 kernel_accel = 16;
11539 break;
11540 case 9100: kernel_loops = ROUNDS_LOTUS8;
11541 #ifndef OSX
11542 kernel_accel = 64;
11543 #endif
11544 break;
11545 case 9200: kernel_loops = ROUNDS_CISCO8;
11546 #ifndef OSX
11547 kernel_accel = 8;
11548 #endif
11549 break;
11550 case 9300: kernel_loops = 1;
11551 #ifndef OSX
11552 kernel_accel = 4;
11553 #else
11554 kernel_accel = 2;
11555 #endif
11556 break;
11557 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11558 #ifndef OSX
11559 kernel_accel = 32;
11560 #endif
11561 break;
11562 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11563 #ifndef OSX
11564 kernel_accel = 32;
11565 #endif
11566 break;
11567 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11568 #ifndef OSX
11569 kernel_accel = 8;
11570 #else
11571 kernel_accel = 1;
11572 #endif
11573 break;
11574 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11575 #ifndef OSX
11576 kernel_accel = 8;
11577 #endif
11578 break;
11579 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11580 kernel_accel = 16;
11581 break;
11582 case 10500: kernel_loops = ROUNDS_PDF14;
11583 kernel_accel = 256;
11584 break;
11585 case 10700: kernel_loops = ROUNDS_PDF17L8;
11586 kernel_accel = 8;
11587 break;
11588 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11589 kernel_accel = 8;
11590 break;
11591 case 11300:
11592 #ifndef OSX
11593 kernel_loops = ROUNDS_BITCOIN_WALLET;
11594 kernel_accel = 8;
11595 #else
11596 kernel_accel = 1;
11597 #endif
11598 break;
11599 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11600 #ifndef OSX
11601 kernel_accel = 8;
11602 #else
11603 kernel_accel = 1;
11604 #endif
11605 break;
11606 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11607 kernel_accel = 8;
11608 break;
11609 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11610 kernel_accel = 8;
11611 break;
11612 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11613 kernel_accel = 8;
11614 break;
11615 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11616 #ifndef OSX
11617 kernel_accel = 8;
11618 #else
11619 kernel_accel = 1;
11620 #endif
11621 break;
11622 case 12300: kernel_loops = ROUNDS_ORACLET;
11623 kernel_accel = 8;
11624 break;
11625 case 12500: kernel_loops = ROUNDS_RAR3;
11626 #ifndef OSX
11627 kernel_accel = 32;
11628 #endif
11629 break;
11630 case 12700: kernel_loops = ROUNDS_MYWALLET;
11631 kernel_accel = 512;
11632 break;
11633 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11634 kernel_accel = 512;
11635 break;
11636 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11637 kernel_accel = 8;
11638 break;
11639 case 13000: kernel_loops = ROUNDS_RAR5;
11640 #ifndef OSX
11641 kernel_accel = 8;
11642 #else
11643 kernel_accel = 2;
11644 #endif
11645 break;
11646 }
11647
11648 // some algorithm collide too fast, make that impossible
11649
11650 switch (hash_mode)
11651 {
11652 case 11500: ((uint *) digests_buf)[1] = 1;
11653 break;
11654 }
11655
11656 if (kernel_loops > 1024) kernel_loops = 1024;
11657 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11658 }
11659
11660 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11661 {
11662 kernel_loops = 1024;
11663 }
11664
11665 if (hash_mode == 12500)
11666 {
11667 kernel_loops = ROUNDS_RAR3 / 16;
11668 }
11669
11670 data.kernel_accel = kernel_accel;
11671 data.kernel_loops = kernel_loops;
11672
11673 hashes_cnt = 1;
11674 }
11675
11676 if (show == 1 || left == 1)
11677 {
11678 for (uint i = 0; i < pot_cnt; i++)
11679 {
11680 pot_t *pot_ptr = &pot[i];
11681
11682 hash_t *hashes_buf = &pot_ptr->hash;
11683
11684 local_free (hashes_buf->digest);
11685
11686 if (isSalted)
11687 {
11688 local_free (hashes_buf->salt);
11689 }
11690 }
11691
11692 local_free (pot);
11693
11694 if (data.quiet == 0) log_info_nn ("");
11695
11696 return (0);
11697 }
11698
11699 if (keyspace == 0)
11700 {
11701 if (hashes_cnt == 0)
11702 {
11703 log_error ("ERROR: No hashes loaded");
11704
11705 return (-1);
11706 }
11707 }
11708
11709 /**
11710 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11711 */
11712
11713 if (data.outfile != NULL)
11714 {
11715 if (data.hashfile != NULL)
11716 {
11717 #ifdef _POSIX
11718 struct stat tmpstat_outfile;
11719 struct stat tmpstat_hashfile;
11720 #endif
11721
11722 #ifdef _WIN
11723 struct stat64 tmpstat_outfile;
11724 struct stat64 tmpstat_hashfile;
11725 #endif
11726
11727 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11728
11729 if (tmp_outfile_fp)
11730 {
11731 #ifdef _POSIX
11732 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11733 #endif
11734
11735 #ifdef _WIN
11736 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11737 #endif
11738
11739 fclose (tmp_outfile_fp);
11740 }
11741
11742 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11743
11744 if (tmp_hashfile_fp)
11745 {
11746 #ifdef _POSIX
11747 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11748 #endif
11749
11750 #ifdef _WIN
11751 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11752 #endif
11753
11754 fclose (tmp_hashfile_fp);
11755 }
11756
11757 if (tmp_outfile_fp && tmp_outfile_fp)
11758 {
11759 tmpstat_outfile.st_mode = 0;
11760 tmpstat_outfile.st_nlink = 0;
11761 tmpstat_outfile.st_uid = 0;
11762 tmpstat_outfile.st_gid = 0;
11763 tmpstat_outfile.st_rdev = 0;
11764 tmpstat_outfile.st_atime = 0;
11765
11766 tmpstat_hashfile.st_mode = 0;
11767 tmpstat_hashfile.st_nlink = 0;
11768 tmpstat_hashfile.st_uid = 0;
11769 tmpstat_hashfile.st_gid = 0;
11770 tmpstat_hashfile.st_rdev = 0;
11771 tmpstat_hashfile.st_atime = 0;
11772
11773 #ifdef _POSIX
11774 tmpstat_outfile.st_blksize = 0;
11775 tmpstat_outfile.st_blocks = 0;
11776
11777 tmpstat_hashfile.st_blksize = 0;
11778 tmpstat_hashfile.st_blocks = 0;
11779 #endif
11780
11781 #ifdef _POSIX
11782 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11783 {
11784 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11785
11786 return (-1);
11787 }
11788 #endif
11789
11790 #ifdef _WIN
11791 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11792 {
11793 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11794
11795 return (-1);
11796 }
11797 #endif
11798 }
11799 }
11800 }
11801
11802 /**
11803 * Remove duplicates
11804 */
11805
11806 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11807
11808 if (isSalted)
11809 {
11810 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11811 }
11812 else
11813 {
11814 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11815 }
11816
11817 uint hashes_cnt_orig = hashes_cnt;
11818
11819 hashes_cnt = 1;
11820
11821 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11822 {
11823 if (isSalted)
11824 {
11825 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11826 {
11827 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11828 }
11829 }
11830 else
11831 {
11832 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11833 }
11834
11835 if (hashes_pos > hashes_cnt)
11836 {
11837 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11838 }
11839
11840 hashes_cnt++;
11841 }
11842
11843 /**
11844 * Potfile removes
11845 */
11846
11847 uint potfile_remove_cracks = 0;
11848
11849 if (potfile_disable == 0)
11850 {
11851 hash_t hash_buf;
11852
11853 hash_buf.digest = mymalloc (dgst_size);
11854 hash_buf.salt = NULL;
11855 hash_buf.esalt = NULL;
11856 hash_buf.hash_info = NULL;
11857 hash_buf.cracked = 0;
11858
11859 if (isSalted)
11860 {
11861 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11862 }
11863
11864 if (esalt_size)
11865 {
11866 hash_buf.esalt = mymalloc (esalt_size);
11867 }
11868
11869 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11870
11871 // no solution for these special hash types (for instane because they use hashfile in output etc)
11872 if ((hash_mode != 5200) &&
11873 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11874 (hash_mode != 9000))
11875 {
11876 FILE *fp = fopen (potfile, "rb");
11877
11878 if (fp != NULL)
11879 {
11880 while (!feof (fp))
11881 {
11882 char line_buf[BUFSIZ] = { 0 };
11883
11884 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11885
11886 if (ptr == NULL) break;
11887
11888 int line_len = strlen (line_buf);
11889
11890 if (line_len == 0) continue;
11891
11892 int iter = MAX_CUT_TRIES;
11893
11894 for (int i = line_len - 1; i && iter; i--, line_len--)
11895 {
11896 if (line_buf[i] != ':') continue;
11897
11898 if (isSalted)
11899 {
11900 memset (hash_buf.salt, 0, sizeof (salt_t));
11901 }
11902
11903 hash_t *found = NULL;
11904
11905 if (hash_mode == 6800)
11906 {
11907 if (i < 48) // 48 = 12 * uint in salt_buf[]
11908 {
11909 // manipulate salt_buf
11910 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11911
11912 hash_buf.salt->salt_len = i;
11913
11914 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11915 }
11916 }
11917 else if (hash_mode == 2500)
11918 {
11919 if (i < 48) // 48 = 12 * uint in salt_buf[]
11920 {
11921 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11922 // manipulate salt_buf
11923
11924 // to be safe work with a copy (because of line_len loop, i etc)
11925
11926 char line_buf_cpy[BUFSIZ] = { 0 };
11927
11928 memcpy (line_buf_cpy, line_buf, i);
11929
11930 char *mac2_pos = strrchr (line_buf_cpy, ':');
11931
11932 if (mac2_pos == NULL) continue;
11933
11934 mac2_pos[0] = 0;
11935 mac2_pos++;
11936
11937 if (strlen (mac2_pos) != 12) continue;
11938
11939 char *mac1_pos = strrchr (line_buf_cpy, ':');
11940
11941 if (mac1_pos == NULL) continue;
11942
11943 mac1_pos[0] = 0;
11944 mac1_pos++;
11945
11946 if (strlen (mac1_pos) != 12) continue;
11947
11948 uint essid_length = mac1_pos - line_buf_cpy - 1;
11949
11950 // here we need the ESSID
11951 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11952
11953 hash_buf.salt->salt_len = essid_length;
11954
11955 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11956
11957 if (found)
11958 {
11959 wpa_t *wpa = (wpa_t *) found->esalt;
11960
11961 uint pke[25] = { 0 };
11962
11963 char *pke_ptr = (char *) pke;
11964
11965 for (uint i = 0; i < 25; i++)
11966 {
11967 pke[i] = byte_swap_32 (wpa->pke[i]);
11968 }
11969
11970 u8 mac1[6] = { 0 };
11971 u8 mac2[6] = { 0 };
11972
11973 memcpy (mac1, pke_ptr + 23, 6);
11974 memcpy (mac2, pke_ptr + 29, 6);
11975
11976 // compare hex string(s) vs binary MAC address(es)
11977
11978 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11979 {
11980 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11981 {
11982 found = NULL;
11983 break;
11984 }
11985 }
11986
11987 // early skip ;)
11988 if (!found) continue;
11989
11990 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11991 {
11992 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11993 {
11994 found = NULL;
11995 break;
11996 }
11997 }
11998 }
11999 }
12000 }
12001 else
12002 {
12003 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12004
12005 if (parser_status == PARSER_OK)
12006 {
12007 if (isSalted)
12008 {
12009 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12010 }
12011 else
12012 {
12013 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12014 }
12015 }
12016 }
12017
12018 if (found == NULL) continue;
12019
12020 if (!found->cracked) potfile_remove_cracks++;
12021
12022 found->cracked = 1;
12023
12024 if (found) break;
12025
12026 iter--;
12027 }
12028 }
12029
12030 fclose (fp);
12031 }
12032 }
12033
12034 if (esalt_size)
12035 {
12036 local_free (hash_buf.esalt);
12037 }
12038
12039 if (isSalted)
12040 {
12041 local_free (hash_buf.salt);
12042 }
12043
12044 local_free (hash_buf.digest);
12045 }
12046
12047 /**
12048 * Now generate all the buffers required for later
12049 */
12050
12051 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12052
12053 salt_t *salts_buf_new = NULL;
12054 void *esalts_buf_new = NULL;
12055
12056 if (isSalted)
12057 {
12058 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12059
12060 if (esalt_size)
12061 {
12062 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12063 }
12064 }
12065 else
12066 {
12067 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12068 }
12069
12070 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12071
12072 uint digests_cnt = hashes_cnt;
12073 uint digests_done = 0;
12074
12075 uint size_digests = digests_cnt * dgst_size;
12076 uint size_shown = digests_cnt * sizeof (uint);
12077
12078 uint *digests_shown = (uint *) mymalloc (size_shown);
12079 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12080
12081 uint salts_cnt = 0;
12082 uint salts_done = 0;
12083
12084 hashinfo_t **hash_info = NULL;
12085
12086 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12087 {
12088 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12089
12090 if (username && (remove || show))
12091 {
12092 uint user_pos;
12093
12094 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12095 {
12096 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12097
12098 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12099 }
12100 }
12101 }
12102
12103 uint *salts_shown = (uint *) mymalloc (size_shown);
12104
12105 salt_t *salt_buf;
12106
12107 {
12108 // copied from inner loop
12109
12110 salt_buf = &salts_buf_new[salts_cnt];
12111
12112 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12113
12114 if (esalt_size)
12115 {
12116 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12117 }
12118
12119 salt_buf->digests_cnt = 0;
12120 salt_buf->digests_done = 0;
12121 salt_buf->digests_offset = 0;
12122
12123 salts_cnt++;
12124 }
12125
12126 if (hashes_buf[0].cracked == 1)
12127 {
12128 digests_shown[0] = 1;
12129
12130 digests_done++;
12131
12132 salt_buf->digests_done++;
12133 }
12134
12135 salt_buf->digests_cnt++;
12136
12137 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12138
12139 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12140 {
12141 hash_info[0] = hashes_buf[0].hash_info;
12142 }
12143
12144 // copy from inner loop
12145
12146 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12147 {
12148 if (isSalted)
12149 {
12150 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12151 {
12152 salt_buf = &salts_buf_new[salts_cnt];
12153
12154 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12155
12156 if (esalt_size)
12157 {
12158 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12159 }
12160
12161 salt_buf->digests_cnt = 0;
12162 salt_buf->digests_done = 0;
12163 salt_buf->digests_offset = hashes_pos;
12164
12165 salts_cnt++;
12166 }
12167 }
12168
12169 if (hashes_buf[hashes_pos].cracked == 1)
12170 {
12171 digests_shown[hashes_pos] = 1;
12172
12173 digests_done++;
12174
12175 salt_buf->digests_done++;
12176 }
12177
12178 salt_buf->digests_cnt++;
12179
12180 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12181
12182 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12183 {
12184 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12185 }
12186 }
12187
12188 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12189 {
12190 salt_t *salt_buf = &salts_buf_new[salt_pos];
12191
12192 if (salt_buf->digests_done == salt_buf->digests_cnt)
12193 {
12194 salts_shown[salt_pos] = 1;
12195
12196 salts_done++;
12197 }
12198
12199 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12200 }
12201
12202 local_free (digests_buf);
12203 local_free (salts_buf);
12204 local_free (esalts_buf);
12205
12206 digests_buf = digests_buf_new;
12207 salts_buf = salts_buf_new;
12208 esalts_buf = esalts_buf_new;
12209
12210 local_free (hashes_buf);
12211
12212 /**
12213 * special modification not set from parser
12214 */
12215
12216 switch (hash_mode)
12217 {
12218 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12219 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12220 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12221 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12222 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12223 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12224 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12225 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12226 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12227 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12228 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12229 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12230 }
12231
12232 if (truecrypt_keyfiles)
12233 {
12234 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12235
12236 char *keyfiles = strdup (truecrypt_keyfiles);
12237
12238 char *keyfile = strtok (keyfiles, ",");
12239
12240 do
12241 {
12242 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12243
12244 } while ((keyfile = strtok (NULL, ",")) != NULL);
12245
12246 free (keyfiles);
12247 }
12248
12249 data.digests_cnt = digests_cnt;
12250 data.digests_done = digests_done;
12251 data.digests_buf = digests_buf;
12252 data.digests_shown = digests_shown;
12253 data.digests_shown_tmp = digests_shown_tmp;
12254
12255 data.salts_cnt = salts_cnt;
12256 data.salts_done = salts_done;
12257 data.salts_buf = salts_buf;
12258 data.salts_shown = salts_shown;
12259
12260 data.esalts_buf = esalts_buf;
12261 data.hash_info = hash_info;
12262
12263 /**
12264 * Automatic Optimizers
12265 */
12266
12267 if (salts_cnt == 1)
12268 opti_type |= OPTI_TYPE_SINGLE_SALT;
12269
12270 if (digests_cnt == 1)
12271 opti_type |= OPTI_TYPE_SINGLE_HASH;
12272
12273 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12274 opti_type |= OPTI_TYPE_NOT_ITERATED;
12275
12276 if (attack_mode == ATTACK_MODE_BF)
12277 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12278
12279 data.opti_type = opti_type;
12280
12281 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12282 {
12283 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12284 {
12285 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12286 {
12287 if (opts_type & OPTS_TYPE_ST_ADD80)
12288 {
12289 opts_type &= ~OPTS_TYPE_ST_ADD80;
12290 opts_type |= OPTS_TYPE_PT_ADD80;
12291 }
12292
12293 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12294 {
12295 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12296 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12297 }
12298
12299 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12300 {
12301 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12302 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12303 }
12304 }
12305 }
12306 }
12307
12308 /**
12309 * Some algorithm, like descrypt, can benefit from JIT compilation
12310 */
12311
12312 int force_jit_compilation = -1;
12313
12314 if (hash_mode == 8900)
12315 {
12316 force_jit_compilation = 8900;
12317 }
12318 else if (hash_mode == 9300)
12319 {
12320 force_jit_compilation = 8900;
12321 }
12322 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12323 {
12324 force_jit_compilation = 1500;
12325 }
12326
12327 /**
12328 * generate bitmap tables
12329 */
12330
12331 const uint bitmap_shift1 = 5;
12332 const uint bitmap_shift2 = 13;
12333
12334 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12335
12336 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12337 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12338 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12339 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12340 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12341 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12342 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12343 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344
12345 uint bitmap_bits;
12346 uint bitmap_nums;
12347 uint bitmap_mask;
12348 uint bitmap_size;
12349
12350 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12351 {
12352 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12353
12354 bitmap_nums = 1 << bitmap_bits;
12355
12356 bitmap_mask = bitmap_nums - 1;
12357
12358 bitmap_size = bitmap_nums * sizeof (uint);
12359
12360 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12361
12362 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;
12363 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;
12364
12365 break;
12366 }
12367
12368 bitmap_nums = 1 << bitmap_bits;
12369
12370 bitmap_mask = bitmap_nums - 1;
12371
12372 bitmap_size = bitmap_nums * sizeof (uint);
12373
12374 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);
12375 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);
12376
12377 /**
12378 * prepare quick rule
12379 */
12380
12381 data.rule_buf_l = rule_buf_l;
12382 data.rule_buf_r = rule_buf_r;
12383
12384 int rule_len_l = (int) strlen (rule_buf_l);
12385 int rule_len_r = (int) strlen (rule_buf_r);
12386
12387 data.rule_len_l = rule_len_l;
12388 data.rule_len_r = rule_len_r;
12389
12390 /**
12391 * load rules
12392 */
12393
12394 uint *all_kernel_rules_cnt = NULL;
12395
12396 kernel_rule_t **all_kernel_rules_buf = NULL;
12397
12398 if (rp_files_cnt)
12399 {
12400 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12401
12402 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12403 }
12404
12405 char rule_buf[BUFSIZ] = { 0 };
12406
12407 int rule_len = 0;
12408
12409 for (uint i = 0; i < rp_files_cnt; i++)
12410 {
12411 uint kernel_rules_avail = 0;
12412
12413 uint kernel_rules_cnt = 0;
12414
12415 kernel_rule_t *kernel_rules_buf = NULL;
12416
12417 char *rp_file = rp_files[i];
12418
12419 char in[BLOCK_SIZE] = { 0 };
12420 char out[BLOCK_SIZE] = { 0 };
12421
12422 FILE *fp = NULL;
12423
12424 uint rule_line = 0;
12425
12426 if ((fp = fopen (rp_file, "rb")) == NULL)
12427 {
12428 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12429
12430 return (-1);
12431 }
12432
12433 while (!feof (fp))
12434 {
12435 memset (rule_buf, 0, BUFSIZ);
12436
12437 rule_len = fgetl (fp, rule_buf);
12438
12439 rule_line++;
12440
12441 if (rule_len == 0) continue;
12442
12443 if (rule_buf[0] == '#') continue;
12444
12445 if (kernel_rules_avail == kernel_rules_cnt)
12446 {
12447 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12448
12449 kernel_rules_avail += INCR_RULES;
12450 }
12451
12452 memset (in, 0, BLOCK_SIZE);
12453 memset (out, 0, BLOCK_SIZE);
12454
12455 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12456
12457 if (result == -1)
12458 {
12459 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12460
12461 continue;
12462 }
12463
12464 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12465 {
12466 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12467
12468 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12469
12470 continue;
12471 }
12472
12473 /* its so slow
12474 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12475 {
12476 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12477
12478 continue;
12479 }
12480 */
12481
12482 kernel_rules_cnt++;
12483 }
12484
12485 fclose (fp);
12486
12487 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12488
12489 all_kernel_rules_buf[i] = kernel_rules_buf;
12490 }
12491
12492 /**
12493 * merge rules or automatic rule generator
12494 */
12495
12496 uint kernel_rules_cnt = 0;
12497
12498 kernel_rule_t *kernel_rules_buf = NULL;
12499
12500 if (attack_mode == ATTACK_MODE_STRAIGHT)
12501 {
12502 if (rp_files_cnt)
12503 {
12504 kernel_rules_cnt = 1;
12505
12506 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12507
12508 repeats[0] = kernel_rules_cnt;
12509
12510 for (uint i = 0; i < rp_files_cnt; i++)
12511 {
12512 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12513
12514 repeats[i + 1] = kernel_rules_cnt;
12515 }
12516
12517 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12518
12519 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12520
12521 for (uint i = 0; i < kernel_rules_cnt; i++)
12522 {
12523 uint out_pos = 0;
12524
12525 kernel_rule_t *out = &kernel_rules_buf[i];
12526
12527 for (uint j = 0; j < rp_files_cnt; j++)
12528 {
12529 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12530 uint in_pos;
12531
12532 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12533
12534 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12535 {
12536 if (out_pos == RULES_MAX - 1)
12537 {
12538 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12539
12540 break;
12541 }
12542
12543 out->cmds[out_pos] = in->cmds[in_pos];
12544 }
12545 }
12546 }
12547
12548 local_free (repeats);
12549 }
12550 else if (rp_gen)
12551 {
12552 uint kernel_rules_avail = 0;
12553
12554 while (kernel_rules_cnt < rp_gen)
12555 {
12556 if (kernel_rules_avail == kernel_rules_cnt)
12557 {
12558 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12559
12560 kernel_rules_avail += INCR_RULES;
12561 }
12562
12563 memset (rule_buf, 0, BLOCK_SIZE);
12564
12565 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12566
12567 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12568
12569 kernel_rules_cnt++;
12570 }
12571 }
12572 }
12573
12574 /**
12575 * generate NOP rules
12576 */
12577
12578 if (kernel_rules_cnt == 0)
12579 {
12580 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12581
12582 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12583
12584 kernel_rules_cnt++;
12585 }
12586
12587 data.kernel_rules_cnt = kernel_rules_cnt;
12588 data.kernel_rules_buf = kernel_rules_buf;
12589
12590 /**
12591 * OpenCL platforms: detect
12592 */
12593
12594 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12595
12596 cl_uint platforms_cnt = 0;
12597
12598 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12599
12600 cl_uint platform_devices_cnt;
12601
12602 if (keyspace == 0)
12603 {
12604 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12605
12606 if (platforms_cnt == 0)
12607 {
12608 log_error ("ERROR: No OpenCL compatible platform found");
12609
12610 return (-1);
12611 }
12612 }
12613
12614 /**
12615 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12616 */
12617
12618 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12619 {
12620 cl_platform_id platform = platforms[platform_id];
12621
12622 char platform_vendor[INFOSZ] = { 0 };
12623
12624 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12625
12626 #ifdef HAVE_HWMON
12627 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12628 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12629 {
12630 // make sure that we do not directly control the fan for NVidia
12631
12632 gpu_temp_retain = 0;
12633
12634 data.gpu_temp_retain = gpu_temp_retain;
12635 }
12636 #endif // HAVE_NVML || HAVE_NVAPI
12637 #endif
12638 }
12639
12640 /**
12641 * OpenCL devices: simply push all devices from all platforms into the same device array
12642 */
12643
12644 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12645
12646 data.devices_param = devices_param;
12647
12648 uint devices_cnt = 0;
12649
12650 uint devices_active = 0;
12651
12652 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12653 {
12654 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12655
12656 cl_platform_id platform = platforms[platform_id];
12657
12658 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12659
12660 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12661 {
12662 const uint device_id = devices_cnt;
12663
12664 hc_device_param_t *device_param = &data.devices_param[device_id];
12665
12666 device_param->device = platform_devices[platform_devices_id];
12667
12668 device_param->device_id = device_id;
12669
12670 device_param->platform_devices_id = platform_devices_id;
12671
12672 // device_type
12673
12674 cl_device_type device_type;
12675
12676 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12677
12678 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12679
12680 device_param->device_type = device_type;
12681
12682 // vendor_id
12683
12684 cl_uint vendor_id = 0;
12685
12686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12687
12688 device_param->vendor_id = vendor_id;
12689
12690 // device_name
12691
12692 char *device_name = (char *) mymalloc (INFOSZ);
12693
12694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12695
12696 device_param->device_name = device_name;
12697
12698 // device_version
12699
12700 char *device_version = (char *) mymalloc (INFOSZ);
12701
12702 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12703
12704 device_param->device_version = device_version;
12705
12706 if (strstr (device_version, "pocl"))
12707 {
12708 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12709 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12710
12711 cl_uint vendor_id = VENDOR_ID_GENERIC;
12712
12713 device_param->vendor_id = vendor_id;
12714 }
12715
12716 // max_compute_units
12717
12718 cl_uint vector_width;
12719
12720 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12721 {
12722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12723
12724 int is_ti = 0;
12725
12726 const int device_name_len = strlen (device_name);
12727
12728 if (device_name[device_name_len - 2] == 't') is_ti++;
12729 if (device_name[device_name_len - 2] == 'T') is_ti++;
12730 if (device_name[device_name_len - 1] == 'i') is_ti++;
12731 if (device_name[device_name_len - 1] == 'I') is_ti++;
12732
12733 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12734 {
12735 // Yeah that's a super bad hack, but there's no other attribute we could use
12736
12737 if (vector_width < 2) vector_width *= 2;
12738 }
12739
12740 if (opti_type & OPTI_TYPE_USES_BITS_64)
12741 {
12742 if (vector_width > 1) vector_width /= 2;
12743 }
12744 }
12745 else
12746 {
12747 vector_width = opencl_vector_width;
12748 }
12749
12750 if (vector_width > 8) vector_width = 8;
12751
12752 device_param->vector_width = vector_width;
12753
12754 // max_compute_units
12755
12756 cl_uint device_processors;
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12759
12760 device_param->device_processors = device_processors;
12761
12762 // max_mem_alloc_size
12763
12764 cl_ulong device_maxmem_alloc;
12765
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12767
12768 device_param->device_maxmem_alloc = device_maxmem_alloc;
12769
12770 // max_mem_alloc_size
12771
12772 cl_ulong device_global_mem;
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12775
12776 device_param->device_global_mem = device_global_mem;
12777
12778 // max_clock_frequency
12779
12780 cl_uint device_maxclock_frequency;
12781
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12783
12784 device_param->device_maxclock_frequency = device_maxclock_frequency;
12785
12786 // skipped
12787
12788 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12789 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12790
12791 device_param->skipped = (skipped1 || skipped2);
12792
12793 // driver_version
12794
12795 char *driver_version = (char *) mymalloc (INFOSZ);
12796
12797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12798
12799 device_param->driver_version = driver_version;
12800
12801 // device_name_chksum
12802
12803 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12804
12805 #if __x86_64__
12806 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);
12807 #else
12808 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);
12809 #endif
12810
12811 uint device_name_digest[4] = { 0 };
12812
12813 md5_64 ((uint *) device_name_chksum, device_name_digest);
12814
12815 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12816
12817 device_param->device_name_chksum = device_name_chksum;
12818
12819 // device_processor_cores
12820
12821 if (device_type & CL_DEVICE_TYPE_CPU)
12822 {
12823 cl_uint device_processor_cores = 1;
12824
12825 device_param->device_processor_cores = device_processor_cores;
12826 }
12827
12828 if (device_type & CL_DEVICE_TYPE_GPU)
12829 {
12830 if (vendor_id == VENDOR_ID_AMD)
12831 {
12832 cl_uint device_processor_cores = 0;
12833
12834 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12835
12836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12837
12838 device_param->device_processor_cores = device_processor_cores;
12839 }
12840 else if (vendor_id == VENDOR_ID_NV)
12841 {
12842 cl_uint kernel_exec_timeout = 0;
12843
12844 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12845
12846 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12847
12848 device_param->kernel_exec_timeout = kernel_exec_timeout;
12849
12850 cl_uint device_processor_cores = 0;
12851
12852 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12853
12854 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12855
12856 device_param->device_processor_cores = device_processor_cores;
12857
12858 cl_uint sm_minor = 0;
12859 cl_uint sm_major = 0;
12860
12861 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12862 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12863
12864 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12866
12867 device_param->sm_minor = sm_minor;
12868 device_param->sm_major = sm_major;
12869 }
12870 else
12871 {
12872 cl_uint device_processor_cores = 1;
12873
12874 device_param->device_processor_cores = device_processor_cores;
12875 }
12876 }
12877
12878 // display results
12879
12880 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12881 {
12882 if (device_param->skipped == 0)
12883 {
12884 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12885 device_id + 1,
12886 device_name,
12887 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12888 (unsigned int) (device_global_mem / 1024 / 1024),
12889 (unsigned int) (device_maxclock_frequency),
12890 (unsigned int) device_processors);
12891 }
12892 else
12893 {
12894 log_info ("Device #%u: %s, skipped",
12895 device_id + 1,
12896 device_name);
12897 }
12898 }
12899
12900 // common driver check
12901
12902 if (device_param->skipped == 0)
12903 {
12904 if (strstr (device_version, "pocl"))
12905 {
12906 if (force == 0)
12907 {
12908 log_info ("");
12909 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12910 log_info ("You are STRONGLY encouraged not to use it");
12911 log_info ("You can use --force to override this but do not post error reports if you do so");
12912 log_info ("");
12913
12914 return (-1);
12915 }
12916 }
12917
12918 if (device_type & CL_DEVICE_TYPE_GPU)
12919 {
12920 if (vendor_id == VENDOR_ID_NV)
12921 {
12922 if (device_param->kernel_exec_timeout != 0)
12923 {
12924 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);
12925 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12926 }
12927 }
12928 else if (vendor_id == VENDOR_ID_AMD)
12929 {
12930 int catalyst_check = (force == 1) ? 0 : 1;
12931
12932 int catalyst_warn = 0;
12933
12934 int catalyst_broken = 0;
12935
12936 if (catalyst_check == 1)
12937 {
12938 catalyst_warn = 1;
12939
12940 // v14.9 and higher
12941 if (atoi (device_param->driver_version) >= 1573)
12942 {
12943 catalyst_warn = 0;
12944 }
12945
12946 catalyst_check = 0;
12947 }
12948
12949 if (catalyst_broken == 1)
12950 {
12951 log_info ("");
12952 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12953 log_info ("It will pass over cracked hashes and does not report them as cracked");
12954 log_info ("You are STRONGLY encouraged not to use it");
12955 log_info ("You can use --force to override this but do not post error reports if you do so");
12956 log_info ("");
12957
12958 return (-1);
12959 }
12960
12961 if (catalyst_warn == 1)
12962 {
12963 log_info ("");
12964 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12965 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12966 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12967 #ifdef _WIN
12968 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12969 #endif
12970 log_info ("You can use --force to override this but do not post error reports if you do so");
12971 log_info ("");
12972
12973 return (-1);
12974 }
12975 }
12976 }
12977
12978 devices_active++;
12979 }
12980
12981 // next please
12982
12983 devices_cnt++;
12984 }
12985 }
12986
12987 if (keyspace == 0 && devices_active == 0)
12988 {
12989 log_error ("ERROR: No devices found/left");
12990
12991 return (-1);
12992 }
12993
12994 data.devices_cnt = devices_cnt;
12995
12996 data.devices_active = devices_active;
12997
12998 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12999 {
13000 log_info ("");
13001 }
13002
13003 /**
13004 * OpenCL devices: allocate buffer for device specific information
13005 */
13006
13007 #ifdef HAVE_HWMON
13008 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
13009
13010 #ifdef HAVE_ADL
13011 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
13012
13013 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
13014 #endif // ADL
13015 #endif
13016
13017 /**
13018 * enable custom signal handler(s)
13019 */
13020
13021 if (benchmark == 0)
13022 {
13023 hc_signal (sigHandler_default);
13024 }
13025 else
13026 {
13027 hc_signal (sigHandler_benchmark);
13028 }
13029
13030 /**
13031 * User-defined GPU temp handling
13032 */
13033
13034 #ifdef HAVE_HWMON
13035 if (gpu_temp_disable == 1)
13036 {
13037 gpu_temp_abort = 0;
13038 gpu_temp_retain = 0;
13039 }
13040
13041 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13042 {
13043 if (gpu_temp_abort < gpu_temp_retain)
13044 {
13045 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13046
13047 return (-1);
13048 }
13049 }
13050
13051 data.gpu_temp_disable = gpu_temp_disable;
13052 data.gpu_temp_abort = gpu_temp_abort;
13053 data.gpu_temp_retain = gpu_temp_retain;
13054 #endif
13055
13056 /**
13057 * inform the user
13058 */
13059
13060 if (data.quiet == 0)
13061 {
13062 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13063
13064 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);
13065
13066 if (attack_mode == ATTACK_MODE_STRAIGHT)
13067 {
13068 log_info ("Rules: %u", kernel_rules_cnt);
13069 }
13070
13071 if (opti_type)
13072 {
13073 log_info ("Applicable Optimizers:");
13074
13075 for (uint i = 0; i < 32; i++)
13076 {
13077 const uint opti_bit = 1u << i;
13078
13079 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13080 }
13081 }
13082
13083 /**
13084 * Watchdog and Temperature balance
13085 */
13086
13087 #ifdef HAVE_HWMON
13088 if (gpu_temp_abort == 0)
13089 {
13090 log_info ("Watchdog: Temperature abort trigger disabled");
13091 }
13092 else
13093 {
13094 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13095 }
13096
13097 if (gpu_temp_retain == 0)
13098 {
13099 log_info ("Watchdog: Temperature retain trigger disabled");
13100 }
13101 else
13102 {
13103 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13104 }
13105 #endif
13106 }
13107
13108 if (data.quiet == 0) log_info ("");
13109
13110 /**
13111 * HM devices: init
13112 */
13113
13114 #ifdef HAVE_HWMON
13115 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13116 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13117 #endif
13118
13119 #ifdef HAVE_ADL
13120 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13121 #endif
13122
13123 if (gpu_temp_disable == 0)
13124 {
13125 #if defined(WIN) && defined(HAVE_NVAPI)
13126 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13127
13128 if (nvapi_init (nvapi) == 0)
13129 data.hm_nv = nvapi;
13130
13131 if (data.hm_nv)
13132 {
13133 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13134 {
13135 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13136
13137 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13138
13139 int tmp_out = 0;
13140
13141 for (int i = 0; i < tmp_in; i++)
13142 {
13143 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13144 }
13145
13146 for (int i = 0; i < tmp_out; i++)
13147 {
13148 NvU32 speed;
13149
13150 if (hm_NvAPI_GPU_GetTachReading (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13151 }
13152 }
13153 }
13154 #endif // WIN && HAVE_NVAPI
13155
13156 #if defined(LINUX) && defined(HAVE_NVML)
13157 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13158
13159 if (nvml_init (nvml) == 0)
13160 data.hm_nv = nvml;
13161
13162 if (data.hm_nv)
13163 {
13164 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13165 {
13166 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13167
13168 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13169
13170 int tmp_out = 0;
13171
13172 for (int i = 0; i < tmp_in; i++)
13173 {
13174 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13175 }
13176
13177 for (int i = 0; i < tmp_out; i++)
13178 {
13179 unsigned int speed;
13180
13181 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13182 }
13183 }
13184 }
13185 #endif // LINUX && HAVE_NVML
13186
13187 data.hm_amd = NULL;
13188
13189 #ifdef HAVE_ADL
13190 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13191
13192 if (adl_init (adl) == 0)
13193 data.hm_amd = adl;
13194
13195 if (data.hm_amd)
13196 {
13197 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13198 {
13199 // total number of adapters
13200
13201 int hm_adapters_num;
13202
13203 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13204
13205 // adapter info
13206
13207 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13208
13209 if (lpAdapterInfo == NULL) return (-1);
13210
13211 // get a list (of ids of) valid/usable adapters
13212
13213 int num_adl_adapters = 0;
13214
13215 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13216
13217 if (num_adl_adapters > 0)
13218 {
13219 hc_thread_mutex_lock (mux_adl);
13220
13221 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13222
13223 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13224
13225 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13226 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13227
13228 hc_thread_mutex_unlock (mux_adl);
13229 }
13230
13231 myfree (valid_adl_device_list);
13232 myfree (lpAdapterInfo);
13233 }
13234 }
13235 #endif // HAVE_ADL
13236 }
13237
13238 /**
13239 * HM devices: copy
13240 */
13241
13242 if (gpu_temp_disable == 0)
13243 {
13244 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13245 {
13246 hc_device_param_t *device_param = &data.devices_param[device_id];
13247
13248 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13249
13250 if (device_param->skipped) continue;
13251
13252 const uint platform_devices_id = device_param->platform_devices_id;
13253
13254 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13255 if (device_param->vendor_id == VENDOR_ID_NV)
13256 {
13257 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13258 }
13259 #endif
13260
13261 #ifdef HAVE_ADL
13262 if (device_param->vendor_id == VENDOR_ID_AMD)
13263 {
13264 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13265 }
13266 #endif
13267 }
13268 }
13269
13270 /*
13271 * Temporary fix:
13272 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13273 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13274 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13275 * Driver / ADL bug?
13276 */
13277
13278 #ifdef HAVE_ADL
13279 if (powertune_enable == 1)
13280 {
13281 hc_thread_mutex_lock (mux_adl);
13282
13283 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13284 {
13285 hc_device_param_t *device_param = &data.devices_param[device_id];
13286
13287 if (device_param->skipped) continue;
13288
13289 if (data.hm_device[device_id].od_version == 6)
13290 {
13291 // set powertune value only
13292
13293 int powertune_supported = 0;
13294
13295 int ADL_rc = 0;
13296
13297 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13298 {
13299 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13300
13301 return (-1);
13302 }
13303
13304 if (powertune_supported != 0)
13305 {
13306 // powertune set
13307 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13308
13309 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13310 {
13311 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13312
13313 return (-1);
13314 }
13315
13316 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13317 {
13318 log_error ("ERROR: Failed to set new ADL PowerControl values");
13319
13320 return (-1);
13321 }
13322 }
13323 }
13324 }
13325
13326 hc_thread_mutex_unlock (mux_adl);
13327 }
13328 #endif // HAVE_ADK
13329 #endif // HAVE_HWMON
13330
13331 #ifdef OSX
13332 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13333 {
13334 if (force == 0)
13335 {
13336 log_info ("");
13337 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13338 log_info ("You can use --force to override this but do not post error reports if you do so");
13339 log_info ("");
13340
13341 continue;
13342 }
13343 }
13344 #endif
13345
13346 #ifdef DEBUG
13347 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13348 #endif
13349
13350 uint kernel_blocks_all = 0;
13351
13352 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13353 {
13354 /**
13355 * host buffer
13356 */
13357
13358 hc_device_param_t *device_param = &data.devices_param[device_id];
13359
13360 if (device_param->skipped) continue;
13361
13362 /**
13363 * device properties
13364 */
13365
13366 char *device_name_chksum = device_param->device_name_chksum;
13367
13368 uint device_processors = device_param->device_processors;
13369
13370 uint device_processor_cores = device_param->device_processor_cores;
13371
13372 cl_device_type device_type = device_param->device_type;
13373
13374 /**
13375 * create context for each device
13376 */
13377
13378 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13379
13380 /**
13381 * create command-queue
13382 */
13383
13384 // not supported with NV
13385 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13386
13387 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13388
13389 /**
13390 * create input buffers on device
13391 */
13392
13393 uint kernel_threads = KERNEL_THREADS;
13394
13395 // bcrypt
13396 if (hash_mode == 3200) kernel_threads = 8;
13397 if (hash_mode == 9000) kernel_threads = 8;
13398
13399 if (device_type & CL_DEVICE_TYPE_CPU)
13400 {
13401 if (benchmark_mode == 0)
13402 {
13403 if (kernel_accel > 16)
13404 {
13405 kernel_accel = 16;
13406 }
13407 }
13408 else
13409 {
13410 if (kernel_accel > 64)
13411 {
13412 kernel_accel = 64;
13413 }
13414 }
13415 }
13416
13417 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13418 uint kernel_blocks = kernel_power;
13419
13420 device_param->kernel_threads = kernel_threads;
13421 device_param->kernel_power_user = kernel_power;
13422 device_param->kernel_blocks_user = kernel_blocks;
13423
13424 kernel_blocks_all += kernel_blocks;
13425
13426 uint size_pws = kernel_power * sizeof (pw_t);
13427
13428 uint size_tmps = 4;
13429
13430 switch (hash_mode)
13431 {
13432 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13433 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13434 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13435 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13436 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13437 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13438 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13439 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13440 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13441 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13442 case 6211:
13443 case 6212:
13444 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13445 case 6221:
13446 case 6222:
13447 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13448 case 6231:
13449 case 6232:
13450 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13451 case 6241:
13452 case 6242:
13453 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13454 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13455 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13456 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13457 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13458 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13459 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13460 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13461 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13462 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13463 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13464 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13465 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13466 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13467 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13468 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13469 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13470 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13471 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13472 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13473 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13474 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13475 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13476 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13477 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13478 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13479 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13480 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13481 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13482 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13483 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13484 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13485 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13486 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13487 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13488 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13489 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13490 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13491 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13492 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13493 };
13494
13495 uint size_hooks = 4;
13496
13497 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13498 {
13499 // insert correct hook size
13500 }
13501
13502 // we can optimize some stuff here...
13503
13504 device_param->size_pws = size_pws;
13505 device_param->size_tmps = size_tmps;
13506 device_param->size_hooks = size_hooks;
13507
13508 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13509 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13510
13511 device_param->size_root_css = size_root_css;
13512 device_param->size_markov_css = size_markov_css;
13513
13514 uint size_results = KERNEL_THREADS * sizeof (uint);
13515
13516 device_param->size_results = size_results;
13517
13518 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13519 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13520
13521 uint size_plains = digests_cnt * sizeof (plain_t);
13522 uint size_salts = salts_cnt * sizeof (salt_t);
13523 uint size_esalts = salts_cnt * esalt_size;
13524
13525 device_param->size_plains = size_plains;
13526 device_param->size_digests = size_digests;
13527 device_param->size_shown = size_shown;
13528 device_param->size_salts = size_salts;
13529
13530 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13531 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13532 uint size_tm = 32 * sizeof (bs_word_t);
13533
13534 u64 size_scryptV = 1;
13535
13536 if ((hash_mode == 8900) || (hash_mode == 9300))
13537 {
13538 uint tmto_start = 0;
13539 uint tmto_stop = 10;
13540
13541 if (scrypt_tmto)
13542 {
13543 tmto_start = scrypt_tmto;
13544 }
13545 else
13546 {
13547 // in case the user did not specify the tmto manually
13548 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13549 // but set the lower end only in case the user has a device with too less memory
13550
13551 if (hash_mode == 8900)
13552 {
13553 if (device_param->vendor_id == VENDOR_ID_AMD)
13554 {
13555 tmto_start = 1;
13556 }
13557 else if (device_param->vendor_id == VENDOR_ID_NV)
13558 {
13559 tmto_start = 3;
13560 }
13561 }
13562 else if (hash_mode == 9300)
13563 {
13564 if (device_param->vendor_id == VENDOR_ID_AMD)
13565 {
13566 tmto_start = 3;
13567 }
13568 else if (device_param->vendor_id == VENDOR_ID_NV)
13569 {
13570 tmto_start = 5;
13571 }
13572 }
13573 }
13574
13575 if (quiet == 0) log_info ("");
13576
13577 uint shader_per_mp = 1;
13578
13579 if (device_param->vendor_id == VENDOR_ID_AMD)
13580 {
13581 shader_per_mp = 8;
13582 }
13583 else if (device_param->vendor_id == VENDOR_ID_NV)
13584 {
13585 shader_per_mp = 32;
13586 }
13587
13588 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13589 {
13590 // TODO: in theory the following calculation needs to be done per salt, not global
13591 // we assume all hashes have the same scrypt settings
13592
13593 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13594
13595 size_scryptV /= 1 << tmto;
13596
13597 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13598
13599 if (size_scryptV > device_param->device_maxmem_alloc)
13600 {
13601 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13602
13603 continue;
13604 }
13605
13606 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13607 {
13608 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13609 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13610 }
13611
13612 break;
13613 }
13614
13615 if (data.salts_buf[0].scrypt_phy == 0)
13616 {
13617 log_error ("ERROR: can't allocate enough device memory");
13618
13619 return -1;
13620 }
13621
13622 if (quiet == 0) log_info ("");
13623 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13624 }
13625
13626 /**
13627 * default building options
13628 */
13629
13630 char build_opts[1024] = { 0 };
13631
13632 // we don't have sm_* on vendors not NV but it doesn't matter
13633
13634 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);
13635
13636 /**
13637 * main kernel
13638 */
13639
13640 {
13641 /**
13642 * kernel source filename
13643 */
13644
13645 char source_file[256] = { 0 };
13646
13647 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13648
13649 struct stat sst;
13650
13651 if (stat (source_file, &sst) == -1)
13652 {
13653 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13654
13655 return -1;
13656 }
13657
13658 /**
13659 * kernel cached filename
13660 */
13661
13662 char cached_file[256] = { 0 };
13663
13664 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13665
13666 int cached = 1;
13667
13668 struct stat cst;
13669
13670 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13671 {
13672 cached = 0;
13673 }
13674
13675 /**
13676 * kernel compile or load
13677 */
13678
13679 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13680
13681 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13682
13683 if (force_jit_compilation == -1)
13684 {
13685 if (cached == 0)
13686 {
13687 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13688
13689 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13690
13691 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13692
13693 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13694
13695 size_t binary_size;
13696
13697 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13698
13699 u8 *binary = (u8 *) mymalloc (binary_size);
13700
13701 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13702
13703 writeProgramBin (cached_file, binary, binary_size);
13704
13705 local_free (binary);
13706 }
13707 else
13708 {
13709 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13710
13711 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13712
13713 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13714
13715 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13716 }
13717 }
13718 else
13719 {
13720 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13721
13722 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13723
13724 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13725
13726 char build_opts_update[1024] = { 0 };
13727
13728 if (force_jit_compilation == 1500)
13729 {
13730 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13731 }
13732 else if (force_jit_compilation == 8900)
13733 {
13734 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);
13735 }
13736
13737 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
13738 }
13739
13740 local_free (kernel_lengths);
13741 local_free (kernel_sources[0]);
13742 local_free (kernel_sources);
13743 }
13744
13745 /**
13746 * word generator kernel
13747 */
13748
13749 if (attack_mode != ATTACK_MODE_STRAIGHT)
13750 {
13751 /**
13752 * kernel mp source filename
13753 */
13754
13755 char source_file[256] = { 0 };
13756
13757 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13758
13759 struct stat sst;
13760
13761 if (stat (source_file, &sst) == -1)
13762 {
13763 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13764
13765 return -1;
13766 }
13767
13768 /**
13769 * kernel mp cached filename
13770 */
13771
13772 char cached_file[256] = { 0 };
13773
13774 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13775
13776 int cached = 1;
13777
13778 struct stat cst;
13779
13780 if (stat (cached_file, &cst) == -1)
13781 {
13782 cached = 0;
13783 }
13784
13785 /**
13786 * kernel compile or load
13787 */
13788
13789 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13790
13791 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13792
13793 if (cached == 0)
13794 {
13795 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13796
13797 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13798
13799 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13800
13801 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13802
13803 size_t binary_size;
13804
13805 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13806
13807 u8 *binary = (u8 *) mymalloc (binary_size);
13808
13809 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13810
13811 writeProgramBin (cached_file, binary, binary_size);
13812
13813 local_free (binary);
13814 }
13815 else
13816 {
13817 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13818
13819 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13820
13821 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13822
13823 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13824 }
13825
13826 local_free (kernel_lengths);
13827 local_free (kernel_sources[0]);
13828 local_free (kernel_sources);
13829 }
13830
13831 /**
13832 * amplifier kernel
13833 */
13834
13835 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13836 {
13837
13838 }
13839 else
13840 {
13841 /**
13842 * kernel amp source filename
13843 */
13844
13845 char source_file[256] = { 0 };
13846
13847 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13848
13849 struct stat sst;
13850
13851 if (stat (source_file, &sst) == -1)
13852 {
13853 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13854
13855 return -1;
13856 }
13857
13858 /**
13859 * kernel amp cached filename
13860 */
13861
13862 char cached_file[256] = { 0 };
13863
13864 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13865
13866 int cached = 1;
13867
13868 struct stat cst;
13869
13870 if (stat (cached_file, &cst) == -1)
13871 {
13872 cached = 0;
13873 }
13874
13875 /**
13876 * kernel compile or load
13877 */
13878
13879 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13880
13881 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13882
13883 if (cached == 0)
13884 {
13885 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13886
13887 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13888
13889 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13890
13891 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13892
13893 size_t binary_size;
13894
13895 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13896
13897 u8 *binary = (u8 *) mymalloc (binary_size);
13898
13899 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13900
13901 writeProgramBin (cached_file, binary, binary_size);
13902
13903 local_free (binary);
13904 }
13905 else
13906 {
13907 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13908
13909 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13910
13911 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13912
13913 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13914 }
13915
13916 local_free (kernel_lengths);
13917 local_free (kernel_sources[0]);
13918 local_free (kernel_sources);
13919 }
13920
13921 /**
13922 * global buffers
13923 */
13924
13925 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13926 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13927 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13928 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13929 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13930 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13931 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13932 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13933 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13934 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13935 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13936 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13937 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13938 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13939 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13940 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13941 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13942 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13943
13944 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);
13945 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);
13946 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);
13947 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);
13948 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);
13949 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);
13950 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);
13951 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);
13952 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13953 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13954 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13955
13956 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13957 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13958 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13959 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13960 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13961 run_kernel_bzero (device_param, device_param->d_result, size_results);
13962
13963 /**
13964 * special buffers
13965 */
13966
13967 if (attack_kern == ATTACK_KERN_STRAIGHT)
13968 {
13969 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13970 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13971
13972 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13973
13974 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13975 }
13976 else if (attack_kern == ATTACK_KERN_COMBI)
13977 {
13978 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13979 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13980 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13981 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13982
13983 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13984 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13985 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13986 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13987 }
13988 else if (attack_kern == ATTACK_KERN_BF)
13989 {
13990 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13991 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13992 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13993 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13994 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13995
13996 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13997 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13998 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13999 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14000 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14001 }
14002
14003 if (size_esalts)
14004 {
14005 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14006
14007 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14008 }
14009
14010 /**
14011 * main host data
14012 */
14013
14014 uint *result = (uint *) mymalloc (size_results);
14015
14016 device_param->result = result;
14017
14018 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14019
14020 device_param->pws_buf = pws_buf;
14021
14022 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14023
14024 for (int i = 0; i < 64; i++)
14025 {
14026 pw_caches[i].pw_buf.pw_len = i;
14027 pw_caches[i].cnt = 0;
14028 }
14029
14030 device_param->pw_caches = pw_caches;
14031
14032 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14033
14034 device_param->combs_buf = combs_buf;
14035
14036 void *hooks_buf = mymalloc (size_hooks);
14037
14038 device_param->hooks_buf = hooks_buf;
14039
14040 device_param->pw_transpose = pw_transpose_to_hi1;
14041 device_param->pw_add = pw_add_to_hc1;
14042
14043 /**
14044 * kernel args
14045 */
14046
14047 device_param->kernel_params_buf32[21] = bitmap_mask;
14048 device_param->kernel_params_buf32[22] = bitmap_shift1;
14049 device_param->kernel_params_buf32[23] = bitmap_shift2;
14050 device_param->kernel_params_buf32[24] = 0; // salt_pos
14051 device_param->kernel_params_buf32[25] = 0; // loop_pos
14052 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14053 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14054 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14055 device_param->kernel_params_buf32[29] = 0; // digests_offset
14056 device_param->kernel_params_buf32[30] = 0; // combs_mode
14057 device_param->kernel_params_buf32[31] = 0; // gid_max
14058
14059 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14060 ? &device_param->d_pws_buf
14061 : &device_param->d_pws_amp_buf;
14062 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14063 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14064 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14065 device_param->kernel_params[ 4] = &device_param->d_tmps;
14066 device_param->kernel_params[ 5] = &device_param->d_hooks;
14067 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14068 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14069 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14070 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14071 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14072 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14073 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14074 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14075 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14076 device_param->kernel_params[15] = &device_param->d_digests_buf;
14077 device_param->kernel_params[16] = &device_param->d_digests_shown;
14078 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14079 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14080 device_param->kernel_params[19] = &device_param->d_result;
14081 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14082 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14083 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14084 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14085 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14086 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14087 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14088 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14089 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14090 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14091 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14092 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14093
14094 device_param->kernel_params_mp_buf64[3] = 0;
14095 device_param->kernel_params_mp_buf32[4] = 0;
14096 device_param->kernel_params_mp_buf32[5] = 0;
14097 device_param->kernel_params_mp_buf32[6] = 0;
14098 device_param->kernel_params_mp_buf32[7] = 0;
14099 device_param->kernel_params_mp_buf32[8] = 0;
14100
14101 device_param->kernel_params_mp[0] = NULL;
14102 device_param->kernel_params_mp[1] = NULL;
14103 device_param->kernel_params_mp[2] = NULL;
14104 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14105 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14106 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14107 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14108 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14109 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14110
14111 device_param->kernel_params_mp_l_buf64[3] = 0;
14112 device_param->kernel_params_mp_l_buf32[4] = 0;
14113 device_param->kernel_params_mp_l_buf32[5] = 0;
14114 device_param->kernel_params_mp_l_buf32[6] = 0;
14115 device_param->kernel_params_mp_l_buf32[7] = 0;
14116 device_param->kernel_params_mp_l_buf32[8] = 0;
14117 device_param->kernel_params_mp_l_buf32[9] = 0;
14118
14119 device_param->kernel_params_mp_l[0] = NULL;
14120 device_param->kernel_params_mp_l[1] = NULL;
14121 device_param->kernel_params_mp_l[2] = NULL;
14122 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14123 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14124 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14125 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14126 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14127 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14128 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14129
14130 device_param->kernel_params_mp_r_buf64[3] = 0;
14131 device_param->kernel_params_mp_r_buf32[4] = 0;
14132 device_param->kernel_params_mp_r_buf32[5] = 0;
14133 device_param->kernel_params_mp_r_buf32[6] = 0;
14134 device_param->kernel_params_mp_r_buf32[7] = 0;
14135 device_param->kernel_params_mp_r_buf32[8] = 0;
14136
14137 device_param->kernel_params_mp_r[0] = NULL;
14138 device_param->kernel_params_mp_r[1] = NULL;
14139 device_param->kernel_params_mp_r[2] = NULL;
14140 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14141 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14142 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14143 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14144 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14145 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14146
14147 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14148 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14149
14150 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14151 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14152 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14153 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14154 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14155 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14156 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14157
14158 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14159
14160 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14161 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14162
14163 /**
14164 * kernel name
14165 */
14166
14167 char kernel_name[64] = { 0 };
14168
14169 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14170 {
14171 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14172 {
14173 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14174
14175 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14176
14177 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14178
14179 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14180
14181 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14182
14183 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14184 }
14185 else
14186 {
14187 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14188
14189 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14190
14191 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14192
14193 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14194
14195 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14196
14197 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14198 }
14199
14200 if (data.attack_mode == ATTACK_MODE_BF)
14201 {
14202 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14203 {
14204 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14205
14206 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14207
14208 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14209
14210 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14211 }
14212 }
14213 }
14214 else
14215 {
14216 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14217
14218 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14219
14220 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14221
14222 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14223
14224 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14225
14226 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14227
14228 if (opts_type & OPTS_TYPE_HOOK12)
14229 {
14230 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14231
14232 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14233 }
14234
14235 if (opts_type & OPTS_TYPE_HOOK23)
14236 {
14237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14238
14239 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14240 }
14241 }
14242
14243 for (uint i = 0; i <= 20; i++)
14244 {
14245 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14246 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14247 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14248
14249 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14250 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14251 }
14252
14253 for (uint i = 21; i <= 31; i++)
14254 {
14255 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14256 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14257 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14258
14259 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14260 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14261 }
14262
14263 if (attack_mode == ATTACK_MODE_BF)
14264 {
14265 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14266 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14267
14268 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14269 {
14270 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14271
14272 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14273 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14274 }
14275 }
14276 else if (attack_mode == ATTACK_MODE_HYBRID1)
14277 {
14278 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14279 }
14280 else if (attack_mode == ATTACK_MODE_HYBRID2)
14281 {
14282 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14283 }
14284
14285 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14286 {
14287 // nothing to do
14288 }
14289 else
14290 {
14291 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14292 }
14293
14294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14295 {
14296 // nothing to do
14297 }
14298 else
14299 {
14300 for (uint i = 0; i < 5; i++)
14301 {
14302 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14303 }
14304
14305 for (uint i = 5; i < 7; i++)
14306 {
14307 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14308 }
14309 }
14310
14311 /**
14312 * Store initial fanspeed if gpu_temp_retain is enabled
14313 */
14314
14315 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14316 int gpu_temp_retain_set = 0;
14317
14318 if (gpu_temp_disable == 0)
14319 {
14320 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14321 {
14322 hc_thread_mutex_lock (mux_adl);
14323
14324 if (data.hm_device[device_id].fan_supported == 1)
14325 {
14326 if (gpu_temp_retain_chgd == 0)
14327 {
14328 uint cur_temp = 0;
14329 uint default_temp = 0;
14330
14331 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14332
14333 if (ADL_rc == ADL_OK)
14334 {
14335 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14336
14337 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14338
14339 // special case with multi gpu setups: always use minimum retain
14340
14341 if (gpu_temp_retain_set == 0)
14342 {
14343 gpu_temp_retain = gpu_temp_retain_target;
14344 gpu_temp_retain_set = 1;
14345 }
14346 else
14347 {
14348 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14349 }
14350
14351 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14352 }
14353 }
14354
14355 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14356
14357 temp_retain_fanspeed_value[device_id] = fan_speed;
14358
14359 if (fan_speed == -1)
14360 {
14361 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14362
14363 temp_retain_fanspeed_value[device_id] = 0;
14364 }
14365 }
14366
14367 hc_thread_mutex_unlock (mux_adl);
14368 }
14369 }
14370
14371 /**
14372 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14373 */
14374
14375 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14376 {
14377 hc_thread_mutex_lock (mux_adl);
14378
14379 if (data.hm_device[device_id].od_version == 6)
14380 {
14381 int ADL_rc;
14382
14383 // check powertune capabilities first, if not available then skip device
14384
14385 int powertune_supported = 0;
14386
14387 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14388 {
14389 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14390
14391 return (-1);
14392 }
14393
14394 if (powertune_supported != 0)
14395 {
14396 // powercontrol settings
14397
14398 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14399
14400 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14401 {
14402 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14403 }
14404
14405 if (ADL_rc != ADL_OK)
14406 {
14407 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14408
14409 return (-1);
14410 }
14411
14412 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14413 {
14414 log_error ("ERROR: Failed to set new ADL PowerControl values");
14415
14416 return (-1);
14417 }
14418
14419 // clocks
14420
14421 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14422
14423 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14424
14425 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14426 {
14427 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14428
14429 return (-1);
14430 }
14431
14432 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14433
14434 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14435
14436 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14437 {
14438 log_error ("ERROR: Failed to get ADL device capabilities");
14439
14440 return (-1);
14441 }
14442
14443 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14444 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14445
14446 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14447 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14448
14449 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14450 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14451
14452 // warning if profile has too low max values
14453
14454 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14455 {
14456 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14457 }
14458
14459 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14460 {
14461 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14462 }
14463
14464 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14465
14466 performance_state->iNumberOfPerformanceLevels = 2;
14467
14468 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14469 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14470 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14471 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14472
14473 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14474 {
14475 log_info ("ERROR: Failed to set ADL performance state");
14476
14477 return (-1);
14478 }
14479
14480 local_free (performance_state);
14481 }
14482 }
14483
14484 hc_thread_mutex_unlock (mux_adl);
14485 }
14486 #endif // HAVE_HWMON && HAVE_ADL
14487 }
14488
14489 data.kernel_blocks_all = kernel_blocks_all;
14490
14491 if (data.quiet == 0) log_info ("");
14492
14493 /**
14494 * Inform user which algorithm is checked and at which workload setting
14495 */
14496
14497 if (benchmark == 1)
14498 {
14499 quiet = 0;
14500
14501 data.quiet = quiet;
14502
14503 char *hash_type = strhashtype (data.hash_mode); // not a bug
14504
14505 log_info ("Hashtype: %s", hash_type);
14506 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14507 log_info ("");
14508 }
14509
14510 /**
14511 * keep track of the progress
14512 */
14513
14514 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14515 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14516 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14517
14518 /**
14519 * open filehandles
14520 */
14521
14522 #if _WIN
14523 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14524 {
14525 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14526
14527 return (-1);
14528 }
14529
14530 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14531 {
14532 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14533
14534 return (-1);
14535 }
14536
14537 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14538 {
14539 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14540
14541 return (-1);
14542 }
14543 #endif
14544
14545 /**
14546 * dictionary pad
14547 */
14548
14549 segment_size *= (1024 * 1024);
14550
14551 data.segment_size = segment_size;
14552
14553 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14554
14555 wl_data->buf = (char *) mymalloc (segment_size);
14556 wl_data->avail = segment_size;
14557 wl_data->incr = segment_size;
14558 wl_data->cnt = 0;
14559 wl_data->pos = 0;
14560
14561 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14562
14563 data.wordlist_mode = wordlist_mode;
14564
14565 cs_t *css_buf = NULL;
14566 uint css_cnt = 0;
14567 uint dictcnt = 0;
14568 uint maskcnt = 1;
14569 char **masks = NULL;
14570 char **dictfiles = NULL;
14571
14572 uint mask_from_file = 0;
14573
14574 if (attack_mode == ATTACK_MODE_STRAIGHT)
14575 {
14576 if (wordlist_mode == WL_MODE_FILE)
14577 {
14578 int wls_left = myargc - (optind + 1);
14579
14580 for (int i = 0; i < wls_left; i++)
14581 {
14582 char *l0_filename = myargv[optind + 1 + i];
14583
14584 struct stat l0_stat;
14585
14586 if (stat (l0_filename, &l0_stat) == -1)
14587 {
14588 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14589
14590 return (-1);
14591 }
14592
14593 uint is_dir = S_ISDIR (l0_stat.st_mode);
14594
14595 if (is_dir == 0)
14596 {
14597 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14598
14599 dictcnt++;
14600
14601 dictfiles[dictcnt - 1] = l0_filename;
14602 }
14603 else
14604 {
14605 // do not allow --keyspace w/ a directory
14606
14607 if (keyspace == 1)
14608 {
14609 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14610
14611 return (-1);
14612 }
14613
14614 char **dictionary_files = NULL;
14615
14616 dictionary_files = scan_directory (l0_filename);
14617
14618 if (dictionary_files != NULL)
14619 {
14620 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14621
14622 for (int d = 0; dictionary_files[d] != NULL; d++)
14623 {
14624 char *l1_filename = dictionary_files[d];
14625
14626 struct stat l1_stat;
14627
14628 if (stat (l1_filename, &l1_stat) == -1)
14629 {
14630 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14631
14632 return (-1);
14633 }
14634
14635 if (S_ISREG (l1_stat.st_mode))
14636 {
14637 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14638
14639 dictcnt++;
14640
14641 dictfiles[dictcnt - 1] = strdup (l1_filename);
14642 }
14643 }
14644 }
14645
14646 local_free (dictionary_files);
14647 }
14648 }
14649
14650 if (dictcnt < 1)
14651 {
14652 log_error ("ERROR: No usable dictionary file found.");
14653
14654 return (-1);
14655 }
14656 }
14657 else if (wordlist_mode == WL_MODE_STDIN)
14658 {
14659 dictcnt = 1;
14660 }
14661 }
14662 else if (attack_mode == ATTACK_MODE_COMBI)
14663 {
14664 // display
14665
14666 char *dictfile1 = myargv[optind + 1 + 0];
14667 char *dictfile2 = myargv[optind + 1 + 1];
14668
14669 // find the bigger dictionary and use as base
14670
14671 FILE *fp1 = NULL;
14672 FILE *fp2 = NULL;
14673
14674 struct stat tmp_stat;
14675
14676 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14677 {
14678 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14679
14680 return (-1);
14681 }
14682
14683 if (stat (dictfile1, &tmp_stat) == -1)
14684 {
14685 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14686
14687 fclose (fp1);
14688
14689 return (-1);
14690 }
14691
14692 if (S_ISDIR (tmp_stat.st_mode))
14693 {
14694 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14695
14696 fclose (fp1);
14697
14698 return (-1);
14699 }
14700
14701 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14702 {
14703 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14704
14705 fclose (fp1);
14706
14707 return (-1);
14708 }
14709
14710 if (stat (dictfile2, &tmp_stat) == -1)
14711 {
14712 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14713
14714 fclose (fp1);
14715 fclose (fp2);
14716
14717 return (-1);
14718 }
14719
14720 if (S_ISDIR (tmp_stat.st_mode))
14721 {
14722 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14723
14724 fclose (fp1);
14725 fclose (fp2);
14726
14727 return (-1);
14728 }
14729
14730 data.combs_cnt = 1;
14731
14732 data.quiet = 1;
14733
14734 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14735
14736 data.quiet = quiet;
14737
14738 if (words1_cnt == 0)
14739 {
14740 log_error ("ERROR: %s: empty file", dictfile1);
14741
14742 fclose (fp1);
14743 fclose (fp2);
14744
14745 return (-1);
14746 }
14747
14748 data.combs_cnt = 1;
14749
14750 data.quiet = 1;
14751
14752 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14753
14754 data.quiet = quiet;
14755
14756 if (words2_cnt == 0)
14757 {
14758 log_error ("ERROR: %s: empty file", dictfile2);
14759
14760 fclose (fp1);
14761 fclose (fp2);
14762
14763 return (-1);
14764 }
14765
14766 fclose (fp1);
14767 fclose (fp2);
14768
14769 data.dictfile = dictfile1;
14770 data.dictfile2 = dictfile2;
14771
14772 if (words1_cnt >= words2_cnt)
14773 {
14774 data.combs_cnt = words2_cnt;
14775 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14776
14777 dictfiles = &data.dictfile;
14778
14779 dictcnt = 1;
14780 }
14781 else
14782 {
14783 data.combs_cnt = words1_cnt;
14784 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14785
14786 dictfiles = &data.dictfile2;
14787
14788 dictcnt = 1;
14789
14790 // we also have to switch wordlist related rules!
14791
14792 char *tmpc = data.rule_buf_l;
14793
14794 data.rule_buf_l = data.rule_buf_r;
14795 data.rule_buf_r = tmpc;
14796
14797 int tmpi = data.rule_len_l;
14798
14799 data.rule_len_l = data.rule_len_r;
14800 data.rule_len_r = tmpi;
14801 }
14802 }
14803 else if (attack_mode == ATTACK_MODE_BF)
14804 {
14805 char *mask = NULL;
14806
14807 maskcnt = 0;
14808
14809 if (benchmark == 0)
14810 {
14811 mask = myargv[optind + 1];
14812
14813 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14814
14815 if ((optind + 2) <= myargc)
14816 {
14817 struct stat file_stat;
14818
14819 if (stat (mask, &file_stat) == -1)
14820 {
14821 maskcnt = 1;
14822
14823 masks[maskcnt - 1] = mystrdup (mask);
14824 }
14825 else
14826 {
14827 int wls_left = myargc - (optind + 1);
14828
14829 uint masks_avail = INCR_MASKS;
14830
14831 for (int i = 0; i < wls_left; i++)
14832 {
14833 if (i != 0)
14834 {
14835 mask = myargv[optind + 1 + i];
14836
14837 if (stat (mask, &file_stat) == -1)
14838 {
14839 log_error ("ERROR: %s: %s", mask, strerror (errno));
14840
14841 return (-1);
14842 }
14843 }
14844
14845 uint is_file = S_ISREG (file_stat.st_mode);
14846
14847 if (is_file == 1)
14848 {
14849 FILE *mask_fp;
14850
14851 if ((mask_fp = fopen (mask, "r")) == NULL)
14852 {
14853 log_error ("ERROR: %s: %s", mask, strerror (errno));
14854
14855 return (-1);
14856 }
14857
14858 char line_buf[BUFSIZ] = { 0 };
14859
14860 while (!feof (mask_fp))
14861 {
14862 memset (line_buf, 0, BUFSIZ);
14863
14864 int line_len = fgetl (mask_fp, line_buf);
14865
14866 if (line_len == 0) continue;
14867
14868 if (line_buf[0] == '#') continue;
14869
14870 if (masks_avail == maskcnt)
14871 {
14872 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14873
14874 masks_avail += INCR_MASKS;
14875 }
14876
14877 masks[maskcnt] = mystrdup (line_buf);
14878
14879 maskcnt++;
14880 }
14881
14882 fclose (mask_fp);
14883 }
14884 else
14885 {
14886 log_error ("ERROR: %s: unsupported file-type", mask);
14887
14888 return (-1);
14889 }
14890 }
14891
14892 mask_from_file = 1;
14893 }
14894 }
14895 else
14896 {
14897 custom_charset_1 = (char *) "?l?d?u";
14898 custom_charset_2 = (char *) "?l?d";
14899 custom_charset_3 = (char *) "?l?d*!$@_";
14900
14901 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14902 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14903 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14904
14905 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14906
14907 wordlist_mode = WL_MODE_MASK;
14908
14909 data.wordlist_mode = wordlist_mode;
14910
14911 increment = 1;
14912
14913 maskcnt = 1;
14914 }
14915 }
14916 else
14917 {
14918 /**
14919 * generate full masks and charsets
14920 */
14921
14922 masks = (char **) mymalloc (sizeof (char *));
14923
14924 switch (hash_mode)
14925 {
14926 case 1731: pw_min = 5;
14927 pw_max = 5;
14928 mask = mystrdup ("?b?b?b?b?b");
14929 break;
14930 case 12500: pw_min = 5;
14931 pw_max = 5;
14932 mask = mystrdup ("?b?b?b?b?b");
14933 break;
14934 default: pw_min = 7;
14935 pw_max = 7;
14936 mask = mystrdup ("?b?b?b?b?b?b?b");
14937 break;
14938 }
14939
14940 maskcnt = 1;
14941
14942 masks[maskcnt - 1] = mystrdup (mask);
14943
14944 wordlist_mode = WL_MODE_MASK;
14945
14946 data.wordlist_mode = wordlist_mode;
14947
14948 increment = 1;
14949 }
14950
14951 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14952
14953 if (increment)
14954 {
14955 if (increment_min > pw_min) pw_min = increment_min;
14956
14957 if (increment_max < pw_max) pw_max = increment_max;
14958 }
14959 }
14960 else if (attack_mode == ATTACK_MODE_HYBRID1)
14961 {
14962 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14963
14964 // display
14965
14966 char *mask = myargv[myargc - 1];
14967
14968 maskcnt = 0;
14969
14970 masks = (char **) mymalloc (1 * sizeof (char *));
14971
14972 // mod
14973
14974 struct stat file_stat;
14975
14976 if (stat (mask, &file_stat) == -1)
14977 {
14978 maskcnt = 1;
14979
14980 masks[maskcnt - 1] = mystrdup (mask);
14981 }
14982 else
14983 {
14984 uint is_file = S_ISREG (file_stat.st_mode);
14985
14986 if (is_file == 1)
14987 {
14988 FILE *mask_fp;
14989
14990 if ((mask_fp = fopen (mask, "r")) == NULL)
14991 {
14992 log_error ("ERROR: %s: %s", mask, strerror (errno));
14993
14994 return (-1);
14995 }
14996
14997 char line_buf[BUFSIZ] = { 0 };
14998
14999 uint masks_avail = 1;
15000
15001 while (!feof (mask_fp))
15002 {
15003 memset (line_buf, 0, BUFSIZ);
15004
15005 int line_len = fgetl (mask_fp, line_buf);
15006
15007 if (line_len == 0) continue;
15008
15009 if (line_buf[0] == '#') continue;
15010
15011 if (masks_avail == maskcnt)
15012 {
15013 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15014
15015 masks_avail += INCR_MASKS;
15016 }
15017
15018 masks[maskcnt] = mystrdup (line_buf);
15019
15020 maskcnt++;
15021 }
15022
15023 fclose (mask_fp);
15024
15025 mask_from_file = 1;
15026 }
15027 else
15028 {
15029 maskcnt = 1;
15030
15031 masks[maskcnt - 1] = mystrdup (mask);
15032 }
15033 }
15034
15035 // base
15036
15037 int wls_left = myargc - (optind + 2);
15038
15039 for (int i = 0; i < wls_left; i++)
15040 {
15041 char *filename = myargv[optind + 1 + i];
15042
15043 struct stat file_stat;
15044
15045 if (stat (filename, &file_stat) == -1)
15046 {
15047 log_error ("ERROR: %s: %s", filename, strerror (errno));
15048
15049 return (-1);
15050 }
15051
15052 uint is_dir = S_ISDIR (file_stat.st_mode);
15053
15054 if (is_dir == 0)
15055 {
15056 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15057
15058 dictcnt++;
15059
15060 dictfiles[dictcnt - 1] = filename;
15061 }
15062 else
15063 {
15064 // do not allow --keyspace w/ a directory
15065
15066 if (keyspace == 1)
15067 {
15068 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15069
15070 return (-1);
15071 }
15072
15073 char **dictionary_files = NULL;
15074
15075 dictionary_files = scan_directory (filename);
15076
15077 if (dictionary_files != NULL)
15078 {
15079 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15080
15081 for (int d = 0; dictionary_files[d] != NULL; d++)
15082 {
15083 char *l1_filename = dictionary_files[d];
15084
15085 struct stat l1_stat;
15086
15087 if (stat (l1_filename, &l1_stat) == -1)
15088 {
15089 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15090
15091 return (-1);
15092 }
15093
15094 if (S_ISREG (l1_stat.st_mode))
15095 {
15096 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15097
15098 dictcnt++;
15099
15100 dictfiles[dictcnt - 1] = strdup (l1_filename);
15101 }
15102 }
15103 }
15104
15105 local_free (dictionary_files);
15106 }
15107 }
15108
15109 if (dictcnt < 1)
15110 {
15111 log_error ("ERROR: No usable dictionary file found.");
15112
15113 return (-1);
15114 }
15115
15116 if (increment)
15117 {
15118 maskcnt = 0;
15119
15120 uint mask_min = increment_min; // we can't reject smaller masks here
15121 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15122
15123 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15124 {
15125 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15126
15127 if (cur_mask == NULL) break;
15128
15129 masks[maskcnt] = cur_mask;
15130
15131 maskcnt++;
15132
15133 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15134 }
15135 }
15136 }
15137 else if (attack_mode == ATTACK_MODE_HYBRID2)
15138 {
15139 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15140
15141 // display
15142
15143 char *mask = myargv[optind + 1 + 0];
15144
15145 maskcnt = 0;
15146
15147 masks = (char **) mymalloc (1 * sizeof (char *));
15148
15149 // mod
15150
15151 struct stat file_stat;
15152
15153 if (stat (mask, &file_stat) == -1)
15154 {
15155 maskcnt = 1;
15156
15157 masks[maskcnt - 1] = mystrdup (mask);
15158 }
15159 else
15160 {
15161 uint is_file = S_ISREG (file_stat.st_mode);
15162
15163 if (is_file == 1)
15164 {
15165 FILE *mask_fp;
15166
15167 if ((mask_fp = fopen (mask, "r")) == NULL)
15168 {
15169 log_error ("ERROR: %s: %s", mask, strerror (errno));
15170
15171 return (-1);
15172 }
15173
15174 char line_buf[BUFSIZ] = { 0 };
15175
15176 uint masks_avail = 1;
15177
15178 while (!feof (mask_fp))
15179 {
15180 memset (line_buf, 0, BUFSIZ);
15181
15182 int line_len = fgetl (mask_fp, line_buf);
15183
15184 if (line_len == 0) continue;
15185
15186 if (line_buf[0] == '#') continue;
15187
15188 if (masks_avail == maskcnt)
15189 {
15190 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15191
15192 masks_avail += INCR_MASKS;
15193 }
15194
15195 masks[maskcnt] = mystrdup (line_buf);
15196
15197 maskcnt++;
15198 }
15199
15200 fclose (mask_fp);
15201
15202 mask_from_file = 1;
15203 }
15204 else
15205 {
15206 maskcnt = 1;
15207
15208 masks[maskcnt - 1] = mystrdup (mask);
15209 }
15210 }
15211
15212 // base
15213
15214 int wls_left = myargc - (optind + 2);
15215
15216 for (int i = 0; i < wls_left; i++)
15217 {
15218 char *filename = myargv[optind + 2 + i];
15219
15220 struct stat file_stat;
15221
15222 if (stat (filename, &file_stat) == -1)
15223 {
15224 log_error ("ERROR: %s: %s", filename, strerror (errno));
15225
15226 return (-1);
15227 }
15228
15229 uint is_dir = S_ISDIR (file_stat.st_mode);
15230
15231 if (is_dir == 0)
15232 {
15233 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15234
15235 dictcnt++;
15236
15237 dictfiles[dictcnt - 1] = filename;
15238 }
15239 else
15240 {
15241 // do not allow --keyspace w/ a directory
15242
15243 if (keyspace == 1)
15244 {
15245 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15246
15247 return (-1);
15248 }
15249
15250 char **dictionary_files = NULL;
15251
15252 dictionary_files = scan_directory (filename);
15253
15254 if (dictionary_files != NULL)
15255 {
15256 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15257
15258 for (int d = 0; dictionary_files[d] != NULL; d++)
15259 {
15260 char *l1_filename = dictionary_files[d];
15261
15262 struct stat l1_stat;
15263
15264 if (stat (l1_filename, &l1_stat) == -1)
15265 {
15266 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15267
15268 return (-1);
15269 }
15270
15271 if (S_ISREG (l1_stat.st_mode))
15272 {
15273 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15274
15275 dictcnt++;
15276
15277 dictfiles[dictcnt - 1] = strdup (l1_filename);
15278 }
15279 }
15280 }
15281
15282 local_free (dictionary_files);
15283 }
15284 }
15285
15286 if (dictcnt < 1)
15287 {
15288 log_error ("ERROR: No usable dictionary file found.");
15289
15290 return (-1);
15291 }
15292
15293 if (increment)
15294 {
15295 maskcnt = 0;
15296
15297 uint mask_min = increment_min; // we can't reject smaller masks here
15298 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15299
15300 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15301 {
15302 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15303
15304 if (cur_mask == NULL) break;
15305
15306 masks[maskcnt] = cur_mask;
15307
15308 maskcnt++;
15309
15310 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15311 }
15312 }
15313 }
15314
15315 data.pw_min = pw_min;
15316 data.pw_max = pw_max;
15317
15318 /**
15319 * weak hash check
15320 */
15321
15322 if (weak_hash_threshold >= salts_cnt)
15323 {
15324 uint first_device_id = 0;
15325
15326 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15327 {
15328 hc_device_param_t *device_param = &data.devices_param[device_id];
15329
15330 if (device_param->skipped) continue;
15331
15332 first_device_id = device_id;
15333
15334 break;
15335 }
15336
15337 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15338
15339 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15340 {
15341 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15342 }
15343 }
15344
15345 // Display hack, guarantee that there is at least one \r before real start
15346
15347 if (data.quiet == 0) log_info_nn ("");
15348
15349 /**
15350 * status and monitor threads
15351 */
15352
15353 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15354
15355 hc_thread_t i_thread = 0;
15356
15357 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15358 {
15359 hc_thread_create (i_thread, thread_keypress, &benchmark);
15360 }
15361
15362 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15363
15364 uint ni_threads_cnt = 0;
15365
15366 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15367
15368 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15369
15370 ni_threads_cnt++;
15371
15372 /**
15373 * Outfile remove
15374 */
15375
15376 if (keyspace == 0)
15377 {
15378 if (outfile_check_timer != 0)
15379 {
15380 if (data.outfile_check_directory != NULL)
15381 {
15382 if ((hash_mode != 5200) &&
15383 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15384 (hash_mode != 9000))
15385 {
15386 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15387
15388 ni_threads_cnt++;
15389 }
15390 else
15391 {
15392 outfile_check_timer = 0;
15393 }
15394 }
15395 else
15396 {
15397 outfile_check_timer = 0;
15398 }
15399 }
15400 }
15401
15402 /**
15403 * Inform the user if we got some hashes remove because of the pot file remove feature
15404 */
15405
15406 if (data.quiet == 0)
15407 {
15408 if (potfile_remove_cracks > 0)
15409 {
15410 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15411 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15412 }
15413 }
15414
15415 data.outfile_check_timer = outfile_check_timer;
15416
15417 /**
15418 * main loop
15419 */
15420
15421 char **induction_dictionaries = NULL;
15422
15423 int induction_dictionaries_cnt = 0;
15424
15425 hcstat_table_t *root_table_buf = NULL;
15426 hcstat_table_t *markov_table_buf = NULL;
15427
15428 uint initial_restore_done = 0;
15429
15430 data.maskcnt = maskcnt;
15431
15432 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15433 {
15434 if (data.devices_status == STATUS_CRACKED) break;
15435
15436 data.devices_status = STATUS_INIT;
15437
15438 if (maskpos > rd->maskpos)
15439 {
15440 rd->dictpos = 0;
15441 }
15442
15443 rd->maskpos = maskpos;
15444 data.maskpos = maskpos;
15445
15446 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15447 {
15448 char *mask = masks[maskpos];
15449
15450 if (mask_from_file == 1)
15451 {
15452 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15453
15454 char *str_ptr;
15455 uint str_pos;
15456
15457 uint mask_offset = 0;
15458
15459 uint separator_cnt;
15460
15461 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15462 {
15463 str_ptr = strstr (mask + mask_offset, ",");
15464
15465 if (str_ptr == NULL) break;
15466
15467 str_pos = str_ptr - mask;
15468
15469 // escaped separator, i.e. "\,"
15470
15471 if (str_pos > 0)
15472 {
15473 if (mask[str_pos - 1] == '\\')
15474 {
15475 separator_cnt --;
15476
15477 mask_offset = str_pos + 1;
15478
15479 continue;
15480 }
15481 }
15482
15483 // reset the offset
15484
15485 mask_offset = 0;
15486
15487 mask[str_pos] = '\0';
15488
15489 switch (separator_cnt)
15490 {
15491 case 0:
15492 mp_reset_usr (mp_usr, 0);
15493
15494 custom_charset_1 = mask;
15495 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15496 break;
15497
15498 case 1:
15499 mp_reset_usr (mp_usr, 1);
15500
15501 custom_charset_2 = mask;
15502 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15503 break;
15504
15505 case 2:
15506 mp_reset_usr (mp_usr, 2);
15507
15508 custom_charset_3 = mask;
15509 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15510 break;
15511
15512 case 3:
15513 mp_reset_usr (mp_usr, 3);
15514
15515 custom_charset_4 = mask;
15516 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15517 break;
15518 }
15519
15520 mask = mask + str_pos + 1;
15521 }
15522 }
15523
15524 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15525 {
15526 if (maskpos > 0)
15527 {
15528 local_free (css_buf);
15529 local_free (data.root_css_buf);
15530 local_free (data.markov_css_buf);
15531
15532 local_free (masks[maskpos - 1]);
15533 }
15534
15535 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15536
15537 data.mask = mask;
15538 data.css_cnt = css_cnt;
15539 data.css_buf = css_buf;
15540
15541 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15542
15543 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15544
15545 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15546 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15547
15548 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15549
15550 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15551
15552 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15553 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15554
15555 data.root_css_buf = root_css_buf;
15556 data.markov_css_buf = markov_css_buf;
15557
15558 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15559
15560 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15561
15562 local_free (root_table_buf);
15563 local_free (markov_table_buf);
15564
15565 // args
15566
15567 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15568 {
15569 hc_device_param_t *device_param = &data.devices_param[device_id];
15570
15571 if (device_param->skipped) continue;
15572
15573 device_param->kernel_params_mp[0] = &device_param->d_combs;
15574 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15575 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15576
15577 device_param->kernel_params_mp_buf64[3] = 0;
15578 device_param->kernel_params_mp_buf32[4] = css_cnt;
15579 device_param->kernel_params_mp_buf32[5] = 0;
15580 device_param->kernel_params_mp_buf32[6] = 0;
15581 device_param->kernel_params_mp_buf32[7] = 0;
15582
15583 if (attack_mode == ATTACK_MODE_HYBRID1)
15584 {
15585 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15586 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15587 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15588 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15589 }
15590 else if (attack_mode == ATTACK_MODE_HYBRID2)
15591 {
15592 device_param->kernel_params_mp_buf32[5] = 0;
15593 device_param->kernel_params_mp_buf32[6] = 0;
15594 device_param->kernel_params_mp_buf32[7] = 0;
15595 }
15596
15597 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]);
15598 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]);
15599 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]);
15600
15601 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);
15602 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);
15603 }
15604 }
15605 else if (attack_mode == ATTACK_MODE_BF)
15606 {
15607 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15608
15609 if (increment)
15610 {
15611 for (uint i = 0; i < dictcnt; i++)
15612 {
15613 local_free (dictfiles[i]);
15614 }
15615
15616 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15617 {
15618 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15619
15620 if (l1_filename == NULL) break;
15621
15622 dictcnt++;
15623
15624 dictfiles[dictcnt - 1] = l1_filename;
15625 }
15626 }
15627 else
15628 {
15629 dictcnt++;
15630
15631 dictfiles[dictcnt - 1] = mask;
15632 }
15633
15634 if (dictcnt == 0)
15635 {
15636 log_error ("ERROR: Mask is too small");
15637
15638 return (-1);
15639 }
15640 }
15641 }
15642
15643 free (induction_dictionaries);
15644
15645 // induction_dictionaries_cnt = 0; // implied
15646
15647 if (attack_mode != ATTACK_MODE_BF)
15648 {
15649 if (keyspace == 0)
15650 {
15651 induction_dictionaries = scan_directory (induction_directory);
15652
15653 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15654 }
15655 }
15656
15657 if (induction_dictionaries_cnt)
15658 {
15659 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15660 }
15661
15662 /**
15663 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15664 */
15665 if (keyspace == 1)
15666 {
15667 if ((maskcnt > 1) || (dictcnt > 1))
15668 {
15669 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15670
15671 return (-1);
15672 }
15673 }
15674
15675 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15676 {
15677 char *subid = logfile_generate_subid ();
15678
15679 data.subid = subid;
15680
15681 logfile_sub_msg ("START");
15682
15683 data.devices_status = STATUS_INIT;
15684
15685 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15686 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15687 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15688
15689 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15690
15691 data.cpt_pos = 0;
15692
15693 data.cpt_start = time (NULL);
15694
15695 data.cpt_total = 0;
15696
15697 if (data.restore == 0)
15698 {
15699 rd->words_cur = skip;
15700
15701 skip = 0;
15702
15703 data.skip = 0;
15704 }
15705
15706 data.ms_paused = 0;
15707
15708 data.words_cur = rd->words_cur;
15709
15710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15711 {
15712 hc_device_param_t *device_param = &data.devices_param[device_id];
15713
15714 if (device_param->skipped) continue;
15715
15716 device_param->speed_pos = 0;
15717
15718 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15719 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15720 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15721
15722 device_param->kernel_power = device_param->kernel_power_user;
15723 device_param->kernel_blocks = device_param->kernel_blocks_user;
15724
15725 device_param->outerloop_pos = 0;
15726 device_param->outerloop_left = 0;
15727 device_param->innerloop_pos = 0;
15728 device_param->innerloop_left = 0;
15729
15730 // some more resets:
15731
15732 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15733
15734 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15735
15736 device_param->pw_cnt = 0;
15737 device_param->pws_cnt = 0;
15738
15739 device_param->words_off = 0;
15740 device_param->words_done = 0;
15741 }
15742
15743 data.kernel_blocks_div = 0;
15744
15745 // figure out some workload
15746
15747 if (attack_mode == ATTACK_MODE_STRAIGHT)
15748 {
15749 if (data.wordlist_mode == WL_MODE_FILE)
15750 {
15751 char *dictfile = NULL;
15752
15753 if (induction_dictionaries_cnt)
15754 {
15755 dictfile = induction_dictionaries[0];
15756 }
15757 else
15758 {
15759 dictfile = dictfiles[dictpos];
15760 }
15761
15762 data.dictfile = dictfile;
15763
15764 logfile_sub_string (dictfile);
15765
15766 for (uint i = 0; i < rp_files_cnt; i++)
15767 {
15768 logfile_sub_var_string ("rulefile", rp_files[i]);
15769 }
15770
15771 FILE *fd2 = fopen (dictfile, "rb");
15772
15773 if (fd2 == NULL)
15774 {
15775 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15776
15777 return (-1);
15778 }
15779
15780 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15781
15782 fclose (fd2);
15783
15784 if (data.words_cnt == 0)
15785 {
15786 if (data.devices_status == STATUS_CRACKED) break;
15787 if (data.devices_status == STATUS_ABORTED) break;
15788
15789 dictpos++;
15790
15791 continue;
15792 }
15793 }
15794 }
15795 else if (attack_mode == ATTACK_MODE_COMBI)
15796 {
15797 char *dictfile = data.dictfile;
15798 char *dictfile2 = data.dictfile2;
15799
15800 logfile_sub_string (dictfile);
15801 logfile_sub_string (dictfile2);
15802
15803 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15804 {
15805 FILE *fd2 = fopen (dictfile, "rb");
15806
15807 if (fd2 == NULL)
15808 {
15809 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15810
15811 return (-1);
15812 }
15813
15814 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15815
15816 fclose (fd2);
15817 }
15818 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15819 {
15820 FILE *fd2 = fopen (dictfile2, "rb");
15821
15822 if (fd2 == NULL)
15823 {
15824 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15825
15826 return (-1);
15827 }
15828
15829 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15830
15831 fclose (fd2);
15832 }
15833
15834 if (data.words_cnt == 0)
15835 {
15836 if (data.devices_status == STATUS_CRACKED) break;
15837 if (data.devices_status == STATUS_ABORTED) break;
15838
15839 dictpos++;
15840
15841 continue;
15842 }
15843 }
15844 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15845 {
15846 char *dictfile = NULL;
15847
15848 if (induction_dictionaries_cnt)
15849 {
15850 dictfile = induction_dictionaries[0];
15851 }
15852 else
15853 {
15854 dictfile = dictfiles[dictpos];
15855 }
15856
15857 data.dictfile = dictfile;
15858
15859 char *mask = data.mask;
15860
15861 logfile_sub_string (dictfile);
15862 logfile_sub_string (mask);
15863
15864 FILE *fd2 = fopen (dictfile, "rb");
15865
15866 if (fd2 == NULL)
15867 {
15868 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15869
15870 return (-1);
15871 }
15872
15873 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15874
15875 fclose (fd2);
15876
15877 if (data.words_cnt == 0)
15878 {
15879 if (data.devices_status == STATUS_CRACKED) break;
15880 if (data.devices_status == STATUS_ABORTED) break;
15881
15882 dictpos++;
15883
15884 continue;
15885 }
15886 }
15887 else if (attack_mode == ATTACK_MODE_BF)
15888 {
15889 local_free (css_buf);
15890 local_free (data.root_css_buf);
15891 local_free (data.markov_css_buf);
15892
15893 char *mask = dictfiles[dictpos];
15894
15895 logfile_sub_string (mask);
15896
15897 // base
15898
15899 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15900
15901 if (opts_type & OPTS_TYPE_PT_UNICODE)
15902 {
15903 uint css_cnt_unicode = css_cnt * 2;
15904
15905 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15906
15907 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15908 {
15909 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15910
15911 css_buf_unicode[j + 1].cs_buf[0] = 0;
15912 css_buf_unicode[j + 1].cs_len = 1;
15913 }
15914
15915 free (css_buf);
15916
15917 css_buf = css_buf_unicode;
15918 css_cnt = css_cnt_unicode;
15919 }
15920
15921 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15922
15923 uint mask_min = pw_min;
15924 uint mask_max = pw_max;
15925
15926 if (opts_type & OPTS_TYPE_PT_UNICODE)
15927 {
15928 mask_min *= 2;
15929 mask_max *= 2;
15930 }
15931
15932 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15933 {
15934 if (css_cnt < mask_min)
15935 {
15936 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15937 }
15938
15939 if (css_cnt > mask_max)
15940 {
15941 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15942 }
15943
15944 // skip to next mask
15945
15946 dictpos++;
15947
15948 rd->dictpos = dictpos;
15949
15950 logfile_sub_msg ("STOP");
15951
15952 continue;
15953 }
15954
15955 uint save_css_cnt = css_cnt;
15956
15957 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15958 {
15959 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15960 {
15961 uint salt_len = (uint) data.salts_buf[0].salt_len;
15962 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15963
15964 uint css_cnt_salt = css_cnt + salt_len;
15965
15966 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15967
15968 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15969
15970 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15971 {
15972 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15973 css_buf_salt[j].cs_len = 1;
15974 }
15975
15976 free (css_buf);
15977
15978 css_buf = css_buf_salt;
15979 css_cnt = css_cnt_salt;
15980 }
15981 }
15982
15983 data.mask = mask;
15984 data.css_cnt = css_cnt;
15985 data.css_buf = css_buf;
15986
15987 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15988
15989 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15990
15991 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15992
15993 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15994 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15995
15996 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15997
15998 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15999
16000 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16001 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16002
16003 data.root_css_buf = root_css_buf;
16004 data.markov_css_buf = markov_css_buf;
16005
16006 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16007
16008 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16009
16010 local_free (root_table_buf);
16011 local_free (markov_table_buf);
16012
16013 // copy + args
16014
16015 uint css_cnt_l = css_cnt;
16016 uint css_cnt_r;
16017
16018 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16019 {
16020 if (save_css_cnt < 6)
16021 {
16022 css_cnt_r = 1;
16023 }
16024 else if (save_css_cnt == 6)
16025 {
16026 css_cnt_r = 2;
16027 }
16028 else
16029 {
16030 if (opts_type & OPTS_TYPE_PT_UNICODE)
16031 {
16032 if (save_css_cnt == 8 || save_css_cnt == 10)
16033 {
16034 css_cnt_r = 2;
16035 }
16036 else
16037 {
16038 css_cnt_r = 4;
16039 }
16040 }
16041 else
16042 {
16043 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16044 {
16045 css_cnt_r = 3;
16046 }
16047 else
16048 {
16049 css_cnt_r = 4;
16050 }
16051 }
16052 }
16053 }
16054 else
16055 {
16056 css_cnt_r = 1;
16057
16058 /* unfinished code?
16059 int sum = css_buf[css_cnt_r - 1].cs_len;
16060
16061 for (uint i = 1; i < 4 && i < css_cnt; i++)
16062 {
16063 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16064
16065 css_cnt_r++;
16066
16067 sum *= css_buf[css_cnt_r - 1].cs_len;
16068 }
16069 */
16070 }
16071
16072 css_cnt_l -= css_cnt_r;
16073
16074 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16075
16076 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16077 {
16078 hc_device_param_t *device_param = &data.devices_param[device_id];
16079
16080 if (device_param->skipped) continue;
16081
16082 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16083 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16084 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16085
16086 device_param->kernel_params_mp_l_buf64[3] = 0;
16087 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16088 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16089 device_param->kernel_params_mp_l_buf32[6] = 0;
16090 device_param->kernel_params_mp_l_buf32[7] = 0;
16091 device_param->kernel_params_mp_l_buf32[8] = 0;
16092
16093 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16094 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16095 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16096 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16097
16098 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16099 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16100 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16101
16102 device_param->kernel_params_mp_r_buf64[3] = 0;
16103 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16104 device_param->kernel_params_mp_r_buf32[5] = 0;
16105 device_param->kernel_params_mp_r_buf32[6] = 0;
16106 device_param->kernel_params_mp_r_buf32[7] = 0;
16107
16108 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]);
16109 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]);
16110 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]);
16111
16112 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]);
16113 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]);
16114 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]);
16115
16116 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);
16117 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);
16118 }
16119 }
16120
16121 u64 words_base = data.words_cnt;
16122
16123 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16124 {
16125 if (data.kernel_rules_cnt)
16126 {
16127 words_base /= data.kernel_rules_cnt;
16128 }
16129 }
16130 else if (data.attack_kern == ATTACK_KERN_COMBI)
16131 {
16132 if (data.combs_cnt)
16133 {
16134 words_base /= data.combs_cnt;
16135 }
16136 }
16137 else if (data.attack_kern == ATTACK_KERN_BF)
16138 {
16139 if (data.bfs_cnt)
16140 {
16141 words_base /= data.bfs_cnt;
16142 }
16143 }
16144
16145 data.words_base = words_base;
16146
16147 if (keyspace == 1)
16148 {
16149 log_info ("%llu", (unsigned long long int) words_base);
16150
16151 return (0);
16152 }
16153
16154 if (data.words_cur > data.words_base)
16155 {
16156 log_error ("ERROR: restore value greater keyspace");
16157
16158 return (-1);
16159 }
16160
16161 if (data.words_cur)
16162 {
16163 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16164 {
16165 for (uint i = 0; i < data.salts_cnt; i++)
16166 {
16167 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16168 }
16169 }
16170 else if (data.attack_kern == ATTACK_KERN_COMBI)
16171 {
16172 for (uint i = 0; i < data.salts_cnt; i++)
16173 {
16174 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16175 }
16176 }
16177 else if (data.attack_kern == ATTACK_KERN_BF)
16178 {
16179 for (uint i = 0; i < data.salts_cnt; i++)
16180 {
16181 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16182 }
16183 }
16184 }
16185
16186 /*
16187 * Inform user about possible slow speeds
16188 */
16189
16190 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16191 {
16192 if (data.words_base < kernel_blocks_all)
16193 {
16194 if (quiet == 0)
16195 {
16196 log_info ("");
16197 log_info ("ATTENTION!");
16198 log_info (" The wordlist or mask you are using is too small.");
16199 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16200 log_info (" The cracking speed will drop.");
16201 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16202 log_info ("");
16203 }
16204 }
16205 }
16206
16207 /*
16208 * Update loopback file
16209 */
16210
16211 if (loopback == 1)
16212 {
16213 time_t now;
16214
16215 time (&now);
16216
16217 uint random_num = get_random_num (0, 9999);
16218
16219 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16220
16221 data.loopback_file = loopback_file;
16222 }
16223
16224 /*
16225 * Update dictionary statistic
16226 */
16227
16228 if (keyspace == 0)
16229 {
16230 dictstat_fp = fopen (dictstat, "wb");
16231
16232 if (dictstat_fp)
16233 {
16234 lock_file (dictstat_fp);
16235
16236 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16237
16238 fclose (dictstat_fp);
16239 }
16240 }
16241
16242 data.devices_status = STATUS_RUNNING;
16243
16244 if (initial_restore_done == 0)
16245 {
16246 if (data.restore_disable == 0) cycle_restore ();
16247
16248 initial_restore_done = 1;
16249 }
16250
16251 hc_timer_set (&data.timer_running);
16252
16253 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16254 {
16255 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16256 {
16257 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16258 if (quiet == 0) fflush (stdout);
16259 }
16260 }
16261 else if (wordlist_mode == WL_MODE_STDIN)
16262 {
16263 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16264 if (data.quiet == 0) log_info ("");
16265 }
16266
16267 time_t runtime_start;
16268
16269 time (&runtime_start);
16270
16271 data.runtime_start = runtime_start;
16272
16273 /**
16274 * create cracker threads
16275 */
16276
16277 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16278
16279 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16280 {
16281 hc_device_param_t *device_param = &devices_param[device_id];
16282
16283 if (wordlist_mode == WL_MODE_STDIN)
16284 {
16285 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16286 }
16287 else
16288 {
16289 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16290 }
16291 }
16292
16293 // wait for crack threads to exit
16294
16295 hc_thread_wait (devices_cnt, c_threads);
16296
16297 local_free (c_threads);
16298
16299 data.restore = 0;
16300
16301 // finalize task
16302
16303 logfile_sub_var_uint ("status-after-work", data.devices_status);
16304
16305 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16306
16307 if (data.devices_status == STATUS_CRACKED) break;
16308 if (data.devices_status == STATUS_ABORTED) break;
16309
16310 if (data.devices_status == STATUS_BYPASS)
16311 {
16312 data.devices_status = STATUS_RUNNING;
16313 }
16314
16315 if (induction_dictionaries_cnt)
16316 {
16317 unlink (induction_dictionaries[0]);
16318 }
16319
16320 free (induction_dictionaries);
16321
16322 if (attack_mode != ATTACK_MODE_BF)
16323 {
16324 induction_dictionaries = scan_directory (induction_directory);
16325
16326 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16327 }
16328
16329 if (benchmark == 0)
16330 {
16331 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16332 {
16333 if (quiet == 0) clear_prompt ();
16334
16335 if (quiet == 0) log_info ("");
16336
16337 if (status == 1)
16338 {
16339 status_display ();
16340 }
16341 else
16342 {
16343 if (quiet == 0) status_display ();
16344 }
16345
16346 if (quiet == 0) log_info ("");
16347 }
16348 }
16349
16350 if (attack_mode == ATTACK_MODE_BF)
16351 {
16352 dictpos++;
16353
16354 rd->dictpos = dictpos;
16355 }
16356 else
16357 {
16358 if (induction_dictionaries_cnt)
16359 {
16360 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16361 }
16362 else
16363 {
16364 dictpos++;
16365
16366 rd->dictpos = dictpos;
16367 }
16368 }
16369
16370 time_t runtime_stop;
16371
16372 time (&runtime_stop);
16373
16374 data.runtime_stop = runtime_stop;
16375
16376 logfile_sub_uint (runtime_start);
16377 logfile_sub_uint (runtime_stop);
16378
16379 logfile_sub_msg ("STOP");
16380
16381 global_free (subid);
16382 }
16383
16384 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16385
16386 if (data.devices_status == STATUS_CRACKED) break;
16387 if (data.devices_status == STATUS_ABORTED) break;
16388 if (data.devices_status == STATUS_QUIT) break;
16389
16390 if (data.devices_status == STATUS_BYPASS)
16391 {
16392 data.devices_status = STATUS_RUNNING;
16393 }
16394 }
16395
16396 // 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
16397
16398 if (attack_mode == ATTACK_MODE_STRAIGHT)
16399 {
16400 if (data.wordlist_mode == WL_MODE_FILE)
16401 {
16402 if (data.dictfile == NULL)
16403 {
16404 if (dictfiles != NULL)
16405 {
16406 data.dictfile = dictfiles[0];
16407
16408 hc_timer_set (&data.timer_running);
16409 }
16410 }
16411 }
16412 }
16413 // NOTE: combi is okay because it is already set beforehand
16414 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16415 {
16416 if (data.dictfile == NULL)
16417 {
16418 if (dictfiles != NULL)
16419 {
16420 hc_timer_set (&data.timer_running);
16421
16422 data.dictfile = dictfiles[0];
16423 }
16424 }
16425 }
16426 else if (attack_mode == ATTACK_MODE_BF)
16427 {
16428 if (data.mask == NULL)
16429 {
16430 hc_timer_set (&data.timer_running);
16431
16432 data.mask = masks[0];
16433 }
16434 }
16435
16436 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16437 {
16438 data.devices_status = STATUS_EXHAUSTED;
16439 }
16440
16441 // if cracked / aborted remove last induction dictionary
16442
16443 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16444 {
16445 struct stat induct_stat;
16446
16447 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16448 {
16449 unlink (induction_dictionaries[file_pos]);
16450 }
16451 }
16452
16453 // wait for non-interactive threads
16454
16455 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16456 {
16457 hc_thread_wait (1, &ni_threads[thread_idx]);
16458 }
16459
16460 local_free (ni_threads);
16461
16462 // wait for interactive threads
16463
16464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16465 {
16466 hc_thread_wait (1, &i_thread);
16467 }
16468
16469 // we dont need restore file anymore
16470 if (data.restore_disable == 0)
16471 {
16472 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16473 {
16474 unlink (eff_restore_file);
16475 unlink (new_restore_file);
16476 }
16477 else
16478 {
16479 cycle_restore ();
16480 }
16481 }
16482
16483 // finally save left hashes
16484
16485 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16486 {
16487 save_hash ();
16488 }
16489
16490 /**
16491 * Clean up
16492 */
16493
16494 if (benchmark == 1)
16495 {
16496 status_benchmark ();
16497
16498 log_info ("");
16499 }
16500 else
16501 {
16502 if (quiet == 0) clear_prompt ();
16503
16504 if (quiet == 0) log_info ("");
16505
16506 if (status == 1)
16507 {
16508 status_display ();
16509 }
16510 else
16511 {
16512 if (quiet == 0) status_display ();
16513 }
16514
16515 if (quiet == 0) log_info ("");
16516 }
16517
16518 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16519 {
16520 hc_device_param_t *device_param = &data.devices_param[device_id];
16521
16522 if (device_param->skipped) continue;
16523
16524 local_free (device_param->result);
16525
16526 local_free (device_param->pw_caches);
16527
16528 local_free (device_param->combs_buf);
16529
16530 local_free (device_param->hooks_buf);
16531
16532 local_free (device_param->device_name);
16533
16534 local_free (device_param->device_name_chksum);
16535
16536 local_free (device_param->device_version);
16537
16538 local_free (device_param->driver_version);
16539
16540 if (device_param->pws_buf) myfree (device_param->pws_buf);
16541 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16542 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16543 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16544 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16545 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16546 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16547 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16548 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16549 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16550 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16551 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16552 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16553 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16554 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16555 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16556 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16557 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16558 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16559 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16560 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16561 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16562 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16563 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16564 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16565 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16566 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16567 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16568 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16569
16570 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16571 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16572 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16573 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16574 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16575 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16576 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16577 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16578 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16579 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16580 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16581
16582 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16583 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16584 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16585
16586 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16587 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16588 }
16589
16590 // reset default fan speed
16591
16592 #ifdef HAVE_HWMON
16593 if (gpu_temp_disable == 0)
16594 {
16595 #ifdef HAVE_ADL
16596 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16597 {
16598 hc_thread_mutex_lock (mux_adl);
16599
16600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16601 {
16602 hc_device_param_t *device_param = &data.devices_param[device_id];
16603
16604 if (device_param->skipped) continue;
16605
16606 if (data.hm_device[device_id].fan_supported == 1)
16607 {
16608 int fanspeed = temp_retain_fanspeed_value[device_id];
16609
16610 if (fanspeed == -1) continue;
16611
16612 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16613
16614 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16615 }
16616 }
16617
16618 hc_thread_mutex_unlock (mux_adl);
16619 }
16620 #endif // HAVE_ADL
16621 }
16622
16623 #ifdef HAVE_ADL
16624 // reset power tuning
16625
16626 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16627 {
16628 hc_thread_mutex_lock (mux_adl);
16629
16630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16631 {
16632 hc_device_param_t *device_param = &data.devices_param[device_id];
16633
16634 if (device_param->skipped) continue;
16635
16636 if (data.hm_device[device_id].od_version == 6)
16637 {
16638 // check powertune capabilities first, if not available then skip device
16639
16640 int powertune_supported = 0;
16641
16642 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16643 {
16644 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16645
16646 return (-1);
16647 }
16648
16649 if (powertune_supported != 0)
16650 {
16651 // powercontrol settings
16652
16653 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16654 {
16655 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16656
16657 return (-1);
16658 }
16659
16660 // clocks
16661
16662 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16663
16664 performance_state->iNumberOfPerformanceLevels = 2;
16665
16666 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16667 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16668 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16669 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16670
16671 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16672 {
16673 log_info ("ERROR: Failed to restore ADL performance state");
16674
16675 return (-1);
16676 }
16677
16678 local_free (performance_state);
16679 }
16680 }
16681 }
16682
16683 hc_thread_mutex_unlock (mux_adl);
16684 }
16685 #endif // HAVE_ADL
16686
16687 if (gpu_temp_disable == 0)
16688 {
16689 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16690 if (data.hm_nv)
16691 {
16692 #if defined(LINUX) && defined(HAVE_NVML)
16693
16694 hm_NVML_nvmlShutdown (data.hm_nv);
16695
16696 nvml_close (data.hm_nv);
16697
16698 #elif defined(WIN) && (HAVE_NVAPI)
16699
16700 hm_NvAPI_Unload (data.hm_nv);
16701
16702 nvapi_close (data.hm_nv);
16703
16704 #endif
16705
16706 data.hm_nv = NULL;
16707 }
16708 #endif
16709
16710 #ifdef HAVE_ADL
16711 if (data.hm_amd)
16712 {
16713 hm_ADL_Main_Control_Destroy (data.hm_amd);
16714
16715 adl_close (data.hm_amd);
16716 data.hm_amd = NULL;
16717 }
16718 #endif
16719 }
16720 #endif // HAVE_HWMON
16721
16722 // free memory
16723
16724 local_free (masks);
16725
16726 local_free (dictstat_base);
16727
16728 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16729 {
16730 pot_t *pot_ptr = &pot[pot_pos];
16731
16732 hash_t *hash = &pot_ptr->hash;
16733
16734 local_free (hash->digest);
16735
16736 if (isSalted)
16737 {
16738 local_free (hash->salt);
16739 }
16740 }
16741
16742 local_free (pot);
16743
16744 local_free (all_kernel_rules_cnt);
16745 local_free (all_kernel_rules_buf);
16746
16747 local_free (wl_data->buf);
16748 local_free (wl_data);
16749
16750 local_free (bitmap_s1_a);
16751 local_free (bitmap_s1_b);
16752 local_free (bitmap_s1_c);
16753 local_free (bitmap_s1_d);
16754 local_free (bitmap_s2_a);
16755 local_free (bitmap_s2_b);
16756 local_free (bitmap_s2_c);
16757 local_free (bitmap_s2_d);
16758
16759 #ifdef HAVE_HWMON
16760 local_free (temp_retain_fanspeed_value);
16761 #ifdef HAVE_ADL
16762 local_free (od_clock_mem_status);
16763 local_free (od_power_control_status);
16764 #endif // ADL
16765 #endif
16766
16767 global_free (devices_param);
16768
16769 global_free (kernel_rules_buf);
16770
16771 global_free (root_css_buf);
16772 global_free (markov_css_buf);
16773
16774 global_free (digests_buf);
16775 global_free (digests_shown);
16776 global_free (digests_shown_tmp);
16777
16778 global_free (salts_buf);
16779 global_free (salts_shown);
16780
16781 global_free (esalts_buf);
16782
16783 global_free (words_progress_done);
16784 global_free (words_progress_rejected);
16785 global_free (words_progress_restored);
16786
16787 if (pot_fp) fclose (pot_fp);
16788
16789 if (data.devices_status == STATUS_QUIT) break;
16790 }
16791
16792 // destroy others mutex
16793
16794 hc_thread_mutex_delete (mux_dispatcher);
16795 hc_thread_mutex_delete (mux_counter);
16796 hc_thread_mutex_delete (mux_display);
16797 hc_thread_mutex_delete (mux_adl);
16798
16799 // free memory
16800
16801 local_free (eff_restore_file);
16802 local_free (new_restore_file);
16803
16804 local_free (rd);
16805
16806 // loopback
16807
16808 local_free (loopback_file);
16809
16810 if (loopback == 1) unlink (loopback_file);
16811
16812 // induction directory
16813
16814 if (induction_dir == NULL)
16815 {
16816 if (attack_mode != ATTACK_MODE_BF)
16817 {
16818 if (rmdir (induction_directory) == -1)
16819 {
16820 if (errno == ENOENT)
16821 {
16822 // good, we can ignore
16823 }
16824 else if (errno == ENOTEMPTY)
16825 {
16826 // good, we can ignore
16827 }
16828 else
16829 {
16830 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16831
16832 return (-1);
16833 }
16834 }
16835
16836 local_free (induction_directory);
16837 }
16838 }
16839
16840 // outfile-check directory
16841
16842 if (outfile_check_dir == NULL)
16843 {
16844 if (rmdir (outfile_check_directory) == -1)
16845 {
16846 if (errno == ENOENT)
16847 {
16848 // good, we can ignore
16849 }
16850 else if (errno == ENOTEMPTY)
16851 {
16852 // good, we can ignore
16853 }
16854 else
16855 {
16856 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16857
16858 return (-1);
16859 }
16860 }
16861
16862 local_free (outfile_check_directory);
16863 }
16864
16865 time_t proc_stop;
16866
16867 time (&proc_stop);
16868
16869 logfile_top_uint (proc_start);
16870 logfile_top_uint (proc_stop);
16871
16872 logfile_top_msg ("STOP");
16873
16874 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16875 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16876
16877 if (data.ocl) ocl_close (data.ocl);
16878
16879 if (data.devices_status == STATUS_ABORTED) return 2;
16880 if (data.devices_status == STATUS_QUIT) return 2;
16881 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16882 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16883 if (data.devices_status == STATUS_CRACKED) return 0;
16884
16885 return -1;
16886 }
Hashcat additions to support pwdhash