projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Optimized memset calls and also some initializations
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #ifdef OSX
7 #include <stdio.h>
8 #endif
9
10 #include <common.h>
11 #include <shared.h>
12 #include <rp_kernel_on_cpu.h>
13 #include <getopt.h>
14
15 const char *PROGNAME = "oclHashcat";
16 const uint VERSION_BIN = 210;
17 const uint RESTORE_MIN = 210;
18
19 #define INCR_RULES 10000
20 #define INCR_SALTS 100000
21 #define INCR_MASKS 1000
22 #define INCR_POT 1000
23
24 #define USAGE 0
25 #define VERSION 0
26 #define QUIET 0
27 #define MARKOV_THRESHOLD 0
28 #define MARKOV_DISABLE 0
29 #define MARKOV_CLASSIC 0
30 #define BENCHMARK 0
31 #define BENCHMARK_MODE 1
32 #define RESTORE 0
33 #define RESTORE_TIMER 60
34 #define RESTORE_DISABLE 0
35 #define STATUS 0
36 #define STATUS_TIMER 10
37 #define STATUS_AUTOMAT 0
38 #define LOOPBACK 0
39 #define WEAK_HASH_THRESHOLD 100
40 #define SHOW 0
41 #define LEFT 0
42 #define USERNAME 0
43 #define REMOVE 0
44 #define REMOVE_TIMER 60
45 #define SKIP 0
46 #define LIMIT 0
47 #define KEYSPACE 0
48 #define POTFILE_DISABLE 0
49 #define DEBUG_MODE 0
50 #define RP_GEN 0
51 #define RP_GEN_FUNC_MIN 1
52 #define RP_GEN_FUNC_MAX 4
53 #define RP_GEN_SEED 0
54 #define RULE_BUF_L ":"
55 #define RULE_BUF_R ":"
56 #define FORCE 0
57 #define RUNTIME 0
58 #define HEX_CHARSET 0
59 #define HEX_SALT 0
60 #define HEX_WORDLIST 0
61 #define OUTFILE_FORMAT 3
62 #define OUTFILE_AUTOHEX 1
63 #define OUTFILE_CHECK_TIMER 5
64 #define ATTACK_MODE 0
65 #define HASH_MODE 0
66 #define SEGMENT_SIZE 32
67 #define INCREMENT 0
68 #define INCREMENT_MIN 1
69 #define INCREMENT_MAX PW_MAX
70 #define SEPARATOR ':'
71 #define BITMAP_MIN 16
72 #define BITMAP_MAX 24
73 #define GPU_TEMP_DISABLE 0
74 #define GPU_TEMP_ABORT 90
75 #define GPU_TEMP_RETAIN 80
76 #define WORKLOAD_PROFILE 2
77 #define KERNEL_ACCEL 0
78 #define KERNEL_LOOPS 0
79 #define KERNEL_RULES 1024
80 #define KERNEL_COMBS 1024
81 #define KERNEL_BFS 1024
82 #define KERNEL_THREADS 64
83 #define POWERTUNE_ENABLE 0
84 #define LOGFILE_DISABLE 0
85 #define SCRYPT_TMTO 0
86 #define OPENCL_VECTOR_WIDTH 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
123 #define ATTACK_EXEC_INSIDE_KERNEL 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 900,
154 0,
155 5100,
156 100,
157 1400,
158 10800,
159 1700,
160 5000,
161 10100,
162 6000,
163 6100,
164 6900,
165 11700,
166 11800,
167 400,
168 8900,
169 11900,
170 12000,
171 10900,
172 12100,
173 23,
174 2500,
175 5300,
176 5400,
177 5500,
178 5600,
179 7300,
180 7500,
181 8300,
182 11100,
183 11200,
184 11400,
185 121,
186 2611,
187 2711,
188 2811,
189 8400,
190 11,
191 2612,
192 7900,
193 21,
194 11000,
195 124,
196 10000,
197 3711,
198 7600,
199 12,
200 131,
201 132,
202 1731,
203 200,
204 300,
205 3100,
206 112,
207 12300,
208 8000,
209 141,
210 1441,
211 1600,
212 12600,
213 1421,
214 101,
215 111,
216 1711,
217 3000,
218 1000,
219 1100,
220 2100,
221 12800,
222 1500,
223 12400,
224 500,
225 3200,
226 7400,
227 1800,
228 122,
229 1722,
230 7100,
231 6300,
232 6700,
233 6400,
234 6500,
235 2400,
236 2410,
237 5700,
238 9200,
239 9300,
240 22,
241 501,
242 5800,
243 8100,
244 8500,
245 7200,
246 9900,
247 7700,
248 7800,
249 10300,
250 8600,
251 8700,
252 9100,
253 133,
254 11600,
255 12500,
256 13000,
257 6211,
258 6221,
259 6231,
260 6241,
261 8800,
262 12900,
263 12200,
264 9700,
265 9710,
266 9800,
267 9810,
268 9400,
269 9500,
270 9600,
271 10400,
272 10410,
273 10500,
274 10600,
275 10700,
276 9000,
277 5200,
278 6800,
279 6600,
280 8200,
281 11300,
282 12700
283 };
284
285 /**
286 * types
287 */
288
289 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
290
291 /**
292 * globals
293 */
294
295 static unsigned int full01 = 0x01010101;
296 static unsigned int full80 = 0x80808080;
297
298 int SUPPRESS_OUTPUT = 0;
299
300 hc_thread_mutex_t mux_adl;
301 hc_thread_mutex_t mux_counter;
302 hc_thread_mutex_t mux_dispatcher;
303 hc_thread_mutex_t mux_display;
304
305 hc_global_data_t data;
306
307 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
308
309 const char *USAGE_MINI[] =
310 {
311 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
312 "",
313 "Try --help for more help.",
314 NULL
315 };
316
317 const char *USAGE_BIG[] =
318 {
319 "%s, advanced password recovery",
320 "",
321 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
322 "",
323 "=======",
324 "Options",
325 "=======",
326 "",
327 "* General:",
328 "",
329 " -m, --hash-type=NUM Hash-type, see references below",
330 " -a, --attack-mode=NUM Attack-mode, see references below",
331 " -V, --version Print version",
332 " -h, --help Print help",
333 " --quiet Suppress output",
334 "",
335 "* Benchmark:",
336 "",
337 " -b, --benchmark Run benchmark",
338 " --benchmark-mode=NUM Benchmark-mode, see references below",
339 "",
340 "* Misc:",
341 "",
342 " --hex-charset Assume charset is given in hex",
343 " --hex-salt Assume salt is given in hex",
344 " --hex-wordlist Assume words in wordlist is given in hex",
345 " --force Ignore warnings",
346 " --status Enable automatic update of the status-screen",
347 " --status-timer=NUM Seconds between status-screen update",
348 " --status-automat Display the status view in a machine readable format",
349 " --loopback Add new plains to induct directory",
350 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
351 "",
352 "* Markov:",
353 "",
354 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
355 " --markov-disable Disables markov-chains, emulates classic brute-force",
356 " --markov-classic Enables classic markov-chains, no per-position enhancement",
357 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
358 "",
359 "* Session:",
360 "",
361 " --runtime=NUM Abort session after NUM seconds of runtime",
362 " --session=STR Define specific session name",
363 " --restore Restore session from --session",
364 " --restore-disable Do not write restore file",
365 "",
366 "* Files:",
367 "",
368 " -o, --outfile=FILE Define outfile for recovered hash",
369 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
370 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
371 " --outfile-check-timer=NUM Seconds between outfile checks",
372 " -p, --separator=CHAR Separator char for hashlists and outfile",
373 " --show Show cracked passwords only",
374 " --left Show un-cracked passwords only",
375 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
376 " --remove Enable remove of hash once it is cracked",
377 " --remove-timer=NUM Update input hash file each NUM seconds",
378 " --potfile-disable Do not write potfile",
379 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
380 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
381 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
382 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
383 " --logfile-disable Disable the logfile",
384 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
385 "",
386 "* Resources:",
387 "",
388 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
389 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
390 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
391 #ifndef OSX
392 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
393 #else
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
395 #endif
396 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
397 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
398 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
399 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
400 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
401 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
402 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
405 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
406 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
407 #ifdef HAVE_ADL
408 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
409 #endif
410 #endif
411 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
412 "",
413 "* Distributed:",
414 "",
415 " -s, --skip=NUM Skip number of words",
416 " -l, --limit=NUM Limit number of words",
417 " --keyspace Show keyspace base:mod values and quit",
418 "",
419 "* Rules:",
420 "",
421 " -j, --rule-left=RULE Single rule applied to each word from left dict",
422 " -k, --rule-right=RULE Single rule applied to each word from right dict",
423 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
424 " -g, --generate-rules=NUM Generate NUM random rules",
425 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
426 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
427 " --generate-rules-seed=NUM Force RNG seed to NUM",
428 "",
429 "* Custom charsets:",
430 "",
431 " -1, --custom-charset1=CS User-defined charsets",
432 " -2, --custom-charset2=CS Example:",
433 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
434 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
435 "",
436 "* Increment:",
437 "",
438 " -i, --increment Enable increment mode",
439 " --increment-min=NUM Start incrementing at NUM",
440 " --increment-max=NUM Stop incrementing at NUM",
441 "",
442 "==========",
443 "References",
444 "==========",
445 "",
446 "* Workload Profile:",
447 "",
448 " 1 = Reduced performance profile (low latency desktop)",
449 " 2 = Default performance profile",
450 " 3 = Tuned performance profile (high latency desktop)",
451 "",
452 "* Benchmark Settings:",
453 "",
454 " 0 = Manual Tuning",
455 " 1 = Performance Tuning, default",
456 "",
457 "* OpenCL device-types:",
458 "",
459 " 1 = CPU devices",
460 " 2 = GPU devices",
461 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
462 "",
463 "* Outfile Formats:",
464 "",
465 " 1 = hash[:salt]",
466 " 2 = plain",
467 " 3 = hash[:salt]:plain",
468 " 4 = hex_plain",
469 " 5 = hash[:salt]:hex_plain",
470 " 6 = plain:hex_plain",
471 " 7 = hash[:salt]:plain:hex_plain",
472 " 8 = crackpos",
473 " 9 = hash[:salt]:crackpos",
474 " 10 = plain:crackpos",
475 " 11 = hash[:salt]:plain:crackpos",
476 " 12 = hex_plain:crackpos",
477 " 13 = hash[:salt]:hex_plain:crackpos",
478 " 14 = plain:hex_plain:crackpos",
479 " 15 = hash[:salt]:plain:hex_plain:crackpos",
480 "",
481 "* Debug mode output formats (for hybrid mode only, by using rules):",
482 "",
483 " 1 = save finding rule",
484 " 2 = save original word",
485 " 3 = save original word and finding rule",
486 " 4 = save original word, finding rule and modified plain",
487 "",
488 "* Built-in charsets:",
489 "",
490 " ?l = abcdefghijklmnopqrstuvwxyz",
491 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
492 " ?d = 0123456789",
493 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
494 " ?a = ?l?u?d?s",
495 " ?b = 0x00 - 0xff",
496 "",
497 "* Attack modes:",
498 "",
499 " 0 = Straight",
500 " 1 = Combination",
501 " 3 = Brute-force",
502 " 6 = Hybrid dict + mask",
503 " 7 = Hybrid mask + dict",
504 "",
505 "* Hash types:",
506 "",
507 "[[ Roll-your-own: Raw Hashes ]]",
508 "",
509 " 900 = MD4",
510 " 0 = MD5",
511 " 5100 = Half MD5",
512 " 100 = SHA1",
513 " 10800 = SHA-384",
514 " 1400 = SHA-256",
515 " 1700 = SHA-512",
516 " 5000 = SHA-3(Keccak)",
517 " 10100 = SipHash",
518 " 6000 = RipeMD160",
519 " 6100 = Whirlpool",
520 " 6900 = GOST R 34.11-94",
521 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
522 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
523 "",
524 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
525 "",
526 " 10 = md5($pass.$salt)",
527 " 20 = md5($salt.$pass)",
528 " 30 = md5(unicode($pass).$salt)",
529 " 40 = md5($salt.unicode($pass))",
530 " 3800 = md5($salt.$pass.$salt)",
531 " 3710 = md5($salt.md5($pass))",
532 " 2600 = md5(md5($pass)",
533 " 4300 = md5(strtoupper(md5($pass)))",
534 " 4400 = md5(sha1($pass))",
535 " 110 = sha1($pass.$salt)",
536 " 120 = sha1($salt.$pass)",
537 " 130 = sha1(unicode($pass).$salt)",
538 " 140 = sha1($salt.unicode($pass))",
539 " 4500 = sha1(sha1($pass)",
540 " 4700 = sha1(md5($pass))",
541 " 4900 = sha1($salt.$pass.$salt)",
542 " 1410 = sha256($pass.$salt)",
543 " 1420 = sha256($salt.$pass)",
544 " 1430 = sha256(unicode($pass).$salt)",
545 " 1440 = sha256($salt.unicode($pass))",
546 " 1710 = sha512($pass.$salt)",
547 " 1720 = sha512($salt.$pass)",
548 " 1730 = sha512(unicode($pass).$salt)",
549 " 1740 = sha512($salt.unicode($pass))",
550 "",
551 "[[ Roll-your-own: Authenticated Hashes ]]",
552 "",
553 " 50 = HMAC-MD5 (key = $pass)",
554 " 60 = HMAC-MD5 (key = $salt)",
555 " 150 = HMAC-SHA1 (key = $pass)",
556 " 160 = HMAC-SHA1 (key = $salt)",
557 " 1450 = HMAC-SHA256 (key = $pass)",
558 " 1460 = HMAC-SHA256 (key = $salt)",
559 " 1750 = HMAC-SHA512 (key = $pass)",
560 " 1760 = HMAC-SHA512 (key = $salt)",
561 "",
562 "[[ Generic KDF ]]",
563 "",
564 " 400 = phpass",
565 " 8900 = scrypt",
566 " 11900 = PBKDF2-HMAC-MD5",
567 " 12000 = PBKDF2-HMAC-SHA1",
568 " 10900 = PBKDF2-HMAC-SHA256",
569 " 12100 = PBKDF2-HMAC-SHA512",
570 "",
571 "[[ Network protocols, Challenge-Response ]]",
572 "",
573 " 23 = Skype",
574 " 2500 = WPA/WPA2",
575 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
576 " 5300 = IKE-PSK MD5",
577 " 5400 = IKE-PSK SHA1",
578 " 5500 = NetNTLMv1",
579 " 5500 = NetNTLMv1 + ESS",
580 " 5600 = NetNTLMv2",
581 " 7300 = IPMI2 RAKP HMAC-SHA1",
582 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
583 " 8300 = DNSSEC (NSEC3)",
584 " 10200 = Cram MD5",
585 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
586 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
587 " 11400 = SIP digest authentication (MD5)",
588 "",
589 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
590 "",
591 " 121 = SMF (Simple Machines Forum)",
592 " 400 = phpBB3",
593 " 2611 = vBulletin < v3.8.5",
594 " 2711 = vBulletin > v3.8.5",
595 " 2811 = MyBB",
596 " 2811 = IPB (Invison Power Board)",
597 " 8400 = WBB3 (Woltlab Burning Board)",
598 " 11 = Joomla < 2.5.18",
599 " 400 = Joomla > 2.5.18",
600 " 400 = Wordpress",
601 " 2612 = PHPS",
602 " 7900 = Drupal7",
603 " 21 = osCommerce",
604 " 21 = xt:Commerce",
605 " 11000 = PrestaShop",
606 " 124 = Django (SHA-1)",
607 " 10000 = Django (PBKDF2-SHA256)",
608 " 3711 = Mediawiki B type",
609 " 7600 = Redmine",
610 "",
611 "[[ Database Server ]]",
612 "",
613 " 12 = PostgreSQL",
614 " 131 = MSSQL(2000)",
615 " 132 = MSSQL(2005)",
616 " 1731 = MSSQL(2012)",
617 " 1731 = MSSQL(2014)",
618 " 200 = MySQL323",
619 " 300 = MySQL4.1/MySQL5",
620 " 3100 = Oracle H: Type (Oracle 7+)",
621 " 112 = Oracle S: Type (Oracle 11+)",
622 " 12300 = Oracle T: Type (Oracle 12+)",
623 " 8000 = Sybase ASE",
624 "",
625 "[[ HTTP, SMTP, LDAP Server ]]",
626 "",
627 " 141 = EPiServer 6.x < v4",
628 " 1441 = EPiServer 6.x > v4",
629 " 1600 = Apache $apr1$",
630 " 12600 = ColdFusion 10+",
631 " 1421 = hMailServer",
632 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
633 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
634 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
635 "",
636 "[[ Checksums ]]",
637 "",
638 " 11500 = CRC32",
639 "",
640 "[[ Operating-Systems ]]",
641 "",
642 " 3000 = LM",
643 " 1000 = NTLM",
644 " 1100 = Domain Cached Credentials (DCC), MS Cache",
645 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
646 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
647 " 1500 = descrypt, DES(Unix), Traditional DES",
648 " 12400 = BSDiCrypt, Extended DES",
649 " 500 = md5crypt $1$, MD5(Unix)",
650 " 3200 = bcrypt $2*$, Blowfish(Unix)",
651 " 7400 = sha256crypt $5$, SHA256(Unix)",
652 " 1800 = sha512crypt $6$, SHA512(Unix)",
653 " 122 = OSX v10.4",
654 " 122 = OSX v10.5",
655 " 122 = OSX v10.6",
656 " 1722 = OSX v10.7",
657 " 7100 = OSX v10.8",
658 " 7100 = OSX v10.9",
659 " 7100 = OSX v10.10",
660 " 6300 = AIX {smd5}",
661 " 6700 = AIX {ssha1}",
662 " 6400 = AIX {ssha256}",
663 " 6500 = AIX {ssha512}",
664 " 2400 = Cisco-PIX",
665 " 2410 = Cisco-ASA",
666 " 500 = Cisco-IOS $1$",
667 " 5700 = Cisco-IOS $4$",
668 " 9200 = Cisco-IOS $8$",
669 " 9300 = Cisco-IOS $9$",
670 " 22 = Juniper Netscreen/SSG (ScreenOS)",
671 " 501 = Juniper IVE",
672 " 5800 = Android PIN",
673 " 8100 = Citrix Netscaler",
674 " 8500 = RACF",
675 " 7200 = GRUB 2",
676 " 9900 = Radmin2",
677 "",
678 "[[ Enterprise Application Software (EAS) ]]",
679 "",
680 " 7700 = SAP CODVN B (BCODE)",
681 " 7800 = SAP CODVN F/G (PASSCODE)",
682 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
683 " 8600 = Lotus Notes/Domino 5",
684 " 8700 = Lotus Notes/Domino 6",
685 " 9100 = Lotus Notes/Domino 8",
686 " 133 = PeopleSoft",
687 "",
688 "[[ Archives ]]",
689 "",
690 " 11600 = 7-Zip",
691 " 12500 = RAR3-hp",
692 " 13000 = RAR5",
693 "",
694 "[[ Full-Disk encryptions (FDE) ]]",
695 "",
696 " 62XY = TrueCrypt 5.0+",
697 " X = 1 = PBKDF2-HMAC-RipeMD160",
698 " X = 2 = PBKDF2-HMAC-SHA512",
699 " X = 3 = PBKDF2-HMAC-Whirlpool",
700 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
701 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
702 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
703 " Y = 3 = XTS 1536 bit (Ciphers: All)",
704 " 8800 = Android FDE < v4.3",
705 " 12900 = Android FDE (Samsung DEK)",
706 " 12200 = eCryptfs",
707 "",
708 "[[ Documents ]]",
709 "",
710 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
711 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
712 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
713 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
714 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
715 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
716 " 9400 = MS Office 2007",
717 " 9500 = MS Office 2010",
718 " 9600 = MS Office 2013",
719 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
720 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
721 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
722 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
723 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
724 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
725 "",
726 "[[ Password Managers ]]",
727 "",
728 " 9000 = Password Safe v2",
729 " 5200 = Password Safe v3",
730 " 6800 = Lastpass",
731 " 6600 = 1Password, agilekeychain",
732 " 8200 = 1Password, cloudkeychain",
733 " 11300 = Bitcoin/Litecoin wallet.dat",
734 " 12700 = Blockchain, My Wallet",
735 "",
736 NULL
737 };
738
739 /**
740 * oclHashcat specific functions
741 */
742
743 void status_display_automat ()
744 {
745 FILE *out = stdout;
746
747 fprintf (out, "STATUS\t%u\t", data.devices_status);
748
749 /**
750 * speed new
751 */
752
753 fprintf (out, "SPEED\t");
754
755 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
756 {
757 hc_device_param_t *device_param = &data.devices_param[device_id];
758
759 if (device_param->skipped) continue;
760
761 u64 speed_cnt = 0;
762 float speed_ms = 0;
763
764 for (int i = 0; i < SPEED_CACHE; i++)
765 {
766 float rec_ms;
767
768 hc_timer_get (device_param->speed_rec[i], rec_ms);
769
770 if (rec_ms > SPEED_MAXAGE) continue;
771
772 speed_cnt += device_param->speed_cnt[i];
773 speed_ms += device_param->speed_ms[i];
774 }
775
776 speed_cnt /= SPEED_CACHE;
777 speed_ms /= SPEED_CACHE;
778
779 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
780 }
781
782 /**
783 * words_cur
784 */
785
786 u64 words_cur = get_lowest_words_done ();
787
788 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
789
790 /**
791 * counter
792 */
793
794 uint salts_left = data.salts_cnt - data.salts_done;
795
796 if (salts_left == 0) salts_left = 1;
797
798 u64 progress_total = data.words_cnt * salts_left;
799
800 u64 all_done = 0;
801 u64 all_rejected = 0;
802 u64 all_restored = 0;
803
804 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
805 {
806 if (salts_left > 1)
807 {
808 // otherwise the final cracked status shows 0/XXX progress
809
810 if (data.salts_shown[salt_pos] == 1) continue;
811 }
812
813 all_done += data.words_progress_done[salt_pos];
814 all_rejected += data.words_progress_rejected[salt_pos];
815 all_restored += data.words_progress_restored[salt_pos];
816 }
817
818 u64 progress_cur = all_restored + all_done + all_rejected;
819 u64 progress_end = progress_total;
820
821 u64 progress_skip = 0;
822
823 if (data.skip)
824 {
825 progress_skip = MIN (data.skip, data.words_base) * salts_left;
826
827 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
828 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
829 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
830 }
831
832 if (data.limit)
833 {
834 progress_end = MIN (data.limit, data.words_base) * salts_left;
835
836 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
837 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
838 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
839 }
840
841 u64 progress_cur_relative_skip = progress_cur - progress_skip;
842 u64 progress_end_relative_skip = progress_end - progress_skip;
843
844 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
845
846 /**
847 * cracks
848 */
849
850 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
851 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
852
853 /**
854 * temperature
855 */
856
857 #ifdef HAVE_HWMON
858 if (data.gpu_temp_disable == 0)
859 {
860 fprintf (out, "TEMP\t");
861
862 hc_thread_mutex_lock (mux_adl);
863
864 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
865 {
866 hc_device_param_t *device_param = &data.devices_param[device_id];
867
868 if (device_param->skipped) continue;
869
870 int temp = hm_get_temperature_with_device_id (device_id);
871
872 fprintf (out, "%d\t", temp);
873 }
874
875 hc_thread_mutex_unlock (mux_adl);
876 }
877 #endif // HAVE_HWMON
878
879 #ifdef _WIN
880 fputc ('\r', out);
881 fputc ('\n', out);
882 #endif
883
884 #ifdef _POSIX
885 fputc ('\n', out);
886 #endif
887
888 fflush (out);
889 }
890
891 void status_display ()
892 {
893 if (data.devices_status == STATUS_INIT) return;
894 if (data.devices_status == STATUS_STARTING) return;
895 if (data.devices_status == STATUS_BYPASS) return;
896
897 if (data.status_automat == 1)
898 {
899 status_display_automat ();
900
901 return;
902 }
903
904 char tmp_buf[1000] = { 0 };
905
906 uint tmp_len = 0;
907
908 log_info ("Session.Name...: %s", data.session);
909
910 char *status_type = strstatus (data.devices_status);
911
912 uint hash_mode = data.hash_mode;
913
914 char *hash_type = strhashtype (hash_mode); // not a bug
915
916 log_info ("Status.........: %s", status_type);
917
918 /**
919 * show rules
920 */
921
922 if (data.rp_files_cnt)
923 {
924 uint i;
925
926 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
927 {
928 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
929 }
930
931 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
932
933 log_info ("Rules.Type.....: %s", tmp_buf);
934
935 tmp_len = 0;
936 }
937
938 if (data.rp_gen)
939 {
940 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
941
942 if (data.rp_gen_seed)
943 {
944 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
945 }
946 }
947
948 /**
949 * show input
950 */
951
952 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
953 {
954 if (data.wordlist_mode == WL_MODE_FILE)
955 {
956 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
957 }
958 else if (data.wordlist_mode == WL_MODE_STDIN)
959 {
960 log_info ("Input.Mode.....: Pipe");
961 }
962 }
963 else if (data.attack_mode == ATTACK_MODE_COMBI)
964 {
965 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
966 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
967 }
968 else if (data.attack_mode == ATTACK_MODE_BF)
969 {
970 char *mask = data.mask;
971
972 if (mask != NULL)
973 {
974 uint mask_len = data.css_cnt;
975
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
977
978 if (mask_len > 0)
979 {
980 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
981 {
982 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
983 {
984 mask_len -= data.salts_buf[0].salt_len;
985 }
986 }
987
988 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
989
990 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
991 }
992
993 if (data.maskcnt > 1)
994 {
995 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
996
997 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
998 }
999
1000 log_info ("Input.Mode.....: %s", tmp_buf);
1001 }
1002
1003 tmp_len = 0;
1004 }
1005 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1006 {
1007 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1008 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1011 {
1012 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1013 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1014 }
1015
1016 if (data.digests_cnt == 1)
1017 {
1018 if (data.hash_mode == 2500)
1019 {
1020 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1021
1022 uint pke[25] = { 0 };
1023
1024 char *pke_ptr = (char *) pke;
1025
1026 for (uint i = 0; i < 25; i++)
1027 {
1028 pke[i] = byte_swap_32 (wpa->pke[i]);
1029 }
1030
1031 char mac1[6] = { 0 };
1032 char mac2[6] = { 0 };
1033
1034 memcpy (mac1, pke_ptr + 23, 6);
1035 memcpy (mac2, pke_ptr + 29, 6);
1036
1037 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1038 (char *) data.salts_buf[0].salt_buf,
1039 mac1[0] & 0xff,
1040 mac1[1] & 0xff,
1041 mac1[2] & 0xff,
1042 mac1[3] & 0xff,
1043 mac1[4] & 0xff,
1044 mac1[5] & 0xff,
1045 mac2[0] & 0xff,
1046 mac2[1] & 0xff,
1047 mac2[2] & 0xff,
1048 mac2[3] & 0xff,
1049 mac2[4] & 0xff,
1050 mac2[5] & 0xff);
1051 }
1052 else if (data.hash_mode == 5200)
1053 {
1054 log_info ("Hash.Target....: File (%s)", data.hashfile);
1055 }
1056 else if (data.hash_mode == 9000)
1057 {
1058 log_info ("Hash.Target....: File (%s)", data.hashfile);
1059 }
1060 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1061 {
1062 log_info ("Hash.Target....: File (%s)", data.hashfile);
1063 }
1064 else
1065 {
1066 char out_buf[4096] = { 0 };
1067
1068 ascii_digest (out_buf, 0, 0);
1069
1070 // limit length
1071 if (strlen (out_buf) > 40)
1072 {
1073 out_buf[41] = '.';
1074 out_buf[42] = '.';
1075 out_buf[43] = '.';
1076 out_buf[44] = 0;
1077 }
1078
1079 log_info ("Hash.Target....: %s", out_buf);
1080 }
1081 }
1082 else
1083 {
1084 if (data.hash_mode == 3000)
1085 {
1086 char out_buf1[4096] = { 0 };
1087 char out_buf2[4096] = { 0 };
1088
1089 ascii_digest (out_buf1, 0, 0);
1090 ascii_digest (out_buf2, 0, 1);
1091
1092 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1093 }
1094 else
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 }
1099
1100 log_info ("Hash.Type......: %s", hash_type);
1101
1102 /**
1103 * speed new
1104 */
1105
1106 u64 speed_cnt[DEVICES_MAX] = { 0 };
1107 float speed_ms[DEVICES_MAX] = { 0 };
1108
1109 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1110 {
1111 hc_device_param_t *device_param = &data.devices_param[device_id];
1112
1113 if (device_param->skipped) continue;
1114
1115 // we need to clear values (set to 0) because in case the device does
1116 // not get new candidates it idles around but speed display would
1117 // show it as working.
1118 // if we instantly set it to 0 after reading it happens that the
1119 // speed can be shown as zero if the users refreshes too fast.
1120 // therefore, we add a timestamp when a stat was recorded and if its
1121 // too old we will not use it
1122
1123 speed_cnt[device_id] = 0;
1124 speed_ms[device_id] = 0;
1125
1126 for (int i = 0; i < SPEED_CACHE; i++)
1127 {
1128 float rec_ms;
1129
1130 hc_timer_get (device_param->speed_rec[i], rec_ms);
1131
1132 if (rec_ms > SPEED_MAXAGE) continue;
1133
1134 speed_cnt[device_id] += device_param->speed_cnt[i];
1135 speed_ms[device_id] += device_param->speed_ms[i];
1136 }
1137
1138 speed_cnt[device_id] /= SPEED_CACHE;
1139 speed_ms[device_id] /= SPEED_CACHE;
1140 }
1141
1142 float hashes_all_ms = 0;
1143
1144 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1145
1146 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1147 {
1148 hc_device_param_t *device_param = &data.devices_param[device_id];
1149
1150 if (device_param->skipped) continue;
1151
1152 hashes_dev_ms[device_id] = 0;
1153
1154 if (speed_ms[device_id])
1155 {
1156 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1157
1158 hashes_all_ms += hashes_dev_ms[device_id];
1159 }
1160 }
1161
1162 /**
1163 * timers
1164 */
1165
1166 float ms_running = 0;
1167
1168 hc_timer_get (data.timer_running, ms_running);
1169
1170 float ms_paused = data.ms_paused;
1171
1172 if (data.devices_status == STATUS_PAUSED)
1173 {
1174 float ms_paused_tmp = 0;
1175
1176 hc_timer_get (data.timer_paused, ms_paused_tmp);
1177
1178 ms_paused += ms_paused_tmp;
1179 }
1180
1181 #ifdef WIN
1182
1183 __time64_t sec_run = ms_running / 1000;
1184
1185 #else
1186
1187 time_t sec_run = ms_running / 1000;
1188
1189 #endif
1190
1191 if (sec_run)
1192 {
1193 char display_run[32] = { 0 };
1194
1195 struct tm tm_run;
1196
1197 struct tm *tmp = NULL;
1198
1199 #ifdef WIN
1200
1201 tmp = _gmtime64 (&sec_run);
1202
1203 #else
1204
1205 tmp = gmtime (&sec_run);
1206
1207 #endif
1208
1209 if (tmp != NULL)
1210 {
1211 memset (&tm_run, 0, sizeof (tm_run));
1212
1213 memcpy (&tm_run, tmp, sizeof (tm_run));
1214
1215 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1216
1217 char *start = ctime (&data.proc_start);
1218
1219 size_t start_len = strlen (start);
1220
1221 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1222 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1223
1224 log_info ("Time.Started...: %s (%s)", start, display_run);
1225 }
1226 }
1227 else
1228 {
1229 log_info ("Time.Started...: 0 secs");
1230 }
1231
1232 /**
1233 * counters
1234 */
1235
1236 uint salts_left = data.salts_cnt - data.salts_done;
1237
1238 if (salts_left == 0) salts_left = 1;
1239
1240 u64 progress_total = data.words_cnt * salts_left;
1241
1242 u64 all_done = 0;
1243 u64 all_rejected = 0;
1244 u64 all_restored = 0;
1245
1246 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1247 {
1248 if (salts_left > 1)
1249 {
1250 // otherwise the final cracked status shows 0/XXX progress
1251
1252 if (data.salts_shown[salt_pos] == 1) continue;
1253 }
1254
1255 all_done += data.words_progress_done[salt_pos];
1256 all_rejected += data.words_progress_rejected[salt_pos];
1257 all_restored += data.words_progress_restored[salt_pos];
1258 }
1259
1260 u64 progress_cur = all_restored + all_done + all_rejected;
1261 u64 progress_end = progress_total;
1262
1263 u64 progress_skip = 0;
1264
1265 if (data.skip)
1266 {
1267 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1268
1269 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1270 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1271 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1272 }
1273
1274 if (data.limit)
1275 {
1276 progress_end = MIN (data.limit, data.words_base) * salts_left;
1277
1278 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1279 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1280 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1281 }
1282
1283 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1284 u64 progress_end_relative_skip = progress_end - progress_skip;
1285
1286 float speed_ms_real = ms_running - ms_paused;
1287 u64 speed_plains_real = all_done;
1288
1289 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1290 {
1291 if (data.devices_status != STATUS_CRACKED)
1292 {
1293 u64 words_per_ms = 0;
1294
1295 if (speed_plains_real && speed_ms_real)
1296 {
1297 words_per_ms = speed_plains_real / speed_ms_real;
1298 }
1299
1300 #ifdef WIN
1301 __time64_t sec_etc = 0;
1302 #else
1303 time_t sec_etc = 0;
1304 #endif
1305
1306 if (words_per_ms)
1307 {
1308 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1309
1310 u64 ms_left = progress_left_relative_skip / words_per_ms;
1311
1312 sec_etc = ms_left / 1000;
1313 }
1314
1315 if (sec_etc == 0)
1316 {
1317 log_info ("Time.Estimated.: 0 secs");
1318 }
1319 else if ((u64) sec_etc > ETC_MAX)
1320 {
1321 log_info ("Time.Estimated.: > 10 Years");
1322 }
1323 else
1324 {
1325 char display_etc[32] = { 0 };
1326
1327 struct tm tm_etc;
1328
1329 struct tm *tmp = NULL;
1330
1331 #ifdef WIN
1332
1333 tmp = _gmtime64 (&sec_etc);
1334
1335 #else
1336
1337 tmp = gmtime (&sec_etc);
1338
1339 #endif
1340
1341 if (tmp != NULL)
1342 {
1343 memset (&tm_etc, 0, sizeof (tm_etc));
1344
1345 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1346
1347 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1348
1349 time_t now;
1350
1351 time (&now);
1352
1353 now += sec_etc;
1354
1355 char *etc = ctime (&now);
1356
1357 size_t etc_len = strlen (etc);
1358
1359 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1360 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1361
1362 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1363 }
1364 }
1365 }
1366 }
1367
1368 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1369 {
1370 hc_device_param_t *device_param = &data.devices_param[device_id];
1371
1372 if (device_param->skipped) continue;
1373
1374 char display_dev_cur[16] = { 0 };
1375
1376 strncpy (display_dev_cur, "0.00", 4);
1377
1378 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1379
1380 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1381 }
1382
1383 char display_all_cur[16] = { 0 };
1384
1385 strncpy (display_all_cur, "0.00", 4);
1386
1387 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1388
1389 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1390
1391 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1392 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1393
1394 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);
1395
1396 // crack-per-time
1397
1398 if (data.digests_cnt > 100)
1399 {
1400 time_t now = time (NULL);
1401
1402 int cpt_cur_min = 0;
1403 int cpt_cur_hour = 0;
1404 int cpt_cur_day = 0;
1405
1406 for (int i = 0; i < CPT_BUF; i++)
1407 {
1408 const uint cracked = data.cpt_buf[i].cracked;
1409 const time_t timestamp = data.cpt_buf[i].timestamp;
1410
1411 if ((timestamp + 60) > now)
1412 {
1413 cpt_cur_min += cracked;
1414 }
1415
1416 if ((timestamp + 3600) > now)
1417 {
1418 cpt_cur_hour += cracked;
1419 }
1420
1421 if ((timestamp + 86400) > now)
1422 {
1423 cpt_cur_day += cracked;
1424 }
1425 }
1426
1427 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1428 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1429 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1430
1431 if ((data.cpt_start + 86400) < now)
1432 {
1433 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1434 cpt_cur_min,
1435 cpt_cur_hour,
1436 cpt_cur_day,
1437 cpt_avg_min,
1438 cpt_avg_hour,
1439 cpt_avg_day);
1440 }
1441 else if ((data.cpt_start + 3600) < now)
1442 {
1443 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1444 cpt_cur_min,
1445 cpt_cur_hour,
1446 cpt_avg_min,
1447 cpt_avg_hour,
1448 cpt_avg_day);
1449 }
1450 else if ((data.cpt_start + 60) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else
1459 {
1460 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 }
1466
1467 // Restore point
1468
1469 u64 restore_point = get_lowest_words_done ();
1470
1471 u64 restore_total = data.words_base;
1472
1473 float percent_restore = 0;
1474
1475 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1476
1477 if (progress_end_relative_skip)
1478 {
1479 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1480 {
1481 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1482 float percent_rejected = 0.0;
1483
1484 if (progress_cur)
1485 {
1486 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1487 }
1488
1489 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);
1490 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1491
1492 if (data.restore_disable == 0)
1493 {
1494 if (percent_finished != 1)
1495 {
1496 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1497 }
1498 }
1499 }
1500 }
1501 else
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1506 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1507
1508 if (data.restore_disable == 0)
1509 {
1510 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1511 }
1512 }
1513 else
1514 {
1515 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1516 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1517
1518 // --restore not allowed if stdin is used -- really? why?
1519
1520 //if (data.restore_disable == 0)
1521 //{
1522 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1523 //}
1524 }
1525 }
1526
1527 #ifdef HAVE_HWMON
1528 if (data.gpu_temp_disable == 0)
1529 {
1530 hc_thread_mutex_lock (mux_adl);
1531
1532 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1533 {
1534 hc_device_param_t *device_param = &data.devices_param[device_id];
1535
1536 if (device_param->skipped) continue;
1537
1538 #define HM_STR_BUF_SIZE 255
1539
1540 if (data.hm_device[device_id].fan_supported == 1)
1541 {
1542 char utilization[HM_STR_BUF_SIZE] = { 0 };
1543 char temperature[HM_STR_BUF_SIZE] = { 0 };
1544 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1545
1546 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1547 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1548
1549 if (device_param->vendor_id == VENDOR_ID_AMD)
1550 {
1551 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1552 }
1553 else if (device_param->vendor_id == VENDOR_ID_NV)
1554 {
1555 #ifdef LINUX
1556 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1557 #else
1558 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1559 #endif
1560 }
1561
1562 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1563 }
1564 else
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568
1569 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1570 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1571
1572 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1573 }
1574 }
1575
1576 hc_thread_mutex_unlock (mux_adl);
1577 }
1578 #endif // HAVE_HWMON
1579 }
1580
1581 static void status_benchmark ()
1582 {
1583 if (data.devices_status == STATUS_INIT) return;
1584 if (data.devices_status == STATUS_STARTING) return;
1585
1586 if (data.words_cnt == 0) return;
1587
1588 u64 speed_cnt[DEVICES_MAX] = { 0 };
1589 float speed_ms[DEVICES_MAX] = { 0 };
1590
1591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1592 {
1593 hc_device_param_t *device_param = &data.devices_param[device_id];
1594
1595 if (device_param->skipped) continue;
1596
1597 speed_cnt[device_id] = 0;
1598 speed_ms[device_id] = 0;
1599
1600 for (int i = 0; i < SPEED_CACHE; i++)
1601 {
1602 speed_cnt[device_id] += device_param->speed_cnt[i];
1603 speed_ms[device_id] += device_param->speed_ms[i];
1604 }
1605
1606 speed_cnt[device_id] /= SPEED_CACHE;
1607 speed_ms[device_id] /= SPEED_CACHE;
1608 }
1609
1610 float hashes_all_ms = 0;
1611
1612 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1613
1614 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1615 {
1616 hc_device_param_t *device_param = &data.devices_param[device_id];
1617
1618 if (device_param->skipped) continue;
1619
1620 hashes_dev_ms[device_id] = 0;
1621
1622 if (speed_ms[device_id])
1623 {
1624 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1625
1626 hashes_all_ms += hashes_dev_ms[device_id];
1627 }
1628 }
1629
1630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1631 {
1632 hc_device_param_t *device_param = &data.devices_param[device_id];
1633
1634 if (device_param->skipped) continue;
1635
1636 char display_dev_cur[16] = { 0 };
1637
1638 strncpy (display_dev_cur, "0.00", 4);
1639
1640 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1641
1642 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1643 }
1644
1645 char display_all_cur[16] = { 0 };
1646
1647 strncpy (display_all_cur, "0.00", 4);
1648
1649 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1650
1651 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1652 }
1653
1654 /**
1655 * oclHashcat -only- functions
1656 */
1657
1658 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1659 {
1660 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1661 {
1662 if (attack_kern == ATTACK_KERN_STRAIGHT)
1663 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1664 else if (attack_kern == ATTACK_KERN_COMBI)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1666 else if (attack_kern == ATTACK_KERN_BF)
1667 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1668 }
1669 else
1670 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1671 }
1672
1673 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)
1674 {
1675 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1676 {
1677 if (attack_kern == ATTACK_KERN_STRAIGHT)
1678 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1679 else if (attack_kern == ATTACK_KERN_COMBI)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 else if (attack_kern == ATTACK_KERN_BF)
1682 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1683 }
1684 else
1685 {
1686 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1687 }
1688 }
1689
1690 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1691 {
1692 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1693 {
1694 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1695 }
1696 else
1697 {
1698 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1699 }
1700 }
1701
1702 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)
1703 {
1704 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1705 {
1706 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1707 }
1708 else
1709 {
1710 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1711 }
1712 }
1713
1714 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1715 {
1716 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1717 }
1718
1719 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1720 {
1721 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1722 }
1723
1724 static uint convert_from_hex (char *line_buf, const uint line_len)
1725 {
1726 if (line_len & 1) return (line_len); // not in hex
1727
1728 if (data.hex_wordlist == 1)
1729 {
1730 uint i;
1731 uint j;
1732
1733 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1734 {
1735 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1736 }
1737
1738 memset (line_buf + i, 0, line_len - i);
1739
1740 return (i);
1741 }
1742 else if (line_len >= 6) // $HEX[] = 6
1743 {
1744 if (line_buf[0] != '$') return (line_len);
1745 if (line_buf[1] != 'H') return (line_len);
1746 if (line_buf[2] != 'E') return (line_len);
1747 if (line_buf[3] != 'X') return (line_len);
1748 if (line_buf[4] != '[') return (line_len);
1749 if (line_buf[line_len - 1] != ']') return (line_len);
1750
1751 uint i;
1752 uint j;
1753
1754 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1755 {
1756 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1757 }
1758
1759 memset (line_buf + i, 0, line_len - i);
1760
1761 return (i);
1762 }
1763
1764 return (line_len);
1765 }
1766
1767 static uint count_lines (FILE *fd)
1768 {
1769 uint cnt = 0;
1770
1771 char *buf = (char *) mymalloc (BUFSIZ + 1);
1772
1773 size_t nread_tmp = 0;
1774
1775 char *ptr = buf;
1776
1777 while (!feof (fd))
1778 {
1779 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1780 nread_tmp = nread;
1781
1782 if (nread < 1) continue;
1783
1784 ptr = buf;
1785
1786 do
1787 {
1788 if (*ptr++ == '\n') cnt++;
1789
1790 } while (nread--);
1791 }
1792
1793 // special case (if last line did not contain a newline char ... at the very end of the file)
1794
1795 if (nread_tmp > 3)
1796 {
1797 ptr -= 2;
1798
1799 if (*ptr != '\n')
1800 {
1801 ptr--;
1802
1803 if (*ptr != '\n') // needed ? different on windows systems?
1804 {
1805 cnt++;
1806 }
1807 }
1808 }
1809
1810 myfree (buf);
1811
1812 return cnt;
1813 }
1814
1815 static void clear_prompt ()
1816 {
1817 fputc ('\r', stdout);
1818
1819 for (size_t i = 0; i < strlen (PROMPT); i++)
1820 {
1821 fputc (' ', stdout);
1822 }
1823
1824 fputc ('\r', stdout);
1825
1826 fflush (stdout);
1827 }
1828
1829 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1830 {
1831 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1832 }
1833
1834 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1835 {
1836 char *outfile = data.outfile;
1837 uint quiet = data.quiet;
1838 FILE *pot_fp = data.pot_fp;
1839 uint loopback = data.loopback;
1840 uint debug_mode = data.debug_mode;
1841 char *debug_file = data.debug_file;
1842
1843 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1844 int debug_rule_len = 0; // -1 error
1845 uint debug_plain_len = 0;
1846
1847 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1848
1849 // hash
1850
1851 char out_buf[4096] = { 0 };
1852
1853 ascii_digest (out_buf, salt_pos, digest_pos);
1854
1855 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1856
1857 // plain
1858
1859 plain_t plain;
1860
1861 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1862
1863 uint gidvid = plain.gidvid;
1864 uint il_pos = plain.il_pos;
1865
1866 u64 crackpos = device_param->words_off;
1867
1868 uint plain_buf[16] = { 0 };
1869
1870 u8 *plain_ptr = (u8 *) plain_buf;
1871 unsigned int plain_len = 0;
1872
1873 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1874 {
1875 u64 gidd = gidvid;
1876 u64 gidm = 0;
1877
1878 pw_t pw;
1879
1880 gidd_to_pw_t (device_param, gidd, &pw);
1881
1882 for (int i = 0, j = gidm; i < 16; i++, j++)
1883 {
1884 plain_buf[i] = pw.hi1[0][j];
1885 }
1886
1887 plain_len = pw.pw_len;
1888
1889 const uint off = device_param->innerloop_pos + il_pos;
1890
1891 if (debug_mode > 0)
1892 {
1893 debug_rule_len = 0;
1894
1895 // save rule
1896 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1897 {
1898 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1899
1900 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1901 }
1902
1903 // save plain
1904 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1905 {
1906 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1907
1908 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1909
1910 debug_plain_len = plain_len;
1911 }
1912 }
1913
1914 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1915
1916 crackpos += gidvid;
1917 crackpos *= data.kernel_rules_cnt;
1918 crackpos += device_param->innerloop_pos + il_pos;
1919
1920 if (plain_len > data.pw_max) plain_len = data.pw_max;
1921 }
1922 else if (data.attack_mode == ATTACK_MODE_COMBI)
1923 {
1924 u64 gidd = gidvid;
1925 u64 gidm = 0;
1926
1927 pw_t pw;
1928
1929 gidd_to_pw_t (device_param, gidd, &pw);
1930
1931 for (int i = 0, j = gidm; i < 16; i++, j++)
1932 {
1933 plain_buf[i] = pw.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1939 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1940
1941 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1942 {
1943 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1944 }
1945 else
1946 {
1947 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1948
1949 memcpy (plain_ptr, comb_buf, comb_len);
1950 }
1951
1952 plain_len += comb_len;
1953
1954 crackpos += gidvid;
1955 crackpos *= data.combs_cnt;
1956 crackpos += device_param->innerloop_pos + il_pos;
1957
1958 if (data.pw_max != PW_DICTMAX1)
1959 {
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 }
1963 else if (data.attack_mode == ATTACK_MODE_BF)
1964 {
1965 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1966 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1967
1968 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1969 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1970
1971 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1972 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1973
1974 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1975 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1976
1977 plain_len = data.css_cnt;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.bfs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982 }
1983 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1984 {
1985 u64 gidd = gidvid;
1986 u64 gidm = 0;
1987
1988 pw_t pw;
1989
1990 gidd_to_pw_t (device_param, gidd, &pw);
1991
1992 for (int i = 0, j = gidm; i < 16; i++, j++)
1993 {
1994 plain_buf[i] = pw.hi1[0][j];
1995 }
1996
1997 plain_len = pw.pw_len;
1998
1999 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2000
2001 uint start = 0;
2002 uint stop = device_param->kernel_params_mp_buf32[4];
2003
2004 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2005
2006 plain_len += start + stop;
2007
2008 crackpos += gidvid;
2009 crackpos *= data.combs_cnt;
2010 crackpos += device_param->innerloop_pos + il_pos;
2011
2012 if (data.pw_max != PW_DICTMAX1)
2013 {
2014 if (plain_len > data.pw_max) plain_len = data.pw_max;
2015 }
2016 }
2017 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2018 {
2019 u64 gidd = gidvid;
2020 u64 gidm = 0;
2021
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidd, &pw);
2025
2026 for (int i = 0, j = gidm; i < 16; i++, j++)
2027 {
2028 plain_buf[i] = pw.hi1[0][j];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 memmove (plain_ptr + stop, plain_ptr, plain_len);
2039
2040 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2041
2042 plain_len += start + stop;
2043
2044 crackpos += gidvid;
2045 crackpos *= data.combs_cnt;
2046 crackpos += device_param->innerloop_pos + il_pos;
2047
2048 if (data.pw_max != PW_DICTMAX1)
2049 {
2050 if (plain_len > data.pw_max) plain_len = data.pw_max;
2051 }
2052 }
2053
2054 if (data.attack_mode == ATTACK_MODE_BF)
2055 {
2056 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2057 {
2058 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2059 {
2060 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2061 {
2062 plain_len = plain_len - data.salts_buf[0].salt_len;
2063 }
2064 }
2065
2066 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2067 {
2068 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2069 {
2070 plain_ptr[j] = plain_ptr[i];
2071 }
2072
2073 plain_len = plain_len / 2;
2074 }
2075 }
2076 }
2077
2078 // if enabled, update also the potfile
2079
2080 if (pot_fp)
2081 {
2082 fprintf (pot_fp, "%s:", out_buf);
2083
2084 format_plain (pot_fp, plain_ptr, plain_len, 1);
2085
2086 fputc ('\n', pot_fp);
2087
2088 fflush (pot_fp);
2089 }
2090
2091 // outfile
2092
2093 FILE *out_fp = NULL;
2094
2095 if (outfile != NULL)
2096 {
2097 if ((out_fp = fopen (outfile, "ab")) == NULL)
2098 {
2099 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2100
2101 out_fp = stdout;
2102 }
2103 }
2104 else
2105 {
2106 out_fp = stdout;
2107
2108 if (quiet == 0) clear_prompt ();
2109 }
2110
2111 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2112
2113 if (outfile != NULL)
2114 {
2115 if (out_fp != stdout)
2116 {
2117 fclose (out_fp);
2118 }
2119 }
2120 else
2121 {
2122 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2123 {
2124 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2125 {
2126 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2127 if (quiet == 0) fflush (stdout);
2128 }
2129 }
2130 }
2131
2132 // loopback
2133
2134 if (loopback)
2135 {
2136 char *loopback_file = data.loopback_file;
2137
2138 FILE *fb_fp = NULL;
2139
2140 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2141 {
2142 format_plain (fb_fp, plain_ptr, plain_len, 1);
2143
2144 fputc ('\n', fb_fp);
2145
2146 fclose (fb_fp);
2147 }
2148 }
2149
2150 // (rule) debug mode
2151
2152 // the next check implies that:
2153 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2154 // - debug_mode > 0
2155
2156 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2157 {
2158 if (debug_rule_len < 0) debug_rule_len = 0;
2159
2160 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2161
2162 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2163
2164 if ((quiet == 0) && (debug_file == NULL))
2165 {
2166 fprintf (stdout, "%s", PROMPT);
2167 fflush (stdout);
2168 }
2169 }
2170 }
2171
2172 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2173 {
2174 salt_t *salt_buf = &data.salts_buf[salt_pos];
2175
2176 int found = 0;
2177
2178 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2179
2180 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2181
2182 if (found == 1)
2183 {
2184 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2185
2186 log_info_nn ("");
2187
2188 hc_clEnqueueReadBuffer (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);
2189
2190 uint cpt_cracked = 0;
2191
2192 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2193 {
2194 uint idx = salt_buf->digests_offset + digest_pos;
2195
2196 if (data.digests_shown_tmp[idx] == 0) continue;
2197
2198 if (data.digests_shown[idx] == 1) continue;
2199
2200 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2201 {
2202 data.digests_shown[idx] = 1;
2203
2204 data.digests_done++;
2205
2206 cpt_cracked++;
2207
2208 salt_buf->digests_done++;
2209
2210 if (salt_buf->digests_done == salt_buf->digests_cnt)
2211 {
2212 data.salts_shown[salt_pos] = 1;
2213
2214 data.salts_done++;
2215 }
2216 }
2217
2218 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2219
2220 check_hash (device_param, salt_pos, digest_pos);
2221 }
2222
2223 if (cpt_cracked > 0)
2224 {
2225 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2226 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2227
2228 data.cpt_pos++;
2229
2230 data.cpt_total += cpt_cracked;
2231
2232 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2233 }
2234
2235 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2236 {
2237 // we need to reset cracked state on the device
2238 // otherwise host thinks again and again the hash was cracked
2239 // and returns invalid password each time
2240
2241 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2242
2243 hc_clEnqueueWriteBuffer (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);
2244 }
2245
2246 memset (device_param->result, 0, device_param->size_results);
2247
2248 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2249 }
2250 }
2251
2252 static void save_hash ()
2253 {
2254 char *hashfile = data.hashfile;
2255
2256 char new_hashfile[256] = { 0 };
2257 char old_hashfile[256] = { 0 };
2258
2259 snprintf (new_hashfile, 255, "%s.new", hashfile);
2260 snprintf (old_hashfile, 255, "%s.old", hashfile);
2261
2262 unlink (new_hashfile);
2263
2264 char separator = data.separator;
2265
2266 FILE *fp = fopen (new_hashfile, "wb");
2267
2268 if (fp == NULL)
2269 {
2270 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2271
2272 exit (-1);
2273 }
2274
2275 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2276 {
2277 if (data.salts_shown[salt_pos] == 1) continue;
2278
2279 salt_t *salt_buf = &data.salts_buf[salt_pos];
2280
2281 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2282 {
2283 uint idx = salt_buf->digests_offset + digest_pos;
2284
2285 if (data.digests_shown[idx] == 1) continue;
2286
2287 if (data.hash_mode != 2500)
2288 {
2289 char out_buf[4096] = { 0 };
2290
2291 if (data.username == 1)
2292 {
2293 user_t *user = data.hash_info[idx]->user;
2294
2295 uint i;
2296
2297 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2298
2299 fputc (separator, fp);
2300 }
2301
2302 ascii_digest (out_buf, salt_pos, digest_pos);
2303
2304 fputs (out_buf, fp);
2305
2306 log_out (fp, "");
2307 }
2308 else
2309 {
2310 hccap_t hccap;
2311
2312 to_hccap_t (&hccap, salt_pos, digest_pos);
2313
2314 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2315 }
2316 }
2317 }
2318
2319 fflush (fp);
2320
2321 fclose (fp);
2322
2323 unlink (old_hashfile);
2324
2325 if (rename (hashfile, old_hashfile) != 0)
2326 {
2327 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2328
2329 exit (-1);
2330 }
2331
2332 unlink (hashfile);
2333
2334 if (rename (new_hashfile, hashfile) != 0)
2335 {
2336 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2337
2338 exit (-1);
2339 }
2340
2341 unlink (old_hashfile);
2342 }
2343
2344 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2345 {
2346 // function called only in case kernel_blocks_all > words_left)
2347
2348 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2349
2350 kernel_blocks_div += kernel_blocks_div / 100;
2351
2352 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2353
2354 while (kernel_blocks_new < total_left)
2355 {
2356 kernel_blocks_div += kernel_blocks_div / 100;
2357
2358 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2359 }
2360
2361 if (data.quiet == 0)
2362 {
2363 clear_prompt ();
2364
2365 log_info ("");
2366
2367 log_info ("INFO: approaching final keyspace, workload adjusted");
2368
2369 log_info ("");
2370
2371 fprintf (stdout, "%s", PROMPT);
2372
2373 fflush (stdout);
2374 }
2375
2376 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2377
2378 return kernel_blocks_div;
2379 }
2380
2381 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2382 {
2383 uint num_elements = num;
2384
2385 device_param->kernel_params_buf32[30] = data.combs_mode;
2386 device_param->kernel_params_buf32[31] = num;
2387
2388 uint kernel_threads = device_param->kernel_threads;
2389
2390 while (num_elements % kernel_threads) num_elements++;
2391
2392 cl_kernel kernel = NULL;
2393
2394 switch (kern_run)
2395 {
2396 case KERN_RUN_1: kernel = device_param->kernel1; break;
2397 case KERN_RUN_12: kernel = device_param->kernel12; break;
2398 case KERN_RUN_2: kernel = device_param->kernel2; break;
2399 case KERN_RUN_23: kernel = device_param->kernel23; break;
2400 case KERN_RUN_3: kernel = device_param->kernel3; break;
2401 }
2402
2403 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2404 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2405 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2406 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2407 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2408 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2409 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2410 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2411 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2412 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2413 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2414
2415 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2416 {
2417 const size_t global_work_size[3] = { num_elements, 32, 1 };
2418 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2419
2420 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2421 }
2422 else
2423 {
2424 const size_t global_work_size[3] = { num_elements, 1, 1 };
2425 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2426
2427 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2428 }
2429
2430 hc_clFlush (device_param->command_queue);
2431
2432 hc_clFinish (device_param->command_queue);
2433 }
2434
2435 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2436 {
2437 uint num_elements = num;
2438
2439 switch (kern_run)
2440 {
2441 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2442 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2443 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2444 }
2445
2446 // causes problems with special threads like in bcrypt
2447 // const uint kernel_threads = device_param->kernel_threads;
2448
2449 const uint kernel_threads = KERNEL_THREADS;
2450
2451 while (num_elements % kernel_threads) num_elements++;
2452
2453 cl_kernel kernel = NULL;
2454
2455 switch (kern_run)
2456 {
2457 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2458 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2459 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2460 }
2461
2462 switch (kern_run)
2463 {
2464 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2465 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2466 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2467 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2468 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2469 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2470 break;
2471 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2472 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2473 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2474 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2475 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2476 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2477 break;
2478 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2479 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2480 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2481 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2482 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2483 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2484 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2485 break;
2486 }
2487
2488 const size_t global_work_size[3] = { num_elements, 1, 1 };
2489 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2490
2491 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2492
2493 hc_clFlush (device_param->command_queue);
2494
2495 hc_clFinish (device_param->command_queue);
2496 }
2497
2498 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2499 {
2500 uint num_elements = num;
2501
2502 uint kernel_threads = device_param->kernel_threads;
2503
2504 while (num_elements % kernel_threads) num_elements++;
2505
2506 cl_kernel kernel = device_param->kernel_tb;
2507
2508 const size_t global_work_size[3] = { num_elements, 1, 1 };
2509 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2510
2511 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2512
2513 hc_clFlush (device_param->command_queue);
2514
2515 hc_clFinish (device_param->command_queue);
2516 }
2517
2518 static void run_kernel_tm (hc_device_param_t *device_param)
2519 {
2520 const uint num_elements = 1024; // fixed
2521
2522 const uint kernel_threads = 32;
2523
2524 cl_kernel kernel = device_param->kernel_tm;
2525
2526 const size_t global_work_size[3] = { num_elements, 1, 1 };
2527 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2528
2529 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2530
2531 hc_clFlush (device_param->command_queue);
2532
2533 hc_clFinish (device_param->command_queue);
2534 }
2535
2536 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2537 {
2538 uint num_elements = num;
2539
2540 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2541 device_param->kernel_params_amp_buf32[6] = num_elements;
2542
2543 // causes problems with special threads like in bcrypt
2544 // const uint kernel_threads = device_param->kernel_threads;
2545
2546 const uint kernel_threads = KERNEL_THREADS;
2547
2548 while (num_elements % kernel_threads) num_elements++;
2549
2550 cl_kernel kernel = device_param->kernel_amp;
2551
2552 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2553 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (device_param->command_queue);
2561
2562 hc_clFinish (device_param->command_queue);
2563 }
2564
2565 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2566 {
2567 if (device_param->vendor_id == VENDOR_ID_AMD)
2568 {
2569 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2570
2571 const cl_uchar zero = 0;
2572
2573 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2574 }
2575 else
2576 {
2577 // NOTE: clEnqueueFillBuffer () always fails with -59
2578 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2579 // How's that possible, OpenCL 1.2 support is advertised??
2580 // We need to workaround...
2581
2582 #define FILLSZ 0x100000
2583
2584 char *tmp = (char *) mymalloc (FILLSZ);
2585
2586 for (uint i = 0; i < size; i += FILLSZ)
2587 {
2588 const int left = size - i;
2589
2590 const int fillsz = MIN (FILLSZ, left);
2591
2592 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2593 }
2594
2595 myfree (tmp);
2596 }
2597 }
2598
2599 static int run_rule_engine (const int rule_len, const char *rule_buf)
2600 {
2601 if (rule_len == 0)
2602 {
2603 return 0;
2604 }
2605 else if (rule_len == 1)
2606 {
2607 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2608 }
2609
2610 return 1;
2611 }
2612
2613 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2614 {
2615 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2616 {
2617 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2618 }
2619 else if (data.attack_kern == ATTACK_KERN_COMBI)
2620 {
2621 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2622 }
2623 else if (data.attack_kern == ATTACK_KERN_BF)
2624 {
2625 const u64 off = device_param->words_off;
2626
2627 device_param->kernel_params_mp_l_buf64[3] = off;
2628
2629 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2630 }
2631 }
2632
2633 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2634 {
2635 const uint kernel_loops = data.kernel_loops;
2636
2637 // init speed timer
2638
2639 uint speed_pos = device_param->speed_pos;
2640
2641 #ifdef _POSIX
2642 if (device_param->timer_speed.tv_sec == 0)
2643 {
2644 hc_timer_set (&device_param->timer_speed);
2645 }
2646 #endif
2647
2648 #ifdef _WIN
2649 if (device_param->timer_speed.QuadPart == 0)
2650 {
2651 hc_timer_set (&device_param->timer_speed);
2652 }
2653 #endif
2654
2655 // find higest password length, this is for optimization stuff
2656
2657 uint highest_pw_len = 0;
2658
2659 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2660 {
2661 }
2662 else if (data.attack_kern == ATTACK_KERN_COMBI)
2663 {
2664 }
2665 else if (data.attack_kern == ATTACK_KERN_BF)
2666 {
2667 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2668 + device_param->kernel_params_mp_l_buf32[5];
2669 }
2670
2671 // bitslice optimization stuff
2672
2673 if (data.attack_mode == ATTACK_MODE_BF)
2674 {
2675 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2676 {
2677 run_kernel_tb (device_param, pws_cnt);
2678 }
2679 }
2680
2681 // iteration type
2682
2683 uint innerloop_step = 0;
2684 uint innerloop_cnt = 0;
2685
2686 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2687 else innerloop_step = 1;
2688
2689 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2690 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2691 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2692
2693 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2694
2695 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2696 {
2697 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2698
2699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2700
2701 if (data.devices_status == STATUS_CRACKED) break;
2702 if (data.devices_status == STATUS_ABORTED) break;
2703 if (data.devices_status == STATUS_QUIT) break;
2704 if (data.devices_status == STATUS_BYPASS) break;
2705
2706 if (data.salts_shown[salt_pos] == 1) continue;
2707
2708 salt_t *salt_buf = &data.salts_buf[salt_pos];
2709
2710 device_param->kernel_params_buf32[24] = salt_pos;
2711 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2712 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2713
2714 FILE *combs_fp = device_param->combs_fp;
2715
2716 if (data.attack_mode == ATTACK_MODE_COMBI)
2717 {
2718 rewind (combs_fp);
2719 }
2720
2721 // innerloops
2722
2723 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2724 {
2725 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2726
2727 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2728
2729 if (data.devices_status == STATUS_CRACKED) break;
2730 if (data.devices_status == STATUS_ABORTED) break;
2731 if (data.devices_status == STATUS_QUIT) break;
2732 if (data.devices_status == STATUS_BYPASS) break;
2733
2734 uint innerloop_left = innerloop_cnt - innerloop_pos;
2735
2736 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2737
2738 device_param->innerloop_pos = innerloop_pos;
2739 device_param->innerloop_left = innerloop_left;
2740
2741 device_param->kernel_params_buf32[27] = innerloop_left;
2742
2743 if (innerloop_left == 0) continue;
2744
2745 // initialize amplifiers
2746
2747 if (data.attack_mode == ATTACK_MODE_COMBI)
2748 {
2749 char line_buf[BUFSIZ] = { 0 };
2750
2751 uint i = 0;
2752
2753 while (i < innerloop_left)
2754 {
2755 if (feof (combs_fp)) break;
2756
2757 int line_len = fgetl (combs_fp, line_buf);
2758
2759 if (line_len >= PW_MAX1) continue;
2760
2761 line_len = convert_from_hex (line_buf, line_len);
2762
2763 char *line_buf_new = line_buf;
2764
2765 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2766 {
2767 char rule_buf_out[BLOCK_SIZE] = { 0 };
2768
2769 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2770
2771 if (rule_len_out < 0)
2772 {
2773 data.words_progress_rejected[salt_pos] += pw_cnt;
2774
2775 continue;
2776 }
2777
2778 line_len = rule_len_out;
2779
2780 line_buf_new = rule_buf_out;
2781 }
2782
2783 line_len = MIN (line_len, PW_DICTMAX);
2784
2785 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2786
2787 memcpy (ptr, line_buf_new, line_len);
2788
2789 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2790
2791 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2792 {
2793 uppercase (ptr, line_len);
2794 }
2795
2796 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2797 {
2798 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2799 {
2800 ptr[line_len] = 0x80;
2801 }
2802
2803 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2804 {
2805 ptr[line_len] = 0x01;
2806 }
2807 }
2808
2809 device_param->combs_buf[i].pw_len = line_len;
2810
2811 i++;
2812 }
2813
2814 for (uint j = i; j < innerloop_left; j++)
2815 {
2816 device_param->combs_buf[j].i[0] = 0;
2817 device_param->combs_buf[j].i[1] = 0;
2818 device_param->combs_buf[j].i[2] = 0;
2819 device_param->combs_buf[j].i[3] = 0;
2820 device_param->combs_buf[j].i[4] = 0;
2821 device_param->combs_buf[j].i[5] = 0;
2822 device_param->combs_buf[j].i[6] = 0;
2823 device_param->combs_buf[j].i[7] = 0;
2824
2825 device_param->combs_buf[j].pw_len = 0;
2826 }
2827
2828 innerloop_left = i;
2829 }
2830 else if (data.attack_mode == ATTACK_MODE_BF)
2831 {
2832 u64 off = innerloop_pos;
2833
2834 device_param->kernel_params_mp_r_buf64[3] = off;
2835
2836 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2837 }
2838 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2839 {
2840 u64 off = innerloop_pos;
2841
2842 device_param->kernel_params_mp_buf64[3] = off;
2843
2844 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2845 }
2846 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2847 {
2848 u64 off = innerloop_pos;
2849
2850 device_param->kernel_params_mp_buf64[3] = off;
2851
2852 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2853 }
2854
2855 // copy amplifiers
2856
2857 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2858 {
2859 hc_clEnqueueCopyBuffer (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);
2860 }
2861 else if (data.attack_mode == ATTACK_MODE_COMBI)
2862 {
2863 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2864 }
2865 else if (data.attack_mode == ATTACK_MODE_BF)
2866 {
2867 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2868 }
2869 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2870 {
2871 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2872 }
2873 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2874 {
2875 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2876 }
2877
2878 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2879 {
2880 if (data.attack_mode == ATTACK_MODE_BF)
2881 {
2882 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2883 {
2884 const uint size_tm = 32 * sizeof (bs_word_t);
2885
2886 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2887
2888 run_kernel_tm (device_param);
2889
2890 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2891 }
2892 }
2893
2894 if (highest_pw_len < 16)
2895 {
2896 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2897 }
2898 else if (highest_pw_len < 32)
2899 {
2900 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2901 }
2902 else
2903 {
2904 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2905 }
2906 }
2907 else
2908 {
2909 run_kernel_amp (device_param, pws_cnt);
2910
2911 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2912
2913 if (data.opts_type & OPTS_TYPE_HOOK12)
2914 {
2915 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2916 }
2917
2918 uint iter = salt_buf->salt_iter;
2919
2920 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2921 {
2922 uint loop_left = iter - loop_pos;
2923
2924 loop_left = MIN (loop_left, kernel_loops);
2925
2926 device_param->kernel_params_buf32[25] = loop_pos;
2927 device_param->kernel_params_buf32[26] = loop_left;
2928
2929 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2930
2931 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2932
2933 if (data.devices_status == STATUS_CRACKED) break;
2934 if (data.devices_status == STATUS_ABORTED) break;
2935 if (data.devices_status == STATUS_QUIT) break;
2936 }
2937
2938 if (data.opts_type & OPTS_TYPE_HOOK23)
2939 {
2940 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2941
2942 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2943
2944 // do something with data
2945
2946 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2947 }
2948
2949 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2950 }
2951
2952 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2953
2954 if (data.devices_status == STATUS_CRACKED) break;
2955 if (data.devices_status == STATUS_ABORTED) break;
2956 if (data.devices_status == STATUS_QUIT) break;
2957
2958 /**
2959 * result
2960 */
2961
2962 hc_thread_mutex_lock (mux_display);
2963
2964 check_cracked (device_param, salt_pos);
2965
2966 hc_thread_mutex_unlock (mux_display);
2967
2968 /**
2969 * progress
2970 */
2971
2972 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2973
2974 hc_thread_mutex_lock (mux_counter);
2975
2976 data.words_progress_done[salt_pos] += perf_sum_all;
2977
2978 hc_thread_mutex_unlock (mux_counter);
2979
2980 /**
2981 * speed
2982 */
2983
2984 float speed_ms;
2985
2986 hc_timer_get (device_param->timer_speed, speed_ms);
2987
2988 hc_timer_set (&device_param->timer_speed);
2989
2990 hc_thread_mutex_lock (mux_display);
2991
2992 device_param->speed_cnt[speed_pos] = perf_sum_all;
2993
2994 device_param->speed_ms[speed_pos] = speed_ms;
2995
2996 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2997
2998 hc_thread_mutex_unlock (mux_display);
2999
3000 speed_pos++;
3001
3002 if (speed_pos == SPEED_CACHE)
3003 {
3004 speed_pos = 0;
3005 }
3006 }
3007 }
3008
3009 device_param->speed_pos = speed_pos;
3010 }
3011
3012 static void load_segment (wl_data_t *wl_data, FILE *fd)
3013 {
3014 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3015
3016 wl_data->pos = 0;
3017
3018 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3019
3020 wl_data->buf[wl_data->cnt] = 0;
3021
3022 if (wl_data->cnt == 0) return;
3023
3024 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3025
3026 while (!feof (fd))
3027 {
3028 if (wl_data->cnt == wl_data->avail)
3029 {
3030 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3031
3032 wl_data->avail += wl_data->incr;
3033 }
3034
3035 const int c = fgetc (fd);
3036
3037 if (c == EOF) break;
3038
3039 wl_data->buf[wl_data->cnt] = (char) c;
3040
3041 wl_data->cnt++;
3042
3043 if (c == '\n') break;
3044 }
3045
3046 // ensure stream ends with a newline
3047
3048 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3049 {
3050 wl_data->cnt++;
3051
3052 wl_data->buf[wl_data->cnt - 1] = '\n';
3053 }
3054
3055 return;
3056 }
3057
3058 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3059 {
3060 char *ptr = buf;
3061
3062 for (u32 i = 0; i < sz; i++, ptr++)
3063 {
3064 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3065
3066 if (i == 7)
3067 {
3068 *off = i;
3069 *len = i;
3070
3071 return;
3072 }
3073
3074 if (*ptr != '\n') continue;
3075
3076 *off = i + 1;
3077
3078 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3079
3080 *len = i;
3081
3082 return;
3083 }
3084
3085 *off = sz;
3086 *len = sz;
3087 }
3088
3089 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3090 {
3091 char *ptr = buf;
3092
3093 for (u32 i = 0; i < sz; i++, ptr++)
3094 {
3095 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
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_std (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 != '\n') continue;
3119
3120 *off = i + 1;
3121
3122 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3123
3124 *len = i;
3125
3126 return;
3127 }
3128
3129 *off = sz;
3130 *len = sz;
3131 }
3132
3133 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3134 {
3135 while (wl_data->pos < wl_data->cnt)
3136 {
3137 uint off;
3138 uint len;
3139
3140 char *ptr = wl_data->buf + wl_data->pos;
3141
3142 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3143
3144 wl_data->pos += off;
3145
3146 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3147 {
3148 char rule_buf_out[BLOCK_SIZE] = { 0 };
3149
3150 int rule_len_out = -1;
3151
3152 if (len < BLOCK_SIZE)
3153 {
3154 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3155 }
3156
3157 if (rule_len_out < 0)
3158 {
3159 continue;
3160 }
3161
3162 if (rule_len_out > PW_MAX)
3163 {
3164 continue;
3165 }
3166 }
3167 else
3168 {
3169 if (len > PW_MAX)
3170 {
3171 continue;
3172 }
3173 }
3174
3175 *out_buf = ptr;
3176 *out_len = len;
3177
3178 return;
3179 }
3180
3181 if (feof (fd))
3182 {
3183 fprintf (stderr, "bug!!\n");
3184
3185 return;
3186 }
3187
3188 load_segment (wl_data, fd);
3189
3190 get_next_word (wl_data, fd, out_buf, out_len);
3191 }
3192
3193 #ifdef _POSIX
3194 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3195 #endif
3196
3197 #ifdef _WIN
3198 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3199 #endif
3200 {
3201 hc_signal (NULL);
3202
3203 dictstat_t d;
3204
3205 d.cnt = 0;
3206
3207 #ifdef _POSIX
3208 fstat (fileno (fd), &d.stat);
3209 #endif
3210
3211 #ifdef _WIN
3212 _fstat64 (fileno (fd), &d.stat);
3213 #endif
3214
3215 d.stat.st_mode = 0;
3216 d.stat.st_nlink = 0;
3217 d.stat.st_uid = 0;
3218 d.stat.st_gid = 0;
3219 d.stat.st_rdev = 0;
3220 d.stat.st_atime = 0;
3221
3222 #ifdef _POSIX
3223 d.stat.st_blksize = 0;
3224 d.stat.st_blocks = 0;
3225 #endif
3226
3227 if (d.stat.st_size == 0) return 0;
3228
3229 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3230
3231 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3232 {
3233 if (d_cache)
3234 {
3235 u64 cnt = d_cache->cnt;
3236
3237 u64 keyspace = cnt;
3238
3239 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3240 {
3241 keyspace *= data.kernel_rules_cnt;
3242 }
3243 else if (data.attack_kern == ATTACK_KERN_COMBI)
3244 {
3245 keyspace *= data.combs_cnt;
3246 }
3247
3248 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);
3249 if (data.quiet == 0) log_info ("");
3250
3251 hc_signal (sigHandler_default);
3252
3253 return (keyspace);
3254 }
3255 }
3256
3257 time_t now = 0;
3258 time_t prev = 0;
3259
3260 u64 comp = 0;
3261 u64 cnt = 0;
3262 u64 cnt2 = 0;
3263
3264 while (!feof (fd))
3265 {
3266 load_segment (wl_data, fd);
3267
3268 comp += wl_data->cnt;
3269
3270 u32 i = 0;
3271
3272 while (i < wl_data->cnt)
3273 {
3274 u32 len;
3275 u32 off;
3276
3277 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3278
3279 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3280 {
3281 char rule_buf_out[BLOCK_SIZE] = { 0 };
3282
3283 int rule_len_out = -1;
3284
3285 if (len < BLOCK_SIZE)
3286 {
3287 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3288 }
3289
3290 if (rule_len_out < 0)
3291 {
3292 len = PW_MAX1;
3293 }
3294 else
3295 {
3296 len = rule_len_out;
3297 }
3298 }
3299
3300 if (len < PW_MAX1)
3301 {
3302 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3303 {
3304 cnt += data.kernel_rules_cnt;
3305 }
3306 else if (data.attack_kern == ATTACK_KERN_COMBI)
3307 {
3308 cnt += data.combs_cnt;
3309 }
3310
3311 d.cnt++;
3312 }
3313
3314 i += off;
3315
3316 cnt2++;
3317 }
3318
3319 time (&now);
3320
3321 if ((now - prev) == 0) continue;
3322
3323 float percent = (float) comp / (float) d.stat.st_size;
3324
3325 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);
3326
3327 time (&prev);
3328 }
3329
3330 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);
3331 if (data.quiet == 0) log_info ("");
3332
3333 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3334
3335 hc_signal (sigHandler_default);
3336
3337 return (cnt);
3338 }
3339
3340 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3341 {
3342 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3343 }
3344
3345 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3346 {
3347 if (data.devices_status == STATUS_BYPASS) return 0;
3348
3349 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3350
3351 uint cache_cnt = pw_cache->cnt;
3352
3353 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3354
3355 memcpy (pw_hc1, pw_buf, pw_len);
3356
3357 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3358
3359 uint pws_cnt = device_param->pws_cnt;
3360
3361 cache_cnt++;
3362
3363 pw_t *pw = device_param->pws_buf + pws_cnt;
3364
3365 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3366
3367 pw->pw_len = pw_len;
3368
3369 pws_cnt++;
3370
3371 device_param->pws_cnt = pws_cnt;
3372 device_param->pw_cnt = pws_cnt * 1;
3373
3374 cache_cnt = 0;
3375
3376 pw_cache->cnt = cache_cnt;
3377
3378 return pws_cnt;
3379 }
3380
3381 static void *thread_monitor (void *p)
3382 {
3383 uint runtime_check = 0;
3384 uint remove_check = 0;
3385 uint status_check = 0;
3386 uint restore_check = 0;
3387
3388 uint restore_left = data.restore_timer;
3389 uint remove_left = data.remove_timer;
3390 uint status_left = data.status_timer;
3391
3392 #ifdef HAVE_HWMON
3393 uint hwmon_check = 0;
3394
3395 // these variables are mainly used for fan control (AMD only)
3396
3397 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3398
3399 // temperature controller "loopback" values
3400
3401 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3402 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3403
3404 #ifdef HAVE_ADL
3405 int temp_threshold = 1; // degrees celcius
3406
3407 int fan_speed_min = 15; // in percentage
3408 int fan_speed_max = 100;
3409 #endif // HAVE_ADL
3410
3411 time_t last_temp_check_time;
3412 #endif // HAVE_HWMON
3413
3414 uint sleep_time = 1;
3415
3416 if (data.runtime)
3417 {
3418 runtime_check = 1;
3419 }
3420
3421 if (data.restore_timer)
3422 {
3423 restore_check = 1;
3424 }
3425
3426 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3427 {
3428 remove_check = 1;
3429 }
3430
3431 if (data.status == 1)
3432 {
3433 status_check = 1;
3434 }
3435
3436 #ifdef HAVE_HWMON
3437 if (data.gpu_temp_disable == 0)
3438 {
3439 time (&last_temp_check_time);
3440
3441 hwmon_check = 1;
3442 }
3443 #endif
3444
3445 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3446 {
3447 #ifdef HAVE_HWMON
3448 if (hwmon_check == 0)
3449 #endif
3450 return (p);
3451 }
3452
3453 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3454 {
3455 hc_sleep (sleep_time);
3456
3457 if (data.devices_status != STATUS_RUNNING) continue;
3458
3459 #ifdef HAVE_HWMON
3460 if (hwmon_check == 1)
3461 {
3462 hc_thread_mutex_lock (mux_adl);
3463
3464 time_t temp_check_time;
3465
3466 time (&temp_check_time);
3467
3468 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3469
3470 if (Ta == 0) Ta = 1;
3471
3472 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3473 {
3474 hc_device_param_t *device_param = &data.devices_param[device_id];
3475
3476 if (device_param->skipped) continue;
3477
3478 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3479
3480 const int temperature = hm_get_temperature_with_device_id (device_id);
3481
3482 if (temperature > (int) data.gpu_temp_abort)
3483 {
3484 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3485
3486 if (data.devices_status != STATUS_QUIT) myabort ();
3487
3488 break;
3489 }
3490
3491 #ifdef HAVE_ADL
3492 const int gpu_temp_retain = data.gpu_temp_retain;
3493
3494 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3495 {
3496 if (data.hm_device[device_id].fan_supported == 1)
3497 {
3498 int temp_cur = temperature;
3499
3500 int temp_diff_new = gpu_temp_retain - temp_cur;
3501
3502 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3503
3504 // calculate Ta value (time difference in seconds between the last check and this check)
3505
3506 last_temp_check_time = temp_check_time;
3507
3508 float Kp = 1.8;
3509 float Ki = 0.005;
3510 float Kd = 6;
3511
3512 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3513
3514 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);
3515
3516 if (abs (fan_diff_required) >= temp_threshold)
3517 {
3518 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3519
3520 int fan_speed_level = fan_speed_cur;
3521
3522 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3523
3524 int fan_speed_new = fan_speed_level - fan_diff_required;
3525
3526 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3527 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3528
3529 if (fan_speed_new != fan_speed_cur)
3530 {
3531 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3532 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3533
3534 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3535 {
3536 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3537
3538 fan_speed_chgd[device_id] = 1;
3539 }
3540
3541 temp_diff_old[device_id] = temp_diff_new;
3542 }
3543 }
3544 }
3545 }
3546 #endif // HAVE_ADL
3547 }
3548
3549 hc_thread_mutex_unlock (mux_adl);
3550 }
3551 #endif // HAVE_HWMON
3552
3553 if (restore_check == 1)
3554 {
3555 restore_left--;
3556
3557 if (restore_left == 0)
3558 {
3559 if (data.restore_disable == 0) cycle_restore ();
3560
3561 restore_left = data.restore_timer;
3562 }
3563 }
3564
3565 if ((runtime_check == 1) && (data.runtime_start > 0))
3566 {
3567 time_t runtime_cur;
3568
3569 time (&runtime_cur);
3570
3571 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3572
3573 if (runtime_left <= 0)
3574 {
3575 if (data.benchmark == 0)
3576 {
3577 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3578 }
3579
3580 if (data.devices_status != STATUS_QUIT) myabort ();
3581 }
3582 }
3583
3584 if (remove_check == 1)
3585 {
3586 remove_left--;
3587
3588 if (remove_left == 0)
3589 {
3590 if (data.digests_saved != data.digests_done)
3591 {
3592 data.digests_saved = data.digests_done;
3593
3594 save_hash ();
3595 }
3596
3597 remove_left = data.remove_timer;
3598 }
3599 }
3600
3601 if (status_check == 1)
3602 {
3603 status_left--;
3604
3605 if (status_left == 0)
3606 {
3607 hc_thread_mutex_lock (mux_display);
3608
3609 if (data.quiet == 0) clear_prompt ();
3610
3611 if (data.quiet == 0) log_info ("");
3612
3613 status_display ();
3614
3615 if (data.quiet == 0) log_info ("");
3616
3617 hc_thread_mutex_unlock (mux_display);
3618
3619 status_left = data.status_timer;
3620 }
3621 }
3622 }
3623
3624 #ifdef HAVE_HWMON
3625 myfree (fan_speed_chgd);
3626
3627 myfree (temp_diff_old);
3628 myfree (temp_diff_sum);
3629 #endif
3630
3631 p = NULL;
3632
3633 return (p);
3634 }
3635
3636 static void *thread_outfile_remove (void *p)
3637 {
3638 // some hash-dependent constants
3639 char *outfile_dir = data.outfile_check_directory;
3640 uint dgst_size = data.dgst_size;
3641 uint isSalted = data.isSalted;
3642 uint esalt_size = data.esalt_size;
3643 uint hash_mode = data.hash_mode;
3644
3645 uint outfile_check_timer = data.outfile_check_timer;
3646
3647 char separator = data.separator;
3648
3649 // some hash-dependent functions
3650 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3651 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3652
3653 // buffers
3654 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3655
3656 hash_buf.digest = mymalloc (dgst_size);
3657
3658 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3659
3660 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3661
3662 uint digest_buf[64] = { 0 };
3663
3664 outfile_data_t *out_info = NULL;
3665
3666 char **out_files = NULL;
3667
3668 time_t folder_mtime = 0;
3669
3670 int out_cnt = 0;
3671
3672 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3673
3674 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3675 {
3676 hc_sleep (1);
3677
3678 if (data.devices_status != STATUS_RUNNING) continue;
3679
3680 check_left--;
3681
3682 if (check_left == 0)
3683 {
3684 struct stat outfile_check_stat;
3685
3686 if (stat (outfile_dir, &outfile_check_stat) == 0)
3687 {
3688 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3689
3690 if (is_dir == 1)
3691 {
3692 if (outfile_check_stat.st_mtime > folder_mtime)
3693 {
3694 char **out_files_new = scan_directory (outfile_dir);
3695
3696 int out_cnt_new = count_dictionaries (out_files_new);
3697
3698 outfile_data_t *out_info_new = NULL;
3699
3700 if (out_cnt_new > 0)
3701 {
3702 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3703
3704 for (int i = 0; i < out_cnt_new; i++)
3705 {
3706 out_info_new[i].file_name = out_files_new[i];
3707
3708 // check if there are files that we have seen/checked before (and not changed)
3709
3710 for (int j = 0; j < out_cnt; j++)
3711 {
3712 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3713 {
3714 struct stat outfile_stat;
3715
3716 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3717 {
3718 if (outfile_stat.st_ctime == out_info[j].ctime)
3719 {
3720 out_info_new[i].ctime = out_info[j].ctime;
3721 out_info_new[i].seek = out_info[j].seek;
3722 }
3723 }
3724 }
3725 }
3726 }
3727 }
3728
3729 local_free (out_info);
3730 local_free (out_files);
3731
3732 out_files = out_files_new;
3733 out_cnt = out_cnt_new;
3734 out_info = out_info_new;
3735
3736 folder_mtime = outfile_check_stat.st_mtime;
3737 }
3738
3739 for (int j = 0; j < out_cnt; j++)
3740 {
3741 FILE *fp = fopen (out_info[j].file_name, "rb");
3742
3743 if (fp != NULL)
3744 {
3745 //hc_thread_mutex_lock (mux_display);
3746
3747 #ifdef _POSIX
3748 struct stat outfile_stat;
3749
3750 fstat (fileno (fp), &outfile_stat);
3751 #endif
3752
3753 #ifdef _WIN
3754 struct stat64 outfile_stat;
3755
3756 _fstat64 (fileno (fp), &outfile_stat);
3757 #endif
3758
3759 if (outfile_stat.st_ctime > out_info[j].ctime)
3760 {
3761 out_info[j].ctime = outfile_stat.st_ctime;
3762 out_info[j].seek = 0;
3763 }
3764
3765 fseek (fp, out_info[j].seek, SEEK_SET);
3766
3767 while (!feof (fp))
3768 {
3769 char line_buf[BUFSIZ] = { 0 };
3770
3771 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3772
3773 if (ptr == NULL) break;
3774
3775 int line_len = strlen (line_buf);
3776
3777 if (line_len <= 0) continue;
3778
3779 int iter = MAX_CUT_TRIES;
3780
3781 for (uint i = line_len - 1; i && iter; i--, line_len--)
3782 {
3783 if (line_buf[i] != separator) continue;
3784
3785 int parser_status = PARSER_OK;
3786
3787 if ((hash_mode != 2500) && (hash_mode != 6800))
3788 {
3789 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3790 }
3791
3792 uint found = 0;
3793
3794 if (parser_status == PARSER_OK)
3795 {
3796 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3797 {
3798 if (data.salts_shown[salt_pos] == 1) continue;
3799
3800 salt_t *salt_buf = &data.salts_buf[salt_pos];
3801
3802 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3803 {
3804 uint idx = salt_buf->digests_offset + digest_pos;
3805
3806 if (data.digests_shown[idx] == 1) continue;
3807
3808 uint cracked = 0;
3809
3810 if (hash_mode == 6800)
3811 {
3812 if (i == salt_buf->salt_len)
3813 {
3814 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3815 }
3816 }
3817 else if (hash_mode == 2500)
3818 {
3819 // BSSID : MAC1 : MAC2 (:plain)
3820 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3821 {
3822 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3823
3824 if (!cracked) continue;
3825
3826 // now compare MAC1 and MAC2 too, since we have this additional info
3827 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3828 char *mac2_pos = mac1_pos + 12 + 1;
3829
3830 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3831 wpa_t *wpa = &wpas[salt_pos];
3832
3833 uint pke[25] = { 0 };
3834
3835 char *pke_ptr = (char *) pke;
3836
3837 for (uint i = 0; i < 25; i++)
3838 {
3839 pke[i] = byte_swap_32 (wpa->pke[i]);
3840 }
3841
3842 u8 mac1[6] = { 0 };
3843 u8 mac2[6] = { 0 };
3844
3845 memcpy (mac1, pke_ptr + 23, 6);
3846 memcpy (mac2, pke_ptr + 29, 6);
3847
3848 // compare hex string(s) vs binary MAC address(es)
3849
3850 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3851 {
3852 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3853 {
3854 cracked = 0;
3855 break;
3856 }
3857 }
3858
3859 // early skip ;)
3860 if (!cracked) continue;
3861
3862 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3863 {
3864 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3865 {
3866 cracked = 0;
3867 break;
3868 }
3869 }
3870 }
3871 }
3872 else
3873 {
3874 char *digests_buf_ptr = (char *) data.digests_buf;
3875
3876 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3877
3878 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3879 }
3880
3881 if (cracked == 1)
3882 {
3883 found = 1;
3884
3885 data.digests_shown[idx] = 1;
3886
3887 data.digests_done++;
3888
3889 salt_buf->digests_done++;
3890
3891 if (salt_buf->digests_done == salt_buf->digests_cnt)
3892 {
3893 data.salts_shown[salt_pos] = 1;
3894
3895 data.salts_done++;
3896
3897 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3898 }
3899 }
3900 }
3901
3902 if (data.devices_status == STATUS_CRACKED) break;
3903 }
3904 }
3905
3906 if (found) break;
3907
3908 if (data.devices_status == STATUS_CRACKED) break;
3909
3910 iter--;
3911 }
3912
3913 if (data.devices_status == STATUS_CRACKED) break;
3914 }
3915
3916 out_info[j].seek = ftell (fp);
3917
3918 //hc_thread_mutex_unlock (mux_display);
3919
3920 fclose (fp);
3921 }
3922 }
3923 }
3924 }
3925
3926 check_left = outfile_check_timer;
3927 }
3928 }
3929
3930 if (esalt_size) local_free (hash_buf.esalt);
3931
3932 if (isSalted) local_free (hash_buf.salt);
3933
3934 local_free (hash_buf.digest);
3935
3936 local_free (out_info);
3937
3938 local_free (out_files);
3939
3940 p = NULL;
3941
3942 return (p);
3943 }
3944
3945 static uint get_work (hc_device_param_t *device_param, const u64 max)
3946 {
3947 hc_thread_mutex_lock (mux_dispatcher);
3948
3949 const u64 words_cur = data.words_cur;
3950 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3951
3952 device_param->words_off = words_cur;
3953
3954 const u64 words_left = words_base - words_cur;
3955
3956 if (data.kernel_blocks_all > words_left)
3957 {
3958 if (data.kernel_blocks_div == 0)
3959 {
3960 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3961 }
3962 }
3963
3964 if (data.kernel_blocks_div)
3965 {
3966 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3967 {
3968 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3969 const u32 kernel_power_new = kernel_blocks_new;
3970
3971 if (kernel_blocks_new < device_param->kernel_blocks)
3972 {
3973 device_param->kernel_blocks = kernel_blocks_new;
3974 device_param->kernel_power = kernel_power_new;
3975 }
3976 }
3977 }
3978
3979 const uint kernel_blocks = device_param->kernel_blocks;
3980
3981 uint work = MIN (words_left, kernel_blocks);
3982
3983 work = MIN (work, max);
3984
3985 data.words_cur += work;
3986
3987 hc_thread_mutex_unlock (mux_dispatcher);
3988
3989 return work;
3990 }
3991
3992 static void *thread_calc_stdin (void *p)
3993 {
3994 hc_device_param_t *device_param = (hc_device_param_t *) p;
3995
3996 if (device_param->skipped) return NULL;
3997
3998 const uint attack_kern = data.attack_kern;
3999
4000 const uint kernel_blocks = device_param->kernel_blocks;
4001
4002 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4003 {
4004 hc_thread_mutex_lock (mux_dispatcher);
4005
4006 if (feof (stdin) != 0)
4007 {
4008 hc_thread_mutex_unlock (mux_dispatcher);
4009
4010 break;
4011 }
4012
4013 uint words_cur = 0;
4014
4015 while (words_cur < kernel_blocks)
4016 {
4017 char buf[BUFSIZ] = { 0 };
4018
4019 char *line_buf = fgets (buf, sizeof (buf), stdin);
4020
4021 if (line_buf == NULL) break;
4022
4023 uint line_len = in_superchop (line_buf);
4024
4025 line_len = convert_from_hex (line_buf, line_len);
4026
4027 // post-process rule engine
4028
4029 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4030 {
4031 char rule_buf_out[BLOCK_SIZE] = { 0 };
4032
4033 int rule_len_out = -1;
4034
4035 if (line_len < BLOCK_SIZE)
4036 {
4037 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4038 }
4039
4040 if (rule_len_out < 0) continue;
4041
4042 line_buf = rule_buf_out;
4043 line_len = rule_len_out;
4044 }
4045
4046 if (line_len > PW_MAX)
4047 {
4048 continue;
4049 }
4050
4051 if (attack_kern == ATTACK_KERN_STRAIGHT)
4052 {
4053 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4054 {
4055 hc_thread_mutex_lock (mux_counter);
4056
4057 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4058 {
4059 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4060 }
4061
4062 hc_thread_mutex_unlock (mux_counter);
4063
4064 continue;
4065 }
4066 }
4067 else if (attack_kern == ATTACK_KERN_COMBI)
4068 {
4069 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4070 // since we still need to combine the plains
4071
4072 if (line_len > data.pw_max)
4073 {
4074 hc_thread_mutex_lock (mux_counter);
4075
4076 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4077 {
4078 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4079 }
4080
4081 hc_thread_mutex_unlock (mux_counter);
4082
4083 continue;
4084 }
4085 }
4086
4087 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4088
4089 words_cur++;
4090
4091 if (data.devices_status == STATUS_CRACKED) break;
4092 if (data.devices_status == STATUS_ABORTED) break;
4093 if (data.devices_status == STATUS_QUIT) break;
4094 if (data.devices_status == STATUS_BYPASS) break;
4095 }
4096
4097 hc_thread_mutex_unlock (mux_dispatcher);
4098
4099 if (data.devices_status == STATUS_CRACKED) break;
4100 if (data.devices_status == STATUS_ABORTED) break;
4101 if (data.devices_status == STATUS_QUIT) break;
4102 if (data.devices_status == STATUS_BYPASS) break;
4103
4104 // we need 2 flushing because we have two independant caches and it can occur
4105 // that one buffer is already at threshold plus for that length also exists
4106 // more data in the 2nd buffer so it would overflow
4107
4108 // flush session 1
4109
4110 {
4111 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4112 {
4113 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4114
4115 const uint pw_cache_cnt = pw_cache->cnt;
4116
4117 if (pw_cache_cnt == 0) continue;
4118
4119 pw_cache->cnt = 0;
4120
4121 uint pws_cnt = device_param->pws_cnt;
4122
4123 pw_t *pw = device_param->pws_buf + pws_cnt;
4124
4125 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4126
4127 pw->pw_len = pw_len;
4128
4129 uint pw_cnt = device_param->pw_cnt;
4130
4131 pw_cnt += pw_cache_cnt;
4132
4133 device_param->pw_cnt = pw_cnt;
4134
4135 pws_cnt++;
4136
4137 device_param->pws_cnt = pws_cnt;
4138
4139 if (pws_cnt == device_param->kernel_power_user) break;
4140 }
4141
4142 const uint pw_cnt = device_param->pw_cnt;
4143 const uint pws_cnt = device_param->pws_cnt;
4144
4145 if (pws_cnt)
4146 {
4147 run_copy (device_param, pws_cnt);
4148
4149 run_cracker (device_param, pw_cnt, pws_cnt);
4150
4151 device_param->pw_cnt = 0;
4152 device_param->pws_cnt = 0;
4153 }
4154 }
4155
4156 // flush session 2
4157
4158 {
4159 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4160 {
4161 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4162
4163 const uint pw_cache_cnt = pw_cache->cnt;
4164
4165 if (pw_cache_cnt == 0) continue;
4166
4167 pw_cache->cnt = 0;
4168
4169 uint pws_cnt = device_param->pws_cnt;
4170
4171 pw_t *pw = device_param->pws_buf + pws_cnt;
4172
4173 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4174
4175 pw->pw_len = pw_len;
4176
4177 uint pw_cnt = device_param->pw_cnt;
4178
4179 pw_cnt += pw_cache_cnt;
4180
4181 device_param->pw_cnt = pw_cnt;
4182
4183 pws_cnt++;
4184
4185 device_param->pws_cnt = pws_cnt;
4186 }
4187
4188 const uint pw_cnt = device_param->pw_cnt;
4189 const uint pws_cnt = device_param->pws_cnt;
4190
4191 if (pws_cnt)
4192 {
4193 run_copy (device_param, pws_cnt);
4194
4195 run_cracker (device_param, pw_cnt, pws_cnt);
4196
4197 device_param->pw_cnt = 0;
4198 device_param->pws_cnt = 0;
4199 }
4200 }
4201 }
4202
4203 return NULL;
4204 }
4205
4206 static void *thread_calc (void *p)
4207 {
4208 hc_device_param_t *device_param = (hc_device_param_t *) p;
4209
4210 if (device_param->skipped) return NULL;
4211
4212 const uint attack_mode = data.attack_mode;
4213 const uint attack_kern = data.attack_kern;
4214
4215 if (attack_mode == ATTACK_MODE_BF)
4216 {
4217 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4218 {
4219 const uint work = get_work (device_param, -1);
4220
4221 if (work == 0) break;
4222
4223 const u64 words_off = device_param->words_off;
4224 const u64 words_fin = words_off + work;
4225
4226 const uint pw_cnt = work;
4227 const uint pws_cnt = work;
4228
4229 device_param->pw_cnt = pw_cnt;
4230 device_param->pws_cnt = pws_cnt;
4231
4232 if (pws_cnt)
4233 {
4234 run_copy (device_param, pws_cnt);
4235
4236 run_cracker (device_param, pw_cnt, pws_cnt);
4237
4238 device_param->pw_cnt = 0;
4239 device_param->pws_cnt = 0;
4240 }
4241
4242 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4243
4244 if (data.devices_status == STATUS_CRACKED) break;
4245 if (data.devices_status == STATUS_ABORTED) break;
4246 if (data.devices_status == STATUS_QUIT) break;
4247 if (data.devices_status == STATUS_BYPASS) break;
4248
4249 device_param->words_done = words_fin;
4250 }
4251 }
4252 else
4253 {
4254 const uint segment_size = data.segment_size;
4255
4256 char *dictfile = data.dictfile;
4257
4258 if (attack_mode == ATTACK_MODE_COMBI)
4259 {
4260 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4261 {
4262 dictfile = data.dictfile2;
4263 }
4264 }
4265
4266 FILE *fd = fopen (dictfile, "rb");
4267
4268 if (fd == NULL)
4269 {
4270 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4271
4272 return NULL;
4273 }
4274
4275 if (attack_mode == ATTACK_MODE_COMBI)
4276 {
4277 const uint combs_mode = data.combs_mode;
4278
4279 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4280 {
4281 const char *dictfilec = data.dictfile2;
4282
4283 FILE *combs_fp = fopen (dictfilec, "rb");
4284
4285 if (combs_fp == NULL)
4286 {
4287 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4288
4289 fclose (fd);
4290
4291 return NULL;
4292 }
4293
4294 device_param->combs_fp = combs_fp;
4295 }
4296 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4297 {
4298 const char *dictfilec = data.dictfile;
4299
4300 FILE *combs_fp = fopen (dictfilec, "rb");
4301
4302 if (combs_fp == NULL)
4303 {
4304 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4305
4306 fclose (fd);
4307
4308 return NULL;
4309 }
4310
4311 device_param->combs_fp = combs_fp;
4312 }
4313 }
4314
4315 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4316
4317 wl_data->buf = (char *) mymalloc (segment_size);
4318 wl_data->avail = segment_size;
4319 wl_data->incr = segment_size;
4320 wl_data->cnt = 0;
4321 wl_data->pos = 0;
4322
4323 u64 words_cur = 0;
4324
4325 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4326 {
4327 u64 words_off = 0;
4328 u64 words_fin = 0;
4329
4330 u64 max = -1;
4331
4332 while (max)
4333 {
4334 const uint work = get_work (device_param, max);
4335
4336 if (work == 0) break;
4337
4338 words_off = device_param->words_off;
4339 words_fin = words_off + work;
4340
4341 char *line_buf;
4342 uint line_len;
4343
4344 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4345
4346 max = 0;
4347
4348 for ( ; words_cur < words_fin; words_cur++)
4349 {
4350 get_next_word (wl_data, fd, &line_buf, &line_len);
4351
4352 line_len = convert_from_hex (line_buf, line_len);
4353
4354 // post-process rule engine
4355
4356 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4357 {
4358 char rule_buf_out[BLOCK_SIZE] = { 0 };
4359
4360 int rule_len_out = -1;
4361
4362 if (line_len < BLOCK_SIZE)
4363 {
4364 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4365 }
4366
4367 if (rule_len_out < 0) continue;
4368
4369 line_buf = rule_buf_out;
4370 line_len = rule_len_out;
4371 }
4372
4373 if (attack_kern == ATTACK_KERN_STRAIGHT)
4374 {
4375 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4376 {
4377 max++;
4378
4379 hc_thread_mutex_lock (mux_counter);
4380
4381 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4382 {
4383 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4384 }
4385
4386 hc_thread_mutex_unlock (mux_counter);
4387
4388 continue;
4389 }
4390 }
4391 else if (attack_kern == ATTACK_KERN_COMBI)
4392 {
4393 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4394 // since we still need to combine the plains
4395
4396 if (line_len > data.pw_max)
4397 {
4398 max++;
4399
4400 hc_thread_mutex_lock (mux_counter);
4401
4402 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4403 {
4404 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4405 }
4406
4407 hc_thread_mutex_unlock (mux_counter);
4408
4409 continue;
4410 }
4411 }
4412
4413 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4414
4415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4416
4417 if (data.devices_status == STATUS_CRACKED) break;
4418 if (data.devices_status == STATUS_ABORTED) break;
4419 if (data.devices_status == STATUS_QUIT) break;
4420 if (data.devices_status == STATUS_BYPASS) break;
4421 }
4422
4423 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4424
4425 if (data.devices_status == STATUS_CRACKED) break;
4426 if (data.devices_status == STATUS_ABORTED) break;
4427 if (data.devices_status == STATUS_QUIT) break;
4428 if (data.devices_status == STATUS_BYPASS) break;
4429 }
4430
4431 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4432
4433 if (data.devices_status == STATUS_CRACKED) break;
4434 if (data.devices_status == STATUS_ABORTED) break;
4435 if (data.devices_status == STATUS_QUIT) break;
4436 if (data.devices_status == STATUS_BYPASS) break;
4437
4438 // we need 2 flushing because we have two independant caches and it can occur
4439 // that one buffer is already at threshold plus for that length also exists
4440 // more data in the 2nd buffer so it would overflow
4441
4442 //
4443 // flush session 1
4444 //
4445
4446 {
4447 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4448 {
4449 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4450
4451 const uint pw_cache_cnt = pw_cache->cnt;
4452
4453 if (pw_cache_cnt == 0) continue;
4454
4455 pw_cache->cnt = 0;
4456
4457 uint pws_cnt = device_param->pws_cnt;
4458
4459 pw_t *pw = device_param->pws_buf + pws_cnt;
4460
4461 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4462
4463 pw->pw_len = pw_len;
4464
4465 uint pw_cnt = device_param->pw_cnt;
4466
4467 pw_cnt += pw_cache_cnt;
4468
4469 device_param->pw_cnt = pw_cnt;
4470
4471 pws_cnt++;
4472
4473 device_param->pws_cnt = pws_cnt;
4474
4475 if (pws_cnt == device_param->kernel_power_user) break;
4476 }
4477
4478 const uint pw_cnt = device_param->pw_cnt;
4479 const uint pws_cnt = device_param->pws_cnt;
4480
4481 if (pws_cnt)
4482 {
4483 run_copy (device_param, pws_cnt);
4484
4485 run_cracker (device_param, pw_cnt, pws_cnt);
4486
4487 device_param->pw_cnt = 0;
4488 device_param->pws_cnt = 0;
4489 }
4490
4491 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4492
4493 if (data.devices_status == STATUS_CRACKED) break;
4494 if (data.devices_status == STATUS_ABORTED) break;
4495 if (data.devices_status == STATUS_QUIT) break;
4496 if (data.devices_status == STATUS_BYPASS) break;
4497 }
4498
4499 //
4500 // flush session 2
4501 //
4502
4503 {
4504 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4505 {
4506 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4507
4508 const uint pw_cache_cnt = pw_cache->cnt;
4509
4510 if (pw_cache_cnt == 0) continue;
4511
4512 pw_cache->cnt = 0;
4513
4514 uint pws_cnt = device_param->pws_cnt;
4515
4516 pw_t *pw = device_param->pws_buf + pws_cnt;
4517
4518 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4519
4520 pw->pw_len = pw_len;
4521
4522 uint pw_cnt = device_param->pw_cnt;
4523
4524 pw_cnt += pw_cache_cnt;
4525
4526 device_param->pw_cnt = pw_cnt;
4527
4528 pws_cnt++;
4529
4530 device_param->pws_cnt = pws_cnt;
4531 }
4532
4533 const uint pw_cnt = device_param->pw_cnt;
4534 const uint pws_cnt = device_param->pws_cnt;
4535
4536 if (pws_cnt)
4537 {
4538 run_copy (device_param, pws_cnt);
4539
4540 run_cracker (device_param, pw_cnt, pws_cnt);
4541
4542 device_param->pw_cnt = 0;
4543 device_param->pws_cnt = 0;
4544 }
4545
4546 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4547
4548 if (data.devices_status == STATUS_CRACKED) break;
4549 if (data.devices_status == STATUS_ABORTED) break;
4550 if (data.devices_status == STATUS_QUIT) break;
4551 if (data.devices_status == STATUS_BYPASS) break;
4552 }
4553
4554 if (words_fin == 0) break;
4555
4556 device_param->words_done = words_fin;
4557 }
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 fclose (device_param->combs_fp);
4562 }
4563
4564 free (wl_data->buf);
4565 free (wl_data);
4566
4567 fclose (fd);
4568 }
4569
4570 return NULL;
4571 }
4572
4573 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4574 {
4575 salt_t *salt_buf = &data.salts_buf[salt_pos];
4576
4577 device_param->kernel_params_buf32[24] = salt_pos;
4578 device_param->kernel_params_buf32[27] = 1;
4579 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4580 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4581 device_param->kernel_params_buf32[30] = 0;
4582 device_param->kernel_params_buf32[31] = 1;
4583
4584 char *dictfile_old = data.dictfile;
4585
4586 const char *weak_hash_check = "weak-hash-check";
4587
4588 data.dictfile = (char *) weak_hash_check;
4589
4590 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4591
4592 data.kernel_rules_buf[0].cmds[0] = 0;
4593
4594 /**
4595 * run the kernel
4596 */
4597
4598 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4599 {
4600 run_kernel (KERN_RUN_1, device_param, 1);
4601 }
4602 else
4603 {
4604 run_kernel (KERN_RUN_1, device_param, 1);
4605
4606 const uint iter = salt_buf->salt_iter;
4607
4608 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4609 {
4610 uint loop_left = iter - loop_pos;
4611
4612 loop_left = MIN (loop_left, kernel_loops);
4613
4614 device_param->kernel_params_buf32[25] = loop_pos;
4615 device_param->kernel_params_buf32[26] = loop_left;
4616
4617 run_kernel (KERN_RUN_2, device_param, 1);
4618 }
4619
4620 run_kernel (KERN_RUN_3, device_param, 1);
4621 }
4622
4623 /**
4624 * result
4625 */
4626
4627 check_cracked (device_param, salt_pos);
4628
4629 /**
4630 * cleanup
4631 */
4632
4633 device_param->kernel_params_buf32[24] = 0;
4634 device_param->kernel_params_buf32[25] = 0;
4635 device_param->kernel_params_buf32[26] = 0;
4636 device_param->kernel_params_buf32[27] = 0;
4637 device_param->kernel_params_buf32[28] = 0;
4638 device_param->kernel_params_buf32[29] = 0;
4639 device_param->kernel_params_buf32[30] = 0;
4640 device_param->kernel_params_buf32[31] = 0;
4641
4642 data.dictfile = dictfile_old;
4643
4644 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4645 }
4646
4647 // hlfmt hashcat
4648
4649 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4650 {
4651 if (data.username == 0)
4652 {
4653 *hashbuf_pos = line_buf;
4654 *hashbuf_len = line_len;
4655 }
4656 else
4657 {
4658 char *pos = line_buf;
4659 int len = line_len;
4660
4661 for (int i = 0; i < line_len; i++, pos++, len--)
4662 {
4663 if (line_buf[i] == data.separator)
4664 {
4665 pos++;
4666
4667 len--;
4668
4669 break;
4670 }
4671 }
4672
4673 *hashbuf_pos = pos;
4674 *hashbuf_len = len;
4675 }
4676 }
4677
4678 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4679 {
4680 char *pos = NULL;
4681 int len = 0;
4682
4683 int sep_cnt = 0;
4684
4685 for (int i = 0; i < line_len; i++)
4686 {
4687 if (line_buf[i] == data.separator)
4688 {
4689 sep_cnt++;
4690
4691 continue;
4692 }
4693
4694 if (sep_cnt == 0)
4695 {
4696 if (pos == NULL) pos = line_buf + i;
4697
4698 len++;
4699 }
4700 }
4701
4702 *userbuf_pos = pos;
4703 *userbuf_len = len;
4704 }
4705
4706 // hlfmt pwdump
4707
4708 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4709 {
4710 int sep_cnt = 0;
4711
4712 int sep2_len = 0;
4713 int sep3_len = 0;
4714
4715 for (int i = 0; i < line_len; i++)
4716 {
4717 if (line_buf[i] == ':')
4718 {
4719 sep_cnt++;
4720
4721 continue;
4722 }
4723
4724 if (sep_cnt == 2) sep2_len++;
4725 if (sep_cnt == 3) sep3_len++;
4726 }
4727
4728 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4729
4730 return 0;
4731 }
4732
4733 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4734 {
4735 char *pos = NULL;
4736 int len = 0;
4737
4738 int sep_cnt = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (data.hash_mode == 1000)
4750 {
4751 if (sep_cnt == 3)
4752 {
4753 if (pos == NULL) pos = line_buf + i;
4754
4755 len++;
4756 }
4757 }
4758 else if (data.hash_mode == 3000)
4759 {
4760 if (sep_cnt == 2)
4761 {
4762 if (pos == NULL) pos = line_buf + i;
4763
4764 len++;
4765 }
4766 }
4767 }
4768
4769 *hashbuf_pos = pos;
4770 *hashbuf_len = len;
4771 }
4772
4773 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4774 {
4775 char *pos = NULL;
4776 int len = 0;
4777
4778 int sep_cnt = 0;
4779
4780 for (int i = 0; i < line_len; i++)
4781 {
4782 if (line_buf[i] == ':')
4783 {
4784 sep_cnt++;
4785
4786 continue;
4787 }
4788
4789 if (sep_cnt == 0)
4790 {
4791 if (pos == NULL) pos = line_buf + i;
4792
4793 len++;
4794 }
4795 }
4796
4797 *userbuf_pos = pos;
4798 *userbuf_len = len;
4799 }
4800
4801 // hlfmt passwd
4802
4803 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4804 {
4805 int sep_cnt = 0;
4806
4807 char sep5_first = 0;
4808 char sep6_first = 0;
4809
4810 for (int i = 0; i < line_len; i++)
4811 {
4812 if (line_buf[i] == ':')
4813 {
4814 sep_cnt++;
4815
4816 continue;
4817 }
4818
4819 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4820 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4821 }
4822
4823 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4824
4825 return 0;
4826 }
4827
4828 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4829 {
4830 char *pos = NULL;
4831 int len = 0;
4832
4833 int sep_cnt = 0;
4834
4835 for (int i = 0; i < line_len; i++)
4836 {
4837 if (line_buf[i] == ':')
4838 {
4839 sep_cnt++;
4840
4841 continue;
4842 }
4843
4844 if (sep_cnt == 1)
4845 {
4846 if (pos == NULL) pos = line_buf + i;
4847
4848 len++;
4849 }
4850 }
4851
4852 *hashbuf_pos = pos;
4853 *hashbuf_len = len;
4854 }
4855
4856 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4857 {
4858 char *pos = NULL;
4859 int len = 0;
4860
4861 int sep_cnt = 0;
4862
4863 for (int i = 0; i < line_len; i++)
4864 {
4865 if (line_buf[i] == ':')
4866 {
4867 sep_cnt++;
4868
4869 continue;
4870 }
4871
4872 if (sep_cnt == 0)
4873 {
4874 if (pos == NULL) pos = line_buf + i;
4875
4876 len++;
4877 }
4878 }
4879
4880 *userbuf_pos = pos;
4881 *userbuf_len = len;
4882 }
4883
4884 // hlfmt shadow
4885
4886 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4887 {
4888 int sep_cnt = 0;
4889
4890 for (int i = 0; i < line_len; i++)
4891 {
4892 if (line_buf[i] == ':') sep_cnt++;
4893 }
4894
4895 if (sep_cnt == 8) return 1;
4896
4897 return 0;
4898 }
4899
4900 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4901 {
4902 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4903 }
4904
4905 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4906 {
4907 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4908 }
4909
4910 // hlfmt main
4911
4912 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4913 {
4914 switch (hashfile_format)
4915 {
4916 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4917 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4918 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4919 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4920 }
4921 }
4922
4923 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4924 {
4925 switch (hashfile_format)
4926 {
4927 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4928 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4929 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4930 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4931 }
4932 }
4933
4934 static uint hlfmt_detect (FILE *fp, uint max_check)
4935 {
4936 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4937
4938 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4939 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4940
4941 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4942
4943 uint num_check = 0;
4944
4945 while (!feof (fp))
4946 {
4947 char line_buf[BUFSIZ] = { 0 };
4948
4949 int line_len = fgetl (fp, line_buf);
4950
4951 if (line_len == 0) continue;
4952
4953 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4954 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4955 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4956
4957 if (num_check == max_check) break;
4958
4959 num_check++;
4960 }
4961
4962 uint hashlist_format = HLFMT_HASHCAT;
4963
4964 for (int i = 1; i < HLFMTS_CNT; i++)
4965 {
4966 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4967
4968 hashlist_format = i;
4969 }
4970
4971 free (formats_cnt);
4972
4973 return hashlist_format;
4974 }
4975
4976 /**
4977 * some further helper function
4978 */
4979
4980 // wrapper around mymalloc for ADL
4981
4982 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
4983 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4984 {
4985 return mymalloc (iSize);
4986 }
4987 #endif
4988
4989 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)
4990 {
4991 u64 collisions = 0;
4992
4993 const uint dgst_pos0 = data.dgst_pos0;
4994 const uint dgst_pos1 = data.dgst_pos1;
4995 const uint dgst_pos2 = data.dgst_pos2;
4996 const uint dgst_pos3 = data.dgst_pos3;
4997
4998 memset (bitmap_a, 0, bitmap_size);
4999 memset (bitmap_b, 0, bitmap_size);
5000 memset (bitmap_c, 0, bitmap_size);
5001 memset (bitmap_d, 0, bitmap_size);
5002
5003 for (uint i = 0; i < digests_cnt; i++)
5004 {
5005 uint *digest_ptr = (uint *) digests_buf_ptr;
5006
5007 digests_buf_ptr += dgst_size;
5008
5009 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5010 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5011 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5012 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5013
5014 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5015 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5016 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5017 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5018
5019 if (bitmap_a[idx0] & val0) collisions++;
5020 if (bitmap_b[idx1] & val1) collisions++;
5021 if (bitmap_c[idx2] & val2) collisions++;
5022 if (bitmap_d[idx3] & val3) collisions++;
5023
5024 bitmap_a[idx0] |= val0;
5025 bitmap_b[idx1] |= val1;
5026 bitmap_c[idx2] |= val2;
5027 bitmap_d[idx3] |= val3;
5028
5029 if (collisions >= collisions_max) return 0x7fffffff;
5030 }
5031
5032 return collisions;
5033 }
5034
5035 /**
5036 * main
5037 */
5038
5039 int main (int argc, char **argv)
5040 {
5041 /**
5042 * To help users a bit
5043 */
5044
5045 char *compute = getenv ("COMPUTE");
5046
5047 if (compute)
5048 {
5049 char display[100] = { 0 };
5050
5051 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5052
5053 putenv (display);
5054 }
5055 else
5056 {
5057 if (getenv ("DISPLAY") == NULL)
5058 putenv ((char *) "DISPLAY=:0");
5059 }
5060
5061 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5062 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5063
5064 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5065 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5066
5067 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5068 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5069
5070 /**
5071 * Real init
5072 */
5073
5074 memset (&data, 0, sizeof (hc_global_data_t));
5075
5076 time_t proc_start;
5077
5078 time (&proc_start);
5079
5080 data.proc_start = proc_start;
5081
5082 int myargc = argc;
5083 char **myargv = argv;
5084
5085 hc_thread_mutex_init (mux_dispatcher);
5086 hc_thread_mutex_init (mux_counter);
5087 hc_thread_mutex_init (mux_display);
5088 hc_thread_mutex_init (mux_adl);
5089
5090 /**
5091 * commandline parameters
5092 */
5093
5094 uint usage = USAGE;
5095 uint version = VERSION;
5096 uint quiet = QUIET;
5097 uint benchmark = BENCHMARK;
5098 uint benchmark_mode = BENCHMARK_MODE;
5099 uint show = SHOW;
5100 uint left = LEFT;
5101 uint username = USERNAME;
5102 uint remove = REMOVE;
5103 uint remove_timer = REMOVE_TIMER;
5104 u64 skip = SKIP;
5105 u64 limit = LIMIT;
5106 uint keyspace = KEYSPACE;
5107 uint potfile_disable = POTFILE_DISABLE;
5108 uint debug_mode = DEBUG_MODE;
5109 char *debug_file = NULL;
5110 char *induction_dir = NULL;
5111 char *outfile_check_dir = NULL;
5112 uint force = FORCE;
5113 uint runtime = RUNTIME;
5114 uint hash_mode = HASH_MODE;
5115 uint attack_mode = ATTACK_MODE;
5116 uint markov_disable = MARKOV_DISABLE;
5117 uint markov_classic = MARKOV_CLASSIC;
5118 uint markov_threshold = MARKOV_THRESHOLD;
5119 char *markov_hcstat = NULL;
5120 char *outfile = NULL;
5121 uint outfile_format = OUTFILE_FORMAT;
5122 uint outfile_autohex = OUTFILE_AUTOHEX;
5123 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5124 uint restore = RESTORE;
5125 uint restore_timer = RESTORE_TIMER;
5126 uint restore_disable = RESTORE_DISABLE;
5127 uint status = STATUS;
5128 uint status_timer = STATUS_TIMER;
5129 uint status_automat = STATUS_AUTOMAT;
5130 uint loopback = LOOPBACK;
5131 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5132 char *session = NULL;
5133 uint hex_charset = HEX_CHARSET;
5134 uint hex_salt = HEX_SALT;
5135 uint hex_wordlist = HEX_WORDLIST;
5136 uint rp_gen = RP_GEN;
5137 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5138 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5139 uint rp_gen_seed = RP_GEN_SEED;
5140 char *rule_buf_l = (char *) RULE_BUF_L;
5141 char *rule_buf_r = (char *) RULE_BUF_R;
5142 uint increment = INCREMENT;
5143 uint increment_min = INCREMENT_MIN;
5144 uint increment_max = INCREMENT_MAX;
5145 #ifndef OSX
5146 char *cpu_affinity = NULL;
5147 #endif
5148 char *opencl_devices = NULL;
5149 char *opencl_platforms = NULL;
5150 char *opencl_device_types = NULL;
5151 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5152 char *truecrypt_keyfiles = NULL;
5153 uint workload_profile = WORKLOAD_PROFILE;
5154 uint kernel_accel = KERNEL_ACCEL;
5155 uint kernel_loops = KERNEL_LOOPS;
5156 #ifdef HAVE_HWMON
5157 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5158 uint gpu_temp_abort = GPU_TEMP_ABORT;
5159 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5160 #ifdef HAVE_ADL
5161 uint powertune_enable = POWERTUNE_ENABLE;
5162 #endif
5163 #endif
5164 uint logfile_disable = LOGFILE_DISABLE;
5165 uint segment_size = SEGMENT_SIZE;
5166 uint scrypt_tmto = SCRYPT_TMTO;
5167 char separator = SEPARATOR;
5168 uint bitmap_min = BITMAP_MIN;
5169 uint bitmap_max = BITMAP_MAX;
5170 char *custom_charset_1 = NULL;
5171 char *custom_charset_2 = NULL;
5172 char *custom_charset_3 = NULL;
5173 char *custom_charset_4 = NULL;
5174
5175 #define IDX_HELP 'h'
5176 #define IDX_VERSION 'V'
5177 #define IDX_VERSION_LOWER 'v'
5178 #define IDX_QUIET 0xff02
5179 #define IDX_SHOW 0xff03
5180 #define IDX_LEFT 0xff04
5181 #define IDX_REMOVE 0xff05
5182 #define IDX_REMOVE_TIMER 0xff37
5183 #define IDX_SKIP 's'
5184 #define IDX_LIMIT 'l'
5185 #define IDX_KEYSPACE 0xff35
5186 #define IDX_POTFILE_DISABLE 0xff06
5187 #define IDX_DEBUG_MODE 0xff43
5188 #define IDX_DEBUG_FILE 0xff44
5189 #define IDX_INDUCTION_DIR 0xff46
5190 #define IDX_OUTFILE_CHECK_DIR 0xff47
5191 #define IDX_USERNAME 0xff07
5192 #define IDX_FORCE 0xff08
5193 #define IDX_RUNTIME 0xff09
5194 #define IDX_BENCHMARK 'b'
5195 #define IDX_BENCHMARK_MODE 0xff32
5196 #define IDX_HASH_MODE 'm'
5197 #define IDX_ATTACK_MODE 'a'
5198 #define IDX_RP_FILE 'r'
5199 #define IDX_RP_GEN 'g'
5200 #define IDX_RP_GEN_FUNC_MIN 0xff10
5201 #define IDX_RP_GEN_FUNC_MAX 0xff11
5202 #define IDX_RP_GEN_SEED 0xff34
5203 #define IDX_RULE_BUF_L 'j'
5204 #define IDX_RULE_BUF_R 'k'
5205 #define IDX_INCREMENT 'i'
5206 #define IDX_INCREMENT_MIN 0xff12
5207 #define IDX_INCREMENT_MAX 0xff13
5208 #define IDX_OUTFILE 'o'
5209 #define IDX_OUTFILE_FORMAT 0xff14
5210 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5211 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5212 #define IDX_RESTORE 0xff15
5213 #define IDX_RESTORE_DISABLE 0xff27
5214 #define IDX_STATUS 0xff17
5215 #define IDX_STATUS_TIMER 0xff18
5216 #define IDX_STATUS_AUTOMAT 0xff50
5217 #define IDX_LOOPBACK 0xff38
5218 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5219 #define IDX_SESSION 0xff19
5220 #define IDX_HEX_CHARSET 0xff20
5221 #define IDX_HEX_SALT 0xff21
5222 #define IDX_HEX_WORDLIST 0xff40
5223 #define IDX_MARKOV_DISABLE 0xff22
5224 #define IDX_MARKOV_CLASSIC 0xff23
5225 #define IDX_MARKOV_THRESHOLD 't'
5226 #define IDX_MARKOV_HCSTAT 0xff24
5227 #define IDX_CPU_AFFINITY 0xff25
5228 #define IDX_OPENCL_DEVICES 'd'
5229 #define IDX_OPENCL_PLATFORMS 0xff72
5230 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5231 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5232 #define IDX_WORKLOAD_PROFILE 'w'
5233 #define IDX_KERNEL_ACCEL 'n'
5234 #define IDX_KERNEL_LOOPS 'u'
5235 #define IDX_GPU_TEMP_DISABLE 0xff29
5236 #define IDX_GPU_TEMP_ABORT 0xff30
5237 #define IDX_GPU_TEMP_RETAIN 0xff31
5238 #define IDX_POWERTUNE_ENABLE 0xff41
5239 #define IDX_LOGFILE_DISABLE 0xff51
5240 #define IDX_TRUECRYPT_KEYFILES 0xff52
5241 #define IDX_SCRYPT_TMTO 0xff61
5242 #define IDX_SEGMENT_SIZE 'c'
5243 #define IDX_SEPARATOR 'p'
5244 #define IDX_BITMAP_MIN 0xff70
5245 #define IDX_BITMAP_MAX 0xff71
5246 #define IDX_CUSTOM_CHARSET_1 '1'
5247 #define IDX_CUSTOM_CHARSET_2 '2'
5248 #define IDX_CUSTOM_CHARSET_3 '3'
5249 #define IDX_CUSTOM_CHARSET_4 '4'
5250
5251 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5252
5253 struct option long_options[] =
5254 {
5255 {"help", no_argument, 0, IDX_HELP},
5256 {"version", no_argument, 0, IDX_VERSION},
5257 {"quiet", no_argument, 0, IDX_QUIET},
5258 {"show", no_argument, 0, IDX_SHOW},
5259 {"left", no_argument, 0, IDX_LEFT},
5260 {"username", no_argument, 0, IDX_USERNAME},
5261 {"remove", no_argument, 0, IDX_REMOVE},
5262 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5263 {"skip", required_argument, 0, IDX_SKIP},
5264 {"limit", required_argument, 0, IDX_LIMIT},
5265 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5266 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5267 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5268 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5269 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5270 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5271 {"force", no_argument, 0, IDX_FORCE},
5272 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5273 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5274 {"restore", no_argument, 0, IDX_RESTORE},
5275 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5276 {"status", no_argument, 0, IDX_STATUS},
5277 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5278 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5279 {"loopback", no_argument, 0, IDX_LOOPBACK},
5280 {"weak-hash-threshold",
5281 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5282 {"session", required_argument, 0, IDX_SESSION},
5283 {"runtime", required_argument, 0, IDX_RUNTIME},
5284 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5285 {"generate-rules-func-min",
5286 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5287 {"generate-rules-func-max",
5288 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5289 {"generate-rules-seed",
5290 required_argument, 0, IDX_RP_GEN_SEED},
5291 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5292 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5293 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5294 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5295 {"rules-file", required_argument, 0, IDX_RP_FILE},
5296 {"outfile", required_argument, 0, IDX_OUTFILE},
5297 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5298 {"outfile-autohex-disable",
5299 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5300 {"outfile-check-timer",
5301 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5302 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5303 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5304 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5305 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5306 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5307 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5308 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5309 #ifndef OSX
5310 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5311 #endif
5312 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5313 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5314 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5315 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5316 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5317 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5318 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5319 #ifdef HAVE_HWMON
5320 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5321 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5322 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5323 #ifdef HAVE_ADL
5324 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5325 #endif
5326 #endif // HAVE_HWMON
5327 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5328 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5329 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5330 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5331 // deprecated
5332 {"seperator", required_argument, 0, IDX_SEPARATOR},
5333 {"separator", required_argument, 0, IDX_SEPARATOR},
5334 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5335 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5336 {"increment", no_argument, 0, IDX_INCREMENT},
5337 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5338 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5339 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5340 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5341 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5342 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5343
5344 {0, 0, 0, 0}
5345 };
5346
5347 uint rp_files_cnt = 0;
5348
5349 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5350
5351 int option_index = 0;
5352 int c = -1;
5353
5354 optind = 1;
5355 optopt = 0;
5356
5357 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5358 {
5359 switch (c)
5360 {
5361 case IDX_HELP: usage = 1; break;
5362 case IDX_VERSION:
5363 case IDX_VERSION_LOWER: version = 1; break;
5364 case IDX_RESTORE: restore = 1; break;
5365 case IDX_SESSION: session = optarg; break;
5366 case IDX_SHOW: show = 1; break;
5367 case IDX_LEFT: left = 1; break;
5368 case '?': return (-1);
5369 }
5370 }
5371
5372 if (optopt != 0)
5373 {
5374 log_error ("ERROR: Invalid argument specified");
5375
5376 return (-1);
5377 }
5378
5379 /**
5380 * exit functions
5381 */
5382
5383 if (version)
5384 {
5385 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5386
5387 return (0);
5388 }
5389
5390 if (usage)
5391 {
5392 usage_big_print (PROGNAME);
5393
5394 return (0);
5395 }
5396
5397 /**
5398 * session needs to be set, always!
5399 */
5400
5401 if (session == NULL) session = (char *) PROGNAME;
5402
5403 /**
5404 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5405 */
5406
5407 char *exec_path = get_exec_path ();
5408
5409 #ifdef LINUX
5410
5411 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5412 char *resolved_exec_path = realpath (exec_path, NULL);
5413
5414 char *install_dir = get_install_dir (resolved_exec_path);
5415 char *profile_dir = NULL;
5416 char *session_dir = NULL;
5417 char *shared_dir = NULL;
5418
5419 if (strcmp (install_dir, resolved_install_folder) == 0)
5420 {
5421 struct passwd *pw = getpwuid (getuid ());
5422
5423 const char *homedir = pw->pw_dir;
5424
5425 profile_dir = get_profile_dir (homedir);
5426 session_dir = get_session_dir (profile_dir);
5427 shared_dir = strdup (SHARED_FOLDER);
5428
5429 mkdir (profile_dir, 0700);
5430 mkdir (session_dir, 0700);
5431 }
5432 else
5433 {
5434 profile_dir = install_dir;
5435 session_dir = install_dir;
5436 shared_dir = install_dir;
5437 }
5438
5439 myfree (resolved_install_folder);
5440 myfree (resolved_exec_path);
5441
5442 #else
5443
5444 char *install_dir = get_install_dir (exec_path);
5445 char *profile_dir = install_dir;
5446 char *session_dir = install_dir;
5447 char *shared_dir = install_dir;
5448
5449 #endif
5450
5451 data.install_dir = install_dir;
5452 data.profile_dir = profile_dir;
5453 data.session_dir = session_dir;
5454 data.shared_dir = shared_dir;
5455
5456 myfree (exec_path);
5457
5458 /**
5459 * kernel cache, we need to make sure folder exist
5460 */
5461
5462 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5463
5464 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5465
5466 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5467
5468 mkdir (kernels_folder, 0700);
5469
5470 myfree (kernels_folder);
5471
5472 /**
5473 * session
5474 */
5475
5476 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5477
5478 data.session = session;
5479
5480 char *eff_restore_file = (char *) mymalloc (session_size);
5481 char *new_restore_file = (char *) mymalloc (session_size);
5482
5483 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5484 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5485
5486 data.eff_restore_file = eff_restore_file;
5487 data.new_restore_file = new_restore_file;
5488
5489 if (((show == 1) || (left == 1)) && (restore == 1))
5490 {
5491 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5492 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5493
5494 return (-1);
5495 }
5496
5497 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5498 if ((show == 1) || (left == 1))
5499 {
5500 restore_disable = 1;
5501
5502 restore = 0;
5503 }
5504
5505 data.restore_disable = restore_disable;
5506
5507 restore_data_t *rd = init_restore (argc, argv);
5508
5509 data.rd = rd;
5510
5511 /**
5512 * restore file
5513 */
5514
5515 if (restore == 1)
5516 {
5517 read_restore (eff_restore_file, rd);
5518
5519 if (rd->version_bin < RESTORE_MIN)
5520 {
5521 log_error ("ERROR: Incompatible restore-file version");
5522
5523 return (-1);
5524 }
5525
5526 myargc = rd->argc;
5527 myargv = rd->argv;
5528
5529 #ifdef _POSIX
5530 rd->pid = getpid ();
5531 #elif _WIN
5532 rd->pid = GetCurrentProcessId ();
5533 #endif
5534 }
5535
5536 uint hash_mode_chgd = 0;
5537 uint runtime_chgd = 0;
5538 uint kernel_loops_chgd = 0;
5539 uint kernel_accel_chgd = 0;
5540 uint attack_mode_chgd = 0;
5541 uint outfile_format_chgd = 0;
5542 uint rp_gen_seed_chgd = 0;
5543 uint remove_timer_chgd = 0;
5544 uint increment_min_chgd = 0;
5545 uint increment_max_chgd = 0;
5546 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5547 uint gpu_temp_retain_chgd = 0;
5548 uint gpu_temp_abort_chgd = 0;
5549 #endif
5550
5551 optind = 1;
5552 optopt = 0;
5553 option_index = 0;
5554
5555 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5556 {
5557 switch (c)
5558 {
5559 //case IDX_HELP: usage = 1; break;
5560 //case IDX_VERSION: version = 1; break;
5561 //case IDX_RESTORE: restore = 1; break;
5562 case IDX_QUIET: quiet = 1; break;
5563 //case IDX_SHOW: show = 1; break;
5564 case IDX_SHOW: break;
5565 //case IDX_LEFT: left = 1; break;
5566 case IDX_LEFT: break;
5567 case IDX_USERNAME: username = 1; break;
5568 case IDX_REMOVE: remove = 1; break;
5569 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5570 remove_timer_chgd = 1; break;
5571 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5572 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5573 case IDX_DEBUG_FILE: debug_file = optarg; break;
5574 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5575 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5576 case IDX_FORCE: force = 1; break;
5577 case IDX_SKIP: skip = atoll (optarg); break;
5578 case IDX_LIMIT: limit = atoll (optarg); break;
5579 case IDX_KEYSPACE: keyspace = 1; break;
5580 case IDX_BENCHMARK: benchmark = 1; break;
5581 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5582 case IDX_RESTORE: break;
5583 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5584 case IDX_STATUS: status = 1; break;
5585 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5586 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5587 case IDX_LOOPBACK: loopback = 1; break;
5588 case IDX_WEAK_HASH_THRESHOLD:
5589 weak_hash_threshold = atoi (optarg); break;
5590 //case IDX_SESSION: session = optarg; break;
5591 case IDX_SESSION: break;
5592 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5593 hash_mode_chgd = 1; break;
5594 case IDX_RUNTIME: runtime = atoi (optarg);
5595 runtime_chgd = 1; break;
5596 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5597 attack_mode_chgd = 1; break;
5598 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5599 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5600 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5601 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5602 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5603 rp_gen_seed_chgd = 1; break;
5604 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5605 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5606 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5607 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5608 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5609 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5610 case IDX_OUTFILE: outfile = optarg; break;
5611 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5612 outfile_format_chgd = 1; break;
5613 case IDX_OUTFILE_AUTOHEX_DISABLE:
5614 outfile_autohex = 0; break;
5615 case IDX_OUTFILE_CHECK_TIMER:
5616 outfile_check_timer = atoi (optarg); break;
5617 case IDX_HEX_CHARSET: hex_charset = 1; break;
5618 case IDX_HEX_SALT: hex_salt = 1; break;
5619 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5620 #ifndef OSX
5621 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5622 #endif
5623 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5624 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5625 case IDX_OPENCL_DEVICE_TYPES:
5626 opencl_device_types = optarg; break;
5627 case IDX_OPENCL_VECTOR_WIDTH:
5628 opencl_vector_width = atoi (optarg); break;
5629 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5630 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5631 kernel_accel_chgd = 1; break;
5632 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5633 kernel_loops_chgd = 1; break;
5634 #ifdef HAVE_HWMON
5635 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5636 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5637 #ifdef HAVE_ADL
5638 gpu_temp_abort_chgd = 1;
5639 #endif
5640 break;
5641 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5642 #ifdef HAVE_ADL
5643 gpu_temp_retain_chgd = 1;
5644 #endif
5645 break;
5646 #ifdef HAVE_ADL
5647 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5648 #endif
5649 #endif // HAVE_HWMON
5650 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5651 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5652 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5653 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5654 case IDX_SEPARATOR: separator = optarg[0]; break;
5655 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5656 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5657 case IDX_INCREMENT: increment = 1; break;
5658 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5659 increment_min_chgd = 1; break;
5660 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5661 increment_max_chgd = 1; break;
5662 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5663 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5664 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5665 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5666
5667 default:
5668 log_error ("ERROR: Invalid argument specified");
5669 return (-1);
5670 }
5671 }
5672
5673 if (optopt != 0)
5674 {
5675 log_error ("ERROR: Invalid argument specified");
5676
5677 return (-1);
5678 }
5679
5680 /**
5681 * Inform user things getting started,
5682 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5683 * - we do not need to check algorithm_pos
5684 */
5685
5686 if (quiet == 0)
5687 {
5688 if (benchmark == 1)
5689 {
5690 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5691
5692 log_info ("");
5693 }
5694 else if (restore == 1)
5695 {
5696 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5697
5698 log_info ("");
5699 }
5700 else
5701 {
5702 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5703
5704 log_info ("");
5705 }
5706 }
5707
5708 /**
5709 * sanity check
5710 */
5711
5712 if (attack_mode > 7)
5713 {
5714 log_error ("ERROR: Invalid attack-mode specified");
5715
5716 return (-1);
5717 }
5718
5719 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5720 {
5721 log_error ("ERROR: Invalid runtime specified");
5722
5723 return (-1);
5724 }
5725
5726 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5727 {
5728 log_error ("ERROR: Invalid hash-type specified");
5729
5730 return (-1);
5731 }
5732
5733 // renamed hash modes
5734
5735 if (hash_mode_chgd)
5736 {
5737 int n = -1;
5738
5739 switch (hash_mode)
5740 {
5741 case 123: n = 124;
5742 break;
5743 }
5744
5745 if (n >= 0)
5746 {
5747 log_error ("Old -m specified, use -m %d instead", n);
5748
5749 return (-1);
5750 }
5751 }
5752
5753 if (username == 1)
5754 {
5755 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5756 {
5757 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5758
5759 return (-1);
5760 }
5761 }
5762
5763 if (outfile_format > 16)
5764 {
5765 log_error ("ERROR: Invalid outfile-format specified");
5766
5767 return (-1);
5768 }
5769
5770 if (left == 1)
5771 {
5772 if (outfile_format_chgd == 1)
5773 {
5774 if (outfile_format > 1)
5775 {
5776 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5777
5778 return (-1);
5779 }
5780 }
5781 else
5782 {
5783 outfile_format = OUTFILE_FMT_HASH;
5784 }
5785 }
5786
5787 if (show == 1)
5788 {
5789 if (outfile_format_chgd == 1)
5790 {
5791 if ((outfile_format > 7) && (outfile_format < 16))
5792 {
5793 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5794
5795 return (-1);
5796 }
5797 }
5798 }
5799
5800 if (increment_min < INCREMENT_MIN)
5801 {
5802 log_error ("ERROR: Invalid increment-min specified");
5803
5804 return (-1);
5805 }
5806
5807 if (increment_max > INCREMENT_MAX)
5808 {
5809 log_error ("ERROR: Invalid increment-max specified");
5810
5811 return (-1);
5812 }
5813
5814 if (increment_min > increment_max)
5815 {
5816 log_error ("ERROR: Invalid increment-min specified");
5817
5818 return (-1);
5819 }
5820
5821 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5822 {
5823 log_error ("ERROR: increment is not allowed in attack-mode 0");
5824
5825 return (-1);
5826 }
5827
5828 if ((increment == 0) && (increment_min_chgd == 1))
5829 {
5830 log_error ("ERROR: increment-min is only supported together with increment switch");
5831
5832 return (-1);
5833 }
5834
5835 if ((increment == 0) && (increment_max_chgd == 1))
5836 {
5837 log_error ("ERROR: increment-max is only supported together with increment switch");
5838
5839 return (-1);
5840 }
5841
5842 if (rp_files_cnt && rp_gen)
5843 {
5844 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5845
5846 return (-1);
5847 }
5848
5849 if (rp_files_cnt || rp_gen)
5850 {
5851 if (attack_mode != ATTACK_MODE_STRAIGHT)
5852 {
5853 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5854
5855 return (-1);
5856 }
5857 }
5858
5859 if (rp_gen_func_min > rp_gen_func_max)
5860 {
5861 log_error ("ERROR: Invalid rp-gen-func-min specified");
5862
5863 return (-1);
5864 }
5865
5866 if (kernel_accel_chgd == 1)
5867 {
5868 if (workload_profile != WORKLOAD_PROFILE)
5869 {
5870 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5871
5872 return (-1);
5873 }
5874
5875 if (kernel_accel < 1)
5876 {
5877 log_error ("ERROR: Invalid kernel-accel specified");
5878
5879 return (-1);
5880 }
5881
5882 if (kernel_accel > 800)
5883 {
5884 log_error ("ERROR: Invalid kernel-accel specified");
5885
5886 return (-1);
5887 }
5888 }
5889
5890 if (kernel_loops_chgd == 1)
5891 {
5892 if (workload_profile != WORKLOAD_PROFILE)
5893 {
5894 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5895
5896 return (-1);
5897 }
5898
5899 if (kernel_loops < 1)
5900 {
5901 log_error ("ERROR: Invalid kernel-loops specified");
5902
5903 return (-1);
5904 }
5905
5906 if (kernel_loops > 1024)
5907 {
5908 log_error ("ERROR: Invalid kernel-loops specified");
5909
5910 return (-1);
5911 }
5912 }
5913
5914 if (benchmark == 1)
5915 {
5916 if (workload_profile != WORKLOAD_PROFILE)
5917 {
5918 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5919
5920 return (-1);
5921 }
5922 }
5923
5924 if ((workload_profile < 1) || (workload_profile > 3))
5925 {
5926 log_error ("ERROR: workload-profile %i not available", workload_profile);
5927
5928 return (-1);
5929 }
5930
5931 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5932 {
5933 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5934
5935 return (-1);
5936 }
5937
5938 if (show == 1 || left == 1)
5939 {
5940 attack_mode = ATTACK_MODE_NONE;
5941
5942 if (remove == 1)
5943 {
5944 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5945
5946 return (-1);
5947 }
5948
5949 if (potfile_disable == 1)
5950 {
5951 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5952
5953 return (-1);
5954 }
5955 }
5956
5957 uint attack_kern = ATTACK_KERN_NONE;
5958
5959 switch (attack_mode)
5960 {
5961 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5962 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5963 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5964 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5965 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5966 }
5967
5968 if (benchmark == 0)
5969 {
5970 if (keyspace == 1)
5971 {
5972 int num_additional_params = 1;
5973
5974 if (attack_kern == ATTACK_KERN_COMBI)
5975 {
5976 num_additional_params = 2;
5977 }
5978
5979 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5980
5981 if (keyspace_wordlist_specified == 0) optind--;
5982 }
5983
5984 if (attack_kern == ATTACK_KERN_NONE)
5985 {
5986 if ((optind + 1) != myargc)
5987 {
5988 usage_mini_print (myargv[0]);
5989
5990 return (-1);
5991 }
5992 }
5993 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5994 {
5995 if ((optind + 1) > myargc)
5996 {
5997 usage_mini_print (myargv[0]);
5998
5999 return (-1);
6000 }
6001 }
6002 else if (attack_kern == ATTACK_KERN_COMBI)
6003 {
6004 if ((optind + 3) != myargc)
6005 {
6006 usage_mini_print (myargv[0]);
6007
6008 return (-1);
6009 }
6010 }
6011 else if (attack_kern == ATTACK_KERN_BF)
6012 {
6013 if ((optind + 1) > myargc)
6014 {
6015 usage_mini_print (myargv[0]);
6016
6017 return (-1);
6018 }
6019 }
6020 else
6021 {
6022 usage_mini_print (myargv[0]);
6023
6024 return (-1);
6025 }
6026 }
6027 else
6028 {
6029 if (myargv[optind] != 0)
6030 {
6031 log_error ("ERROR: Invalid argument for benchmark mode specified");
6032
6033 return (-1);
6034 }
6035
6036 if (attack_mode_chgd == 1)
6037 {
6038 if (attack_mode != ATTACK_MODE_BF)
6039 {
6040 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6041
6042 return (-1);
6043 }
6044 }
6045
6046 if (benchmark_mode == 0)
6047 {
6048 // nothing to do
6049 }
6050 else if (benchmark_mode == 1)
6051 {
6052 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6053 {
6054 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6055
6056 return (-1);
6057 }
6058 }
6059 else
6060 {
6061 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6062
6063 return (-1);
6064 }
6065 }
6066
6067 if (skip != 0 && limit != 0)
6068 {
6069 limit += skip;
6070 }
6071
6072 if (keyspace == 1)
6073 {
6074 if (show == 1)
6075 {
6076 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6077
6078 return (-1);
6079 }
6080 else if (left == 1)
6081 {
6082 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6083
6084 return (-1);
6085 }
6086
6087 potfile_disable = 1;
6088
6089 restore_disable = 1;
6090
6091 restore = 0;
6092
6093 weak_hash_threshold = 0;
6094
6095 quiet = 1;
6096 }
6097
6098 if (remove_timer_chgd == 1)
6099 {
6100 if (remove == 0)
6101 {
6102 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6103
6104 return (-1);
6105 }
6106
6107 if (remove_timer < 1)
6108 {
6109 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6110
6111 return (-1);
6112 }
6113 }
6114
6115 if (loopback == 1)
6116 {
6117 if (attack_mode == ATTACK_MODE_BF)
6118 {
6119 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6120
6121 return (-1);
6122 }
6123 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6124 {
6125 if ((rp_files_cnt == 0) && (rp_gen == 0))
6126 {
6127 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6128
6129 return (-1);
6130 }
6131 }
6132 }
6133
6134 if (debug_mode > 0)
6135 {
6136 if (attack_mode != ATTACK_MODE_STRAIGHT)
6137 {
6138 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6139
6140 return (-1);
6141 }
6142
6143 if ((rp_files_cnt == 0) && (rp_gen == 0))
6144 {
6145 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6146
6147 return (-1);
6148 }
6149 }
6150
6151 if (debug_mode > 4)
6152 {
6153 log_error ("ERROR: Invalid debug-mode specified");
6154
6155 return (-1);
6156 }
6157
6158 if (debug_file != NULL)
6159 {
6160 if (debug_mode < 1)
6161 {
6162 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6163
6164 return (-1);
6165 }
6166 }
6167
6168 if (induction_dir != NULL)
6169 {
6170 if (attack_mode == ATTACK_MODE_BF)
6171 {
6172 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (attack_mode != ATTACK_MODE_STRAIGHT)
6179 {
6180 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6181 {
6182 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6183
6184 return (-1);
6185 }
6186
6187 weak_hash_threshold = 0;
6188 }
6189
6190 /**
6191 * induction directory
6192 */
6193
6194 char *induction_directory = NULL;
6195
6196 if (attack_mode != ATTACK_MODE_BF)
6197 {
6198 if (induction_dir == NULL)
6199 {
6200 induction_directory = (char *) mymalloc (session_size);
6201
6202 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6203
6204 // create induction folder if it does not already exist
6205
6206 if (keyspace == 0)
6207 {
6208 if (rmdir (induction_directory) == -1)
6209 {
6210 if (errno == ENOENT)
6211 {
6212 // good, we can ignore
6213 }
6214 else if (errno == ENOTEMPTY)
6215 {
6216 char *induction_directory_mv = (char *) mymalloc (session_size);
6217
6218 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6219
6220 if (rename (induction_directory, induction_directory_mv) != 0)
6221 {
6222 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6223
6224 return (-1);
6225 }
6226 }
6227 else
6228 {
6229 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6230
6231 return (-1);
6232 }
6233 }
6234
6235 if (mkdir (induction_directory, 0700) == -1)
6236 {
6237 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6238
6239 return (-1);
6240 }
6241 }
6242 }
6243 else
6244 {
6245 induction_directory = induction_dir;
6246 }
6247 }
6248
6249 data.induction_directory = induction_directory;
6250
6251 /**
6252 * loopback
6253 */
6254
6255 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6256
6257 char *loopback_file = (char *) mymalloc (loopback_size);
6258
6259 /**
6260 * outfile-check directory
6261 */
6262
6263 char *outfile_check_directory = NULL;
6264
6265 if (outfile_check_dir == NULL)
6266 {
6267 outfile_check_directory = (char *) mymalloc (session_size);
6268
6269 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6270 }
6271 else
6272 {
6273 outfile_check_directory = outfile_check_dir;
6274 }
6275
6276 data.outfile_check_directory = outfile_check_directory;
6277
6278 if (keyspace == 0)
6279 {
6280 struct stat outfile_check_stat;
6281
6282 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6283 {
6284 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6285
6286 if (is_dir == 0)
6287 {
6288 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6289
6290 return (-1);
6291 }
6292 }
6293 else if (outfile_check_dir == NULL)
6294 {
6295 if (mkdir (outfile_check_directory, 0700) == -1)
6296 {
6297 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6298
6299 return (-1);
6300 }
6301 }
6302 }
6303
6304 /**
6305 * special other stuff
6306 */
6307
6308 if (hash_mode == 9710)
6309 {
6310 outfile_format = 5;
6311 outfile_format_chgd = 1;
6312 }
6313
6314 if (hash_mode == 9810)
6315 {
6316 outfile_format = 5;
6317 outfile_format_chgd = 1;
6318 }
6319
6320 if (hash_mode == 10410)
6321 {
6322 outfile_format = 5;
6323 outfile_format_chgd = 1;
6324 }
6325
6326 /**
6327 * store stuff
6328 */
6329
6330 data.hash_mode = hash_mode;
6331 data.restore = restore;
6332 data.restore_timer = restore_timer;
6333 data.restore_disable = restore_disable;
6334 data.status = status;
6335 data.status_timer = status_timer;
6336 data.status_automat = status_automat;
6337 data.loopback = loopback;
6338 data.runtime = runtime;
6339 data.remove = remove;
6340 data.remove_timer = remove_timer;
6341 data.debug_mode = debug_mode;
6342 data.debug_file = debug_file;
6343 data.username = username;
6344 data.quiet = quiet;
6345 data.outfile = outfile;
6346 data.outfile_format = outfile_format;
6347 data.outfile_autohex = outfile_autohex;
6348 data.hex_charset = hex_charset;
6349 data.hex_salt = hex_salt;
6350 data.hex_wordlist = hex_wordlist;
6351 data.separator = separator;
6352 data.rp_files = rp_files;
6353 data.rp_files_cnt = rp_files_cnt;
6354 data.rp_gen = rp_gen;
6355 data.rp_gen_seed = rp_gen_seed;
6356 data.force = force;
6357 data.benchmark = benchmark;
6358 data.skip = skip;
6359 data.limit = limit;
6360 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6361 data.powertune_enable = powertune_enable;
6362 #endif
6363 data.logfile_disable = logfile_disable;
6364 data.truecrypt_keyfiles = truecrypt_keyfiles;
6365 data.scrypt_tmto = scrypt_tmto;
6366
6367 /**
6368 * cpu affinity
6369 */
6370
6371 #ifndef OSX
6372 if (cpu_affinity)
6373 {
6374 set_cpu_affinity (cpu_affinity);
6375 }
6376 #endif
6377
6378 if (rp_gen_seed_chgd == 0)
6379 {
6380 srand (proc_start);
6381 }
6382 else
6383 {
6384 srand (rp_gen_seed);
6385 }
6386
6387 /**
6388 * logfile init
6389 */
6390
6391 if (logfile_disable == 0)
6392 {
6393 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6394
6395 char *logfile = (char *) mymalloc (logfile_size);
6396
6397 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6398
6399 data.logfile = logfile;
6400
6401 char *topid = logfile_generate_topid ();
6402
6403 data.topid = topid;
6404 }
6405
6406 // logfile_append() checks for logfile_disable internally to make it easier from here
6407
6408 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6409 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6410 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6411 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6412 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6413 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6414 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6415 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6416 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6417 #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));
6418
6419 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6420 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6421 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6422 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6423 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6424 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6425 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6426 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6427
6428 logfile_top_msg ("START");
6429
6430 logfile_top_uint (attack_mode);
6431 logfile_top_uint (attack_kern);
6432 logfile_top_uint (benchmark);
6433 logfile_top_uint (benchmark_mode);
6434 logfile_top_uint (bitmap_min);
6435 logfile_top_uint (bitmap_max);
6436 logfile_top_uint (debug_mode);
6437 logfile_top_uint (force);
6438 logfile_top_uint (kernel_accel);
6439 logfile_top_uint (kernel_loops);
6440 #ifdef HAVE_HWMON
6441 logfile_top_uint (gpu_temp_abort);
6442 logfile_top_uint (gpu_temp_disable);
6443 logfile_top_uint (gpu_temp_retain);
6444 #endif
6445 logfile_top_uint (hash_mode);
6446 logfile_top_uint (hex_charset);
6447 logfile_top_uint (hex_salt);
6448 logfile_top_uint (hex_wordlist);
6449 logfile_top_uint (increment);
6450 logfile_top_uint (increment_max);
6451 logfile_top_uint (increment_min);
6452 logfile_top_uint (keyspace);
6453 logfile_top_uint (left);
6454 logfile_top_uint (logfile_disable);
6455 logfile_top_uint (loopback);
6456 logfile_top_uint (markov_classic);
6457 logfile_top_uint (markov_disable);
6458 logfile_top_uint (markov_threshold);
6459 logfile_top_uint (outfile_autohex);
6460 logfile_top_uint (outfile_check_timer);
6461 logfile_top_uint (outfile_format);
6462 logfile_top_uint (potfile_disable);
6463 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6464 logfile_top_uint (powertune_enable);
6465 #endif
6466 logfile_top_uint (scrypt_tmto);
6467 logfile_top_uint (quiet);
6468 logfile_top_uint (remove);
6469 logfile_top_uint (remove_timer);
6470 logfile_top_uint (restore);
6471 logfile_top_uint (restore_disable);
6472 logfile_top_uint (restore_timer);
6473 logfile_top_uint (rp_gen);
6474 logfile_top_uint (rp_gen_func_max);
6475 logfile_top_uint (rp_gen_func_min);
6476 logfile_top_uint (rp_gen_seed);
6477 logfile_top_uint (runtime);
6478 logfile_top_uint (segment_size);
6479 logfile_top_uint (show);
6480 logfile_top_uint (status);
6481 logfile_top_uint (status_automat);
6482 logfile_top_uint (status_timer);
6483 logfile_top_uint (usage);
6484 logfile_top_uint (username);
6485 logfile_top_uint (version);
6486 logfile_top_uint (weak_hash_threshold);
6487 logfile_top_uint (workload_profile);
6488 logfile_top_uint64 (limit);
6489 logfile_top_uint64 (skip);
6490 logfile_top_char (separator);
6491 #ifndef OSX
6492 logfile_top_string (cpu_affinity);
6493 #endif
6494 logfile_top_string (custom_charset_1);
6495 logfile_top_string (custom_charset_2);
6496 logfile_top_string (custom_charset_3);
6497 logfile_top_string (custom_charset_4);
6498 logfile_top_string (debug_file);
6499 logfile_top_string (opencl_devices);
6500 logfile_top_string (opencl_platforms);
6501 logfile_top_string (opencl_device_types);
6502 logfile_top_uint (opencl_vector_width);
6503 logfile_top_string (induction_dir);
6504 logfile_top_string (markov_hcstat);
6505 logfile_top_string (outfile);
6506 logfile_top_string (outfile_check_dir);
6507 logfile_top_string (rule_buf_l);
6508 logfile_top_string (rule_buf_r);
6509 logfile_top_string (session);
6510 logfile_top_string (truecrypt_keyfiles);
6511
6512 /**
6513 * OpenCL platform selection
6514 */
6515
6516 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6517
6518 /**
6519 * OpenCL device selection
6520 */
6521
6522 u32 devices_filter = setup_devices_filter (opencl_devices);
6523
6524 /**
6525 * OpenCL device type selection
6526 */
6527
6528 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6529
6530 /**
6531 * benchmark
6532 */
6533
6534 if (benchmark == 1)
6535 {
6536 /**
6537 * disable useless stuff for benchmark
6538 */
6539
6540 restore_timer = 0;
6541 status_timer = 0;
6542 restore_disable = 1;
6543 potfile_disable = 1;
6544 weak_hash_threshold = 0;
6545
6546 data.restore_timer = restore_timer;
6547 data.status_timer = status_timer;
6548 data.restore_disable = restore_disable;
6549
6550 if (benchmark_mode == 1)
6551 {
6552 markov_disable = 1;
6553 }
6554
6555 /**
6556 * force attack mode to be bruteforce
6557 */
6558
6559 attack_mode = ATTACK_MODE_BF;
6560 attack_kern = ATTACK_KERN_BF;
6561
6562 if (runtime_chgd == 0)
6563 {
6564 runtime = 4;
6565
6566 if (benchmark_mode == 1) runtime = 17;
6567
6568 data.runtime = runtime;
6569 }
6570 }
6571
6572 /**
6573 * config
6574 */
6575
6576 uint hash_type = 0;
6577 uint salt_type = 0;
6578 uint attack_exec = 0;
6579 uint opts_type = 0;
6580 uint kern_type = 0;
6581 uint dgst_size = 0;
6582 uint esalt_size = 0;
6583 uint opti_type = 0;
6584 uint dgst_pos0 = -1;
6585 uint dgst_pos1 = -1;
6586 uint dgst_pos2 = -1;
6587 uint dgst_pos3 = -1;
6588
6589 int (*parse_func) (char *, uint, hash_t *);
6590 int (*sort_by_digest) (const void *, const void *);
6591
6592 uint algorithm_pos = 0;
6593 uint algorithm_max = 1;
6594
6595 uint *algorithms = default_benchmark_algorithms;
6596
6597 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6598
6599 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6600 {
6601 /*
6602 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6603 * the following algos are skipped entirely
6604 */
6605
6606 if (algorithm_pos > 0)
6607 {
6608 local_free (rd);
6609
6610 rd = init_restore (argc, argv);
6611
6612 data.rd = rd;
6613 }
6614
6615 /**
6616 * update hash_mode in case of multihash benchmark
6617 */
6618
6619 if (benchmark == 1)
6620 {
6621 if (hash_mode_chgd == 0)
6622 {
6623 hash_mode = algorithms[algorithm_pos];
6624
6625 data.hash_mode = hash_mode;
6626 }
6627
6628 quiet = 1;
6629
6630 data.quiet = quiet;
6631 }
6632
6633 switch (hash_mode)
6634 {
6635 case 0: hash_type = HASH_TYPE_MD5;
6636 salt_type = SALT_TYPE_NONE;
6637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6638 opts_type = OPTS_TYPE_PT_GENERATE_LE
6639 | OPTS_TYPE_PT_ADD80
6640 | OPTS_TYPE_PT_ADDBITS14;
6641 kern_type = KERN_TYPE_MD5;
6642 dgst_size = DGST_SIZE_4_4;
6643 parse_func = md5_parse_hash;
6644 sort_by_digest = sort_by_digest_4_4;
6645 opti_type = OPTI_TYPE_ZERO_BYTE
6646 | OPTI_TYPE_PRECOMPUTE_INIT
6647 | OPTI_TYPE_PRECOMPUTE_MERKLE
6648 | OPTI_TYPE_MEET_IN_MIDDLE
6649 | OPTI_TYPE_EARLY_SKIP
6650 | OPTI_TYPE_NOT_ITERATED
6651 | OPTI_TYPE_NOT_SALTED
6652 | OPTI_TYPE_RAW_HASH;
6653 dgst_pos0 = 0;
6654 dgst_pos1 = 3;
6655 dgst_pos2 = 2;
6656 dgst_pos3 = 1;
6657 break;
6658
6659 case 10: hash_type = HASH_TYPE_MD5;
6660 salt_type = SALT_TYPE_INTERN;
6661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6662 opts_type = OPTS_TYPE_PT_GENERATE_LE
6663 | OPTS_TYPE_ST_ADD80
6664 | OPTS_TYPE_ST_ADDBITS14;
6665 kern_type = KERN_TYPE_MD5_PWSLT;
6666 dgst_size = DGST_SIZE_4_4;
6667 parse_func = md5s_parse_hash;
6668 sort_by_digest = sort_by_digest_4_4;
6669 opti_type = OPTI_TYPE_ZERO_BYTE
6670 | OPTI_TYPE_PRECOMPUTE_INIT
6671 | OPTI_TYPE_PRECOMPUTE_MERKLE
6672 | OPTI_TYPE_MEET_IN_MIDDLE
6673 | OPTI_TYPE_EARLY_SKIP
6674 | OPTI_TYPE_NOT_ITERATED
6675 | OPTI_TYPE_APPENDED_SALT
6676 | OPTI_TYPE_RAW_HASH;
6677 dgst_pos0 = 0;
6678 dgst_pos1 = 3;
6679 dgst_pos2 = 2;
6680 dgst_pos3 = 1;
6681 break;
6682
6683 case 11: hash_type = HASH_TYPE_MD5;
6684 salt_type = SALT_TYPE_INTERN;
6685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6686 opts_type = OPTS_TYPE_PT_GENERATE_LE
6687 | OPTS_TYPE_ST_ADD80
6688 | OPTS_TYPE_ST_ADDBITS14;
6689 kern_type = KERN_TYPE_MD5_PWSLT;
6690 dgst_size = DGST_SIZE_4_4;
6691 parse_func = joomla_parse_hash;
6692 sort_by_digest = sort_by_digest_4_4;
6693 opti_type = OPTI_TYPE_ZERO_BYTE
6694 | OPTI_TYPE_PRECOMPUTE_INIT
6695 | OPTI_TYPE_PRECOMPUTE_MERKLE
6696 | OPTI_TYPE_MEET_IN_MIDDLE
6697 | OPTI_TYPE_EARLY_SKIP
6698 | OPTI_TYPE_NOT_ITERATED
6699 | OPTI_TYPE_APPENDED_SALT
6700 | OPTI_TYPE_RAW_HASH;
6701 dgst_pos0 = 0;
6702 dgst_pos1 = 3;
6703 dgst_pos2 = 2;
6704 dgst_pos3 = 1;
6705 break;
6706
6707 case 12: hash_type = HASH_TYPE_MD5;
6708 salt_type = SALT_TYPE_INTERN;
6709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6710 opts_type = OPTS_TYPE_PT_GENERATE_LE
6711 | OPTS_TYPE_ST_ADD80
6712 | OPTS_TYPE_ST_ADDBITS14;
6713 kern_type = KERN_TYPE_MD5_PWSLT;
6714 dgst_size = DGST_SIZE_4_4;
6715 parse_func = postgresql_parse_hash;
6716 sort_by_digest = sort_by_digest_4_4;
6717 opti_type = OPTI_TYPE_ZERO_BYTE
6718 | OPTI_TYPE_PRECOMPUTE_INIT
6719 | OPTI_TYPE_PRECOMPUTE_MERKLE
6720 | OPTI_TYPE_MEET_IN_MIDDLE
6721 | OPTI_TYPE_EARLY_SKIP
6722 | OPTI_TYPE_NOT_ITERATED
6723 | OPTI_TYPE_APPENDED_SALT
6724 | OPTI_TYPE_RAW_HASH;
6725 dgst_pos0 = 0;
6726 dgst_pos1 = 3;
6727 dgst_pos2 = 2;
6728 dgst_pos3 = 1;
6729 break;
6730
6731 case 20: hash_type = HASH_TYPE_MD5;
6732 salt_type = SALT_TYPE_INTERN;
6733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6734 opts_type = OPTS_TYPE_PT_GENERATE_LE
6735 | OPTS_TYPE_PT_ADD80
6736 | OPTS_TYPE_PT_ADDBITS14;
6737 kern_type = KERN_TYPE_MD5_SLTPW;
6738 dgst_size = DGST_SIZE_4_4;
6739 parse_func = md5s_parse_hash;
6740 sort_by_digest = sort_by_digest_4_4;
6741 opti_type = OPTI_TYPE_ZERO_BYTE
6742 | OPTI_TYPE_PRECOMPUTE_INIT
6743 | OPTI_TYPE_PRECOMPUTE_MERKLE
6744 | OPTI_TYPE_EARLY_SKIP
6745 | OPTI_TYPE_NOT_ITERATED
6746 | OPTI_TYPE_PREPENDED_SALT
6747 | OPTI_TYPE_RAW_HASH;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 21: hash_type = HASH_TYPE_MD5;
6755 salt_type = SALT_TYPE_INTERN;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_LE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS14;
6760 kern_type = KERN_TYPE_MD5_SLTPW;
6761 dgst_size = DGST_SIZE_4_4;
6762 parse_func = osc_parse_hash;
6763 sort_by_digest = sort_by_digest_4_4;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_PREPENDED_SALT
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 0;
6772 dgst_pos1 = 3;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 22: hash_type = HASH_TYPE_MD5;
6778 salt_type = SALT_TYPE_EMBEDDED;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_LE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS14;
6783 kern_type = KERN_TYPE_MD5_SLTPW;
6784 dgst_size = DGST_SIZE_4_4;
6785 parse_func = netscreen_parse_hash;
6786 sort_by_digest = sort_by_digest_4_4;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_PREPENDED_SALT
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 0;
6795 dgst_pos1 = 3;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 23: hash_type = HASH_TYPE_MD5;
6801 salt_type = SALT_TYPE_EMBEDDED;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_LE
6804 | OPTS_TYPE_PT_ADD80
6805 | OPTS_TYPE_PT_ADDBITS14;
6806 kern_type = KERN_TYPE_MD5_SLTPW;
6807 dgst_size = DGST_SIZE_4_4;
6808 parse_func = skype_parse_hash;
6809 sort_by_digest = sort_by_digest_4_4;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_PREPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 0;
6818 dgst_pos1 = 3;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 30: hash_type = HASH_TYPE_MD5;
6824 salt_type = SALT_TYPE_INTERN;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_LE
6827 | OPTS_TYPE_PT_UNICODE
6828 | OPTS_TYPE_ST_ADD80
6829 | OPTS_TYPE_ST_ADDBITS14;
6830 kern_type = KERN_TYPE_MD5_PWUSLT;
6831 dgst_size = DGST_SIZE_4_4;
6832 parse_func = md5s_parse_hash;
6833 sort_by_digest = sort_by_digest_4_4;
6834 opti_type = OPTI_TYPE_ZERO_BYTE
6835 | OPTI_TYPE_PRECOMPUTE_INIT
6836 | OPTI_TYPE_PRECOMPUTE_MERKLE
6837 | OPTI_TYPE_MEET_IN_MIDDLE
6838 | OPTI_TYPE_EARLY_SKIP
6839 | OPTI_TYPE_NOT_ITERATED
6840 | OPTI_TYPE_APPENDED_SALT
6841 | OPTI_TYPE_RAW_HASH;
6842 dgst_pos0 = 0;
6843 dgst_pos1 = 3;
6844 dgst_pos2 = 2;
6845 dgst_pos3 = 1;
6846 break;
6847
6848 case 40: hash_type = HASH_TYPE_MD5;
6849 salt_type = SALT_TYPE_INTERN;
6850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6851 opts_type = OPTS_TYPE_PT_GENERATE_LE
6852 | OPTS_TYPE_PT_ADD80
6853 | OPTS_TYPE_PT_ADDBITS14
6854 | OPTS_TYPE_PT_UNICODE;
6855 kern_type = KERN_TYPE_MD5_SLTPWU;
6856 dgst_size = DGST_SIZE_4_4;
6857 parse_func = md5s_parse_hash;
6858 sort_by_digest = sort_by_digest_4_4;
6859 opti_type = OPTI_TYPE_ZERO_BYTE
6860 | OPTI_TYPE_PRECOMPUTE_INIT
6861 | OPTI_TYPE_PRECOMPUTE_MERKLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_PREPENDED_SALT
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 0;
6867 dgst_pos1 = 3;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 50: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_ST_ADD80
6877 | OPTS_TYPE_ST_ADDBITS14;
6878 kern_type = KERN_TYPE_HMACMD5_PW;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = hmacmd5_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_NOT_ITERATED;
6884 dgst_pos0 = 0;
6885 dgst_pos1 = 3;
6886 dgst_pos2 = 2;
6887 dgst_pos3 = 1;
6888 break;
6889
6890 case 60: hash_type = HASH_TYPE_MD5;
6891 salt_type = SALT_TYPE_INTERN;
6892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6893 opts_type = OPTS_TYPE_PT_GENERATE_LE
6894 | OPTS_TYPE_PT_ADD80
6895 | OPTS_TYPE_PT_ADDBITS14;
6896 kern_type = KERN_TYPE_HMACMD5_SLT;
6897 dgst_size = DGST_SIZE_4_4;
6898 parse_func = hmacmd5_parse_hash;
6899 sort_by_digest = sort_by_digest_4_4;
6900 opti_type = OPTI_TYPE_ZERO_BYTE
6901 | OPTI_TYPE_NOT_ITERATED;
6902 dgst_pos0 = 0;
6903 dgst_pos1 = 3;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 100: hash_type = HASH_TYPE_SHA1;
6909 salt_type = SALT_TYPE_NONE;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_BE
6912 | OPTS_TYPE_PT_ADD80
6913 | OPTS_TYPE_PT_ADDBITS15;
6914 kern_type = KERN_TYPE_SHA1;
6915 dgst_size = DGST_SIZE_4_5;
6916 parse_func = sha1_parse_hash;
6917 sort_by_digest = sort_by_digest_4_5;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_NOT_SALTED
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 3;
6926 dgst_pos1 = 4;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 101: hash_type = HASH_TYPE_SHA1;
6932 salt_type = SALT_TYPE_NONE;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_BE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS15;
6937 kern_type = KERN_TYPE_SHA1;
6938 dgst_size = DGST_SIZE_4_5;
6939 parse_func = sha1b64_parse_hash;
6940 sort_by_digest = sort_by_digest_4_5;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_EARLY_SKIP
6945 | OPTI_TYPE_NOT_ITERATED
6946 | OPTI_TYPE_NOT_SALTED
6947 | OPTI_TYPE_RAW_HASH;
6948 dgst_pos0 = 3;
6949 dgst_pos1 = 4;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 110: hash_type = HASH_TYPE_SHA1;
6955 salt_type = SALT_TYPE_INTERN;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_BE
6958 | OPTS_TYPE_ST_ADD80
6959 | OPTS_TYPE_ST_ADDBITS15;
6960 kern_type = KERN_TYPE_SHA1_PWSLT;
6961 dgst_size = DGST_SIZE_4_5;
6962 parse_func = sha1s_parse_hash;
6963 sort_by_digest = sort_by_digest_4_5;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_APPENDED_SALT
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 3;
6972 dgst_pos1 = 4;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 111: hash_type = HASH_TYPE_SHA1;
6978 salt_type = SALT_TYPE_EMBEDDED;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_BE
6981 | OPTS_TYPE_ST_ADD80
6982 | OPTS_TYPE_ST_ADDBITS15;
6983 kern_type = KERN_TYPE_SHA1_PWSLT;
6984 dgst_size = DGST_SIZE_4_5;
6985 parse_func = sha1b64s_parse_hash;
6986 sort_by_digest = sort_by_digest_4_5;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_APPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 3;
6995 dgst_pos1 = 4;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 112: hash_type = HASH_TYPE_SHA1;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_BE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS15
7006 | OPTS_TYPE_ST_HEX;
7007 kern_type = KERN_TYPE_SHA1_PWSLT;
7008 dgst_size = DGST_SIZE_4_5;
7009 parse_func = oracles_parse_hash;
7010 sort_by_digest = sort_by_digest_4_5;
7011 opti_type = OPTI_TYPE_ZERO_BYTE
7012 | OPTI_TYPE_PRECOMPUTE_INIT
7013 | OPTI_TYPE_PRECOMPUTE_MERKLE
7014 | OPTI_TYPE_EARLY_SKIP
7015 | OPTI_TYPE_NOT_ITERATED
7016 | OPTI_TYPE_APPENDED_SALT
7017 | OPTI_TYPE_RAW_HASH;
7018 dgst_pos0 = 3;
7019 dgst_pos1 = 4;
7020 dgst_pos2 = 2;
7021 dgst_pos3 = 1;
7022 break;
7023
7024 case 120: hash_type = HASH_TYPE_SHA1;
7025 salt_type = SALT_TYPE_INTERN;
7026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7027 opts_type = OPTS_TYPE_PT_GENERATE_BE
7028 | OPTS_TYPE_PT_ADD80
7029 | OPTS_TYPE_PT_ADDBITS15;
7030 kern_type = KERN_TYPE_SHA1_SLTPW;
7031 dgst_size = DGST_SIZE_4_5;
7032 parse_func = sha1s_parse_hash;
7033 sort_by_digest = sort_by_digest_4_5;
7034 opti_type = OPTI_TYPE_ZERO_BYTE
7035 | OPTI_TYPE_PRECOMPUTE_INIT
7036 | OPTI_TYPE_PRECOMPUTE_MERKLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_PREPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 3;
7042 dgst_pos1 = 4;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 121: hash_type = HASH_TYPE_SHA1;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_BE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS15
7053 | OPTS_TYPE_ST_LOWER;
7054 kern_type = KERN_TYPE_SHA1_SLTPW;
7055 dgst_size = DGST_SIZE_4_5;
7056 parse_func = smf_parse_hash;
7057 sort_by_digest = sort_by_digest_4_5;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_PRECOMPUTE_INIT
7060 | OPTI_TYPE_PRECOMPUTE_MERKLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_PREPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 3;
7066 dgst_pos1 = 4;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 122: hash_type = HASH_TYPE_SHA1;
7072 salt_type = SALT_TYPE_EMBEDDED;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_BE
7075 | OPTS_TYPE_PT_ADD80
7076 | OPTS_TYPE_PT_ADDBITS15
7077 | OPTS_TYPE_ST_HEX;
7078 kern_type = KERN_TYPE_SHA1_SLTPW;
7079 dgst_size = DGST_SIZE_4_5;
7080 parse_func = osx1_parse_hash;
7081 sort_by_digest = sort_by_digest_4_5;
7082 opti_type = OPTI_TYPE_ZERO_BYTE
7083 | OPTI_TYPE_PRECOMPUTE_INIT
7084 | OPTI_TYPE_PRECOMPUTE_MERKLE
7085 | OPTI_TYPE_EARLY_SKIP
7086 | OPTI_TYPE_NOT_ITERATED
7087 | OPTI_TYPE_PREPENDED_SALT
7088 | OPTI_TYPE_RAW_HASH;
7089 dgst_pos0 = 3;
7090 dgst_pos1 = 4;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 124: hash_type = HASH_TYPE_SHA1;
7096 salt_type = SALT_TYPE_EMBEDDED;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_BE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS15;
7101 kern_type = KERN_TYPE_SHA1_SLTPW;
7102 dgst_size = DGST_SIZE_4_5;
7103 parse_func = djangosha1_parse_hash;
7104 sort_by_digest = sort_by_digest_4_5;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_PREPENDED_SALT
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 3;
7113 dgst_pos1 = 4;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 130: hash_type = HASH_TYPE_SHA1;
7119 salt_type = SALT_TYPE_INTERN;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_BE
7122 | OPTS_TYPE_PT_UNICODE
7123 | OPTS_TYPE_ST_ADD80
7124 | OPTS_TYPE_ST_ADDBITS15;
7125 kern_type = KERN_TYPE_SHA1_PWUSLT;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = sha1s_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_EARLY_SKIP
7133 | OPTI_TYPE_NOT_ITERATED
7134 | OPTI_TYPE_APPENDED_SALT
7135 | OPTI_TYPE_RAW_HASH;
7136 dgst_pos0 = 3;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 2;
7139 dgst_pos3 = 1;
7140 break;
7141
7142 case 131: hash_type = HASH_TYPE_SHA1;
7143 salt_type = SALT_TYPE_EMBEDDED;
7144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7145 opts_type = OPTS_TYPE_PT_GENERATE_BE
7146 | OPTS_TYPE_PT_UNICODE
7147 | OPTS_TYPE_PT_UPPER
7148 | OPTS_TYPE_ST_ADD80
7149 | OPTS_TYPE_ST_ADDBITS15
7150 | OPTS_TYPE_ST_HEX;
7151 kern_type = KERN_TYPE_SHA1_PWUSLT;
7152 dgst_size = DGST_SIZE_4_5;
7153 parse_func = mssql2000_parse_hash;
7154 sort_by_digest = sort_by_digest_4_5;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_APPENDED_SALT
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 132: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_EMBEDDED;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_PT_UNICODE
7173 | OPTS_TYPE_ST_ADD80
7174 | OPTS_TYPE_ST_ADDBITS15
7175 | OPTS_TYPE_ST_HEX;
7176 kern_type = KERN_TYPE_SHA1_PWUSLT;
7177 dgst_size = DGST_SIZE_4_5;
7178 parse_func = mssql2005_parse_hash;
7179 sort_by_digest = sort_by_digest_4_5;
7180 opti_type = OPTI_TYPE_ZERO_BYTE
7181 | OPTI_TYPE_PRECOMPUTE_INIT
7182 | OPTI_TYPE_PRECOMPUTE_MERKLE
7183 | OPTI_TYPE_EARLY_SKIP
7184 | OPTI_TYPE_NOT_ITERATED
7185 | OPTI_TYPE_APPENDED_SALT
7186 | OPTI_TYPE_RAW_HASH;
7187 dgst_pos0 = 3;
7188 dgst_pos1 = 4;
7189 dgst_pos2 = 2;
7190 dgst_pos3 = 1;
7191 break;
7192
7193 case 133: hash_type = HASH_TYPE_SHA1;
7194 salt_type = SALT_TYPE_EMBEDDED;
7195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7196 opts_type = OPTS_TYPE_PT_GENERATE_BE
7197 | OPTS_TYPE_PT_UNICODE
7198 | OPTS_TYPE_ST_ADD80
7199 | OPTS_TYPE_ST_ADDBITS15;
7200 kern_type = KERN_TYPE_SHA1_PWUSLT;
7201 dgst_size = DGST_SIZE_4_5;
7202 parse_func = peoplesoft_parse_hash;
7203 sort_by_digest = sort_by_digest_4_5;
7204 opti_type = OPTI_TYPE_ZERO_BYTE
7205 | OPTI_TYPE_PRECOMPUTE_INIT
7206 | OPTI_TYPE_PRECOMPUTE_MERKLE
7207 | OPTI_TYPE_EARLY_SKIP
7208 | OPTI_TYPE_NOT_ITERATED
7209 | OPTI_TYPE_APPENDED_SALT
7210 | OPTI_TYPE_RAW_HASH;
7211 dgst_pos0 = 3;
7212 dgst_pos1 = 4;
7213 dgst_pos2 = 2;
7214 dgst_pos3 = 1;
7215 break;
7216
7217 case 140: hash_type = HASH_TYPE_SHA1;
7218 salt_type = SALT_TYPE_INTERN;
7219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7220 opts_type = OPTS_TYPE_PT_GENERATE_BE
7221 | OPTS_TYPE_PT_ADD80
7222 | OPTS_TYPE_PT_ADDBITS15
7223 | OPTS_TYPE_PT_UNICODE;
7224 kern_type = KERN_TYPE_SHA1_SLTPWU;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = sha1s_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_PRECOMPUTE_MERKLE
7231 | OPTI_TYPE_EARLY_SKIP
7232 | OPTI_TYPE_NOT_ITERATED
7233 | OPTI_TYPE_PREPENDED_SALT
7234 | OPTI_TYPE_RAW_HASH;
7235 dgst_pos0 = 3;
7236 dgst_pos1 = 4;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 141: hash_type = HASH_TYPE_SHA1;
7242 salt_type = SALT_TYPE_EMBEDDED;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_BE
7245 | OPTS_TYPE_PT_ADD80
7246 | OPTS_TYPE_PT_ADDBITS15
7247 | OPTS_TYPE_PT_UNICODE
7248 | OPTS_TYPE_ST_BASE64;
7249 kern_type = KERN_TYPE_SHA1_SLTPWU;
7250 dgst_size = DGST_SIZE_4_5;
7251 parse_func = episerver_parse_hash;
7252 sort_by_digest = sort_by_digest_4_5;
7253 opti_type = OPTI_TYPE_ZERO_BYTE
7254 | OPTI_TYPE_PRECOMPUTE_INIT
7255 | OPTI_TYPE_PRECOMPUTE_MERKLE
7256 | OPTI_TYPE_EARLY_SKIP
7257 | OPTI_TYPE_NOT_ITERATED
7258 | OPTI_TYPE_PREPENDED_SALT
7259 | OPTI_TYPE_RAW_HASH;
7260 dgst_pos0 = 3;
7261 dgst_pos1 = 4;
7262 dgst_pos2 = 2;
7263 dgst_pos3 = 1;
7264 break;
7265
7266 case 150: hash_type = HASH_TYPE_SHA1;
7267 salt_type = SALT_TYPE_INTERN;
7268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7269 opts_type = OPTS_TYPE_PT_GENERATE_BE
7270 | OPTS_TYPE_ST_ADD80
7271 | OPTS_TYPE_ST_ADDBITS15;
7272 kern_type = KERN_TYPE_HMACSHA1_PW;
7273 dgst_size = DGST_SIZE_4_5;
7274 parse_func = hmacsha1_parse_hash;
7275 sort_by_digest = sort_by_digest_4_5;
7276 opti_type = OPTI_TYPE_ZERO_BYTE
7277 | OPTI_TYPE_NOT_ITERATED;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 160: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_INTERN;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15;
7290 kern_type = KERN_TYPE_HMACSHA1_SLT;
7291 dgst_size = DGST_SIZE_4_5;
7292 parse_func = hmacsha1_parse_hash;
7293 sort_by_digest = sort_by_digest_4_5;
7294 opti_type = OPTI_TYPE_ZERO_BYTE
7295 | OPTI_TYPE_NOT_ITERATED;
7296 dgst_pos0 = 3;
7297 dgst_pos1 = 4;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 190: hash_type = HASH_TYPE_SHA1;
7303 salt_type = SALT_TYPE_NONE;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_BE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS15;
7308 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = sha1linkedin_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_EARLY_SKIP
7315 | OPTI_TYPE_NOT_ITERATED
7316 | OPTI_TYPE_NOT_SALTED;
7317 dgst_pos0 = 0;
7318 dgst_pos1 = 4;
7319 dgst_pos2 = 3;
7320 dgst_pos3 = 2;
7321 break;
7322
7323 case 200: hash_type = HASH_TYPE_MYSQL;
7324 salt_type = SALT_TYPE_NONE;
7325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7326 opts_type = 0;
7327 kern_type = KERN_TYPE_MYSQL;
7328 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7329 parse_func = mysql323_parse_hash;
7330 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7331 opti_type = OPTI_TYPE_ZERO_BYTE;
7332 dgst_pos0 = 0;
7333 dgst_pos1 = 1;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 3;
7336 break;
7337
7338 case 300: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_NONE;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15;
7344 kern_type = KERN_TYPE_MYSQL41;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = sha1_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_NOT_SALTED;
7354 dgst_pos0 = 3;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 2;
7357 dgst_pos3 = 1;
7358 break;
7359
7360 case 400: hash_type = HASH_TYPE_MD5;
7361 salt_type = SALT_TYPE_EMBEDDED;
7362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7364 kern_type = KERN_TYPE_PHPASS;
7365 dgst_size = DGST_SIZE_4_4;
7366 parse_func = phpass_parse_hash;
7367 sort_by_digest = sort_by_digest_4_4;
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 500: hash_type = HASH_TYPE_MD5;
7376 salt_type = SALT_TYPE_EMBEDDED;
7377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7379 kern_type = KERN_TYPE_MD5CRYPT;
7380 dgst_size = DGST_SIZE_4_4;
7381 parse_func = md5crypt_parse_hash;
7382 sort_by_digest = sort_by_digest_4_4;
7383 opti_type = OPTI_TYPE_ZERO_BYTE;
7384 dgst_pos0 = 0;
7385 dgst_pos1 = 1;
7386 dgst_pos2 = 2;
7387 dgst_pos3 = 3;
7388 break;
7389
7390 case 501: hash_type = HASH_TYPE_MD5;
7391 salt_type = SALT_TYPE_EMBEDDED;
7392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7393 opts_type = OPTS_TYPE_PT_GENERATE_LE
7394 | OPTS_TYPE_HASH_COPY;
7395 kern_type = KERN_TYPE_MD5CRYPT;
7396 dgst_size = DGST_SIZE_4_4;
7397 parse_func = juniper_parse_hash;
7398 sort_by_digest = sort_by_digest_4_4;
7399 opti_type = OPTI_TYPE_ZERO_BYTE;
7400 dgst_pos0 = 0;
7401 dgst_pos1 = 1;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 3;
7404 break;
7405
7406 case 900: hash_type = HASH_TYPE_MD4;
7407 salt_type = SALT_TYPE_NONE;
7408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_LE
7410 | OPTS_TYPE_PT_ADD80
7411 | OPTS_TYPE_PT_ADDBITS14;
7412 kern_type = KERN_TYPE_MD4;
7413 dgst_size = DGST_SIZE_4_4;
7414 parse_func = md4_parse_hash;
7415 sort_by_digest = sort_by_digest_4_4;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_MEET_IN_MIDDLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_NOT_SALTED
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 0;
7425 dgst_pos1 = 3;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 1000: hash_type = HASH_TYPE_MD4;
7431 salt_type = SALT_TYPE_NONE;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_LE
7434 | OPTS_TYPE_PT_ADD80
7435 | OPTS_TYPE_PT_ADDBITS14
7436 | OPTS_TYPE_PT_UNICODE;
7437 kern_type = KERN_TYPE_MD4_PWU;
7438 dgst_size = DGST_SIZE_4_4;
7439 parse_func = md4_parse_hash;
7440 sort_by_digest = sort_by_digest_4_4;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_MEET_IN_MIDDLE
7445 | OPTI_TYPE_EARLY_SKIP
7446 | OPTI_TYPE_NOT_ITERATED
7447 | OPTI_TYPE_NOT_SALTED
7448 | OPTI_TYPE_RAW_HASH;
7449 dgst_pos0 = 0;
7450 dgst_pos1 = 3;
7451 dgst_pos2 = 2;
7452 dgst_pos3 = 1;
7453 break;
7454
7455 case 1100: hash_type = HASH_TYPE_MD4;
7456 salt_type = SALT_TYPE_INTERN;
7457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7458 opts_type = OPTS_TYPE_PT_GENERATE_LE
7459 | OPTS_TYPE_PT_ADD80
7460 | OPTS_TYPE_PT_ADDBITS14
7461 | OPTS_TYPE_PT_UNICODE
7462 | OPTS_TYPE_ST_ADD80
7463 | OPTS_TYPE_ST_UNICODE
7464 | OPTS_TYPE_ST_LOWER;
7465 kern_type = KERN_TYPE_MD44_PWUSLT;
7466 dgst_size = DGST_SIZE_4_4;
7467 parse_func = dcc_parse_hash;
7468 sort_by_digest = sort_by_digest_4_4;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_PRECOMPUTE_INIT
7471 | OPTI_TYPE_PRECOMPUTE_MERKLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED;
7474 dgst_pos0 = 0;
7475 dgst_pos1 = 3;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 1400: hash_type = HASH_TYPE_SHA256;
7481 salt_type = SALT_TYPE_NONE;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS15;
7486 kern_type = KERN_TYPE_SHA256;
7487 dgst_size = DGST_SIZE_4_8;
7488 parse_func = sha256_parse_hash;
7489 sort_by_digest = sort_by_digest_4_8;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_EARLY_SKIP
7494 | OPTI_TYPE_NOT_ITERATED
7495 | OPTI_TYPE_NOT_SALTED
7496 | OPTI_TYPE_RAW_HASH;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 7;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 6;
7501 break;
7502
7503 case 1410: hash_type = HASH_TYPE_SHA256;
7504 salt_type = SALT_TYPE_INTERN;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_ST_ADD80
7508 | OPTS_TYPE_ST_ADDBITS15;
7509 kern_type = KERN_TYPE_SHA256_PWSLT;
7510 dgst_size = DGST_SIZE_4_8;
7511 parse_func = sha256s_parse_hash;
7512 sort_by_digest = sort_by_digest_4_8;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_PRECOMPUTE_INIT
7515 | OPTI_TYPE_PRECOMPUTE_MERKLE
7516 | OPTI_TYPE_EARLY_SKIP
7517 | OPTI_TYPE_NOT_ITERATED
7518 | OPTI_TYPE_APPENDED_SALT
7519 | OPTI_TYPE_RAW_HASH;
7520 dgst_pos0 = 3;
7521 dgst_pos1 = 7;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 6;
7524 break;
7525
7526 case 1420: hash_type = HASH_TYPE_SHA256;
7527 salt_type = SALT_TYPE_INTERN;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_BE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS15;
7532 kern_type = KERN_TYPE_SHA256_SLTPW;
7533 dgst_size = DGST_SIZE_4_8;
7534 parse_func = sha256s_parse_hash;
7535 sort_by_digest = sort_by_digest_4_8;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_EARLY_SKIP
7540 | OPTI_TYPE_NOT_ITERATED
7541 | OPTI_TYPE_PREPENDED_SALT
7542 | OPTI_TYPE_RAW_HASH;
7543 dgst_pos0 = 3;
7544 dgst_pos1 = 7;
7545 dgst_pos2 = 2;
7546 dgst_pos3 = 6;
7547 break;
7548
7549 case 1421: hash_type = HASH_TYPE_SHA256;
7550 salt_type = SALT_TYPE_EMBEDDED;
7551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7552 opts_type = OPTS_TYPE_PT_GENERATE_BE
7553 | OPTS_TYPE_PT_ADD80
7554 | OPTS_TYPE_PT_ADDBITS15;
7555 kern_type = KERN_TYPE_SHA256_SLTPW;
7556 dgst_size = DGST_SIZE_4_8;
7557 parse_func = hmailserver_parse_hash;
7558 sort_by_digest = sort_by_digest_4_8;
7559 opti_type = OPTI_TYPE_ZERO_BYTE
7560 | OPTI_TYPE_PRECOMPUTE_INIT
7561 | OPTI_TYPE_PRECOMPUTE_MERKLE
7562 | OPTI_TYPE_EARLY_SKIP
7563 | OPTI_TYPE_NOT_ITERATED
7564 | OPTI_TYPE_PREPENDED_SALT
7565 | OPTI_TYPE_RAW_HASH;
7566 dgst_pos0 = 3;
7567 dgst_pos1 = 7;
7568 dgst_pos2 = 2;
7569 dgst_pos3 = 6;
7570 break;
7571
7572 case 1430: hash_type = HASH_TYPE_SHA256;
7573 salt_type = SALT_TYPE_INTERN;
7574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7575 opts_type = OPTS_TYPE_PT_GENERATE_BE
7576 | OPTS_TYPE_PT_UNICODE
7577 | OPTS_TYPE_ST_ADD80
7578 | OPTS_TYPE_ST_ADDBITS15;
7579 kern_type = KERN_TYPE_SHA256_PWUSLT;
7580 dgst_size = DGST_SIZE_4_8;
7581 parse_func = sha256s_parse_hash;
7582 sort_by_digest = sort_by_digest_4_8;
7583 opti_type = OPTI_TYPE_ZERO_BYTE
7584 | OPTI_TYPE_PRECOMPUTE_INIT
7585 | OPTI_TYPE_PRECOMPUTE_MERKLE
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_APPENDED_SALT
7589 | OPTI_TYPE_RAW_HASH;
7590 dgst_pos0 = 3;
7591 dgst_pos1 = 7;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 6;
7594 break;
7595
7596 case 1440: hash_type = HASH_TYPE_SHA256;
7597 salt_type = SALT_TYPE_INTERN;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_BE
7600 | OPTS_TYPE_PT_ADD80
7601 | OPTS_TYPE_PT_ADDBITS15
7602 | OPTS_TYPE_PT_UNICODE;
7603 kern_type = KERN_TYPE_SHA256_SLTPWU;
7604 dgst_size = DGST_SIZE_4_8;
7605 parse_func = sha256s_parse_hash;
7606 sort_by_digest = sort_by_digest_4_8;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_PREPENDED_SALT
7613 | OPTI_TYPE_RAW_HASH;
7614 dgst_pos0 = 3;
7615 dgst_pos1 = 7;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 6;
7618 break;
7619
7620 case 1441: hash_type = HASH_TYPE_SHA256;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_BE
7624 | OPTS_TYPE_PT_ADD80
7625 | OPTS_TYPE_PT_ADDBITS15
7626 | OPTS_TYPE_PT_UNICODE
7627 | OPTS_TYPE_ST_BASE64;
7628 kern_type = KERN_TYPE_SHA256_SLTPWU;
7629 dgst_size = DGST_SIZE_4_8;
7630 parse_func = episerver4_parse_hash;
7631 sort_by_digest = sort_by_digest_4_8;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_PREPENDED_SALT
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 3;
7640 dgst_pos1 = 7;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 6;
7643 break;
7644
7645 case 1450: hash_type = HASH_TYPE_SHA256;
7646 salt_type = SALT_TYPE_INTERN;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_BE
7649 | OPTS_TYPE_ST_ADD80;
7650 kern_type = KERN_TYPE_HMACSHA256_PW;
7651 dgst_size = DGST_SIZE_4_8;
7652 parse_func = hmacsha256_parse_hash;
7653 sort_by_digest = sort_by_digest_4_8;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_NOT_ITERATED;
7656 dgst_pos0 = 3;
7657 dgst_pos1 = 7;
7658 dgst_pos2 = 2;
7659 dgst_pos3 = 6;
7660 break;
7661
7662 case 1460: hash_type = HASH_TYPE_SHA256;
7663 salt_type = SALT_TYPE_INTERN;
7664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7665 opts_type = OPTS_TYPE_PT_GENERATE_BE
7666 | OPTS_TYPE_PT_ADD80
7667 | OPTS_TYPE_PT_ADDBITS15;
7668 kern_type = KERN_TYPE_HMACSHA256_SLT;
7669 dgst_size = DGST_SIZE_4_8;
7670 parse_func = hmacsha256_parse_hash;
7671 sort_by_digest = sort_by_digest_4_8;
7672 opti_type = OPTI_TYPE_ZERO_BYTE
7673 | OPTI_TYPE_NOT_ITERATED;
7674 dgst_pos0 = 3;
7675 dgst_pos1 = 7;
7676 dgst_pos2 = 2;
7677 dgst_pos3 = 6;
7678 break;
7679
7680 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7681 salt_type = SALT_TYPE_EMBEDDED;
7682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7683 opts_type = OPTS_TYPE_PT_GENERATE_LE
7684 | OPTS_TYPE_PT_BITSLICE;
7685 kern_type = KERN_TYPE_DESCRYPT;
7686 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7687 parse_func = descrypt_parse_hash;
7688 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7691 dgst_pos0 = 0;
7692 dgst_pos1 = 1;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 3;
7695 break;
7696
7697 case 1600: hash_type = HASH_TYPE_MD5;
7698 salt_type = SALT_TYPE_EMBEDDED;
7699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7701 kern_type = KERN_TYPE_APR1CRYPT;
7702 dgst_size = DGST_SIZE_4_4;
7703 parse_func = md5apr1_parse_hash;
7704 sort_by_digest = sort_by_digest_4_4;
7705 opti_type = OPTI_TYPE_ZERO_BYTE;
7706 dgst_pos0 = 0;
7707 dgst_pos1 = 1;
7708 dgst_pos2 = 2;
7709 dgst_pos3 = 3;
7710 break;
7711
7712 case 1700: hash_type = HASH_TYPE_SHA512;
7713 salt_type = SALT_TYPE_NONE;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_BE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS15;
7718 kern_type = KERN_TYPE_SHA512;
7719 dgst_size = DGST_SIZE_8_8;
7720 parse_func = sha512_parse_hash;
7721 sort_by_digest = sort_by_digest_8_8;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_PRECOMPUTE_INIT
7724 | OPTI_TYPE_PRECOMPUTE_MERKLE
7725 | OPTI_TYPE_EARLY_SKIP
7726 | OPTI_TYPE_NOT_ITERATED
7727 | OPTI_TYPE_NOT_SALTED
7728 | OPTI_TYPE_USES_BITS_64
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 14;
7731 dgst_pos1 = 15;
7732 dgst_pos2 = 6;
7733 dgst_pos3 = 7;
7734 break;
7735
7736 case 1710: hash_type = HASH_TYPE_SHA512;
7737 salt_type = SALT_TYPE_INTERN;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_ST_ADD80
7741 | OPTS_TYPE_ST_ADDBITS15;
7742 kern_type = KERN_TYPE_SHA512_PWSLT;
7743 dgst_size = DGST_SIZE_8_8;
7744 parse_func = sha512s_parse_hash;
7745 sort_by_digest = sort_by_digest_8_8;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_APPENDED_SALT
7752 | OPTI_TYPE_USES_BITS_64
7753 | OPTI_TYPE_RAW_HASH;
7754 dgst_pos0 = 14;
7755 dgst_pos1 = 15;
7756 dgst_pos2 = 6;
7757 dgst_pos3 = 7;
7758 break;
7759
7760 case 1711: hash_type = HASH_TYPE_SHA512;
7761 salt_type = SALT_TYPE_EMBEDDED;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_ST_ADD80
7765 | OPTS_TYPE_ST_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA512_PWSLT;
7767 dgst_size = DGST_SIZE_8_8;
7768 parse_func = sha512b64s_parse_hash;
7769 sort_by_digest = sort_by_digest_8_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_USES_BITS_64
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 14;
7779 dgst_pos1 = 15;
7780 dgst_pos2 = 6;
7781 dgst_pos3 = 7;
7782 break;
7783
7784 case 1720: hash_type = HASH_TYPE_SHA512;
7785 salt_type = SALT_TYPE_INTERN;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_PT_ADD80
7789 | OPTS_TYPE_PT_ADDBITS15;
7790 kern_type = KERN_TYPE_SHA512_SLTPW;
7791 dgst_size = DGST_SIZE_8_8;
7792 parse_func = sha512s_parse_hash;
7793 sort_by_digest = sort_by_digest_8_8;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_PRECOMPUTE_INIT
7796 | OPTI_TYPE_PRECOMPUTE_MERKLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_PREPENDED_SALT
7800 | OPTI_TYPE_USES_BITS_64
7801 | OPTI_TYPE_RAW_HASH;
7802 dgst_pos0 = 14;
7803 dgst_pos1 = 15;
7804 dgst_pos2 = 6;
7805 dgst_pos3 = 7;
7806 break;
7807
7808 case 1722: hash_type = HASH_TYPE_SHA512;
7809 salt_type = SALT_TYPE_EMBEDDED;
7810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7811 opts_type = OPTS_TYPE_PT_GENERATE_BE
7812 | OPTS_TYPE_PT_ADD80
7813 | OPTS_TYPE_PT_ADDBITS15
7814 | OPTS_TYPE_ST_HEX;
7815 kern_type = KERN_TYPE_SHA512_SLTPW;
7816 dgst_size = DGST_SIZE_8_8;
7817 parse_func = osx512_parse_hash;
7818 sort_by_digest = sort_by_digest_8_8;
7819 opti_type = OPTI_TYPE_ZERO_BYTE
7820 | OPTI_TYPE_PRECOMPUTE_INIT
7821 | OPTI_TYPE_PRECOMPUTE_MERKLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED
7824 | OPTI_TYPE_PREPENDED_SALT
7825 | OPTI_TYPE_USES_BITS_64
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 14;
7828 dgst_pos1 = 15;
7829 dgst_pos2 = 6;
7830 dgst_pos3 = 7;
7831 break;
7832
7833 case 1730: hash_type = HASH_TYPE_SHA512;
7834 salt_type = SALT_TYPE_INTERN;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_PT_UNICODE
7838 | OPTS_TYPE_ST_ADD80
7839 | OPTS_TYPE_ST_ADDBITS15;
7840 kern_type = KERN_TYPE_SHA512_PWSLTU;
7841 dgst_size = DGST_SIZE_8_8;
7842 parse_func = sha512s_parse_hash;
7843 sort_by_digest = sort_by_digest_8_8;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_EARLY_SKIP
7848 | OPTI_TYPE_NOT_ITERATED
7849 | OPTI_TYPE_APPENDED_SALT
7850 | OPTI_TYPE_USES_BITS_64
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 14;
7853 dgst_pos1 = 15;
7854 dgst_pos2 = 6;
7855 dgst_pos3 = 7;
7856 break;
7857
7858 case 1731: hash_type = HASH_TYPE_SHA512;
7859 salt_type = SALT_TYPE_EMBEDDED;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_UNICODE
7863 | OPTS_TYPE_ST_ADD80
7864 | OPTS_TYPE_ST_ADDBITS15
7865 | OPTS_TYPE_ST_HEX;
7866 kern_type = KERN_TYPE_SHA512_PWSLTU;
7867 dgst_size = DGST_SIZE_8_8;
7868 parse_func = mssql2012_parse_hash;
7869 sort_by_digest = sort_by_digest_8_8;
7870 opti_type = OPTI_TYPE_ZERO_BYTE
7871 | OPTI_TYPE_PRECOMPUTE_INIT
7872 | OPTI_TYPE_PRECOMPUTE_MERKLE
7873 | OPTI_TYPE_EARLY_SKIP
7874 | OPTI_TYPE_NOT_ITERATED
7875 | OPTI_TYPE_APPENDED_SALT
7876 | OPTI_TYPE_USES_BITS_64
7877 | OPTI_TYPE_RAW_HASH;
7878 dgst_pos0 = 14;
7879 dgst_pos1 = 15;
7880 dgst_pos2 = 6;
7881 dgst_pos3 = 7;
7882 break;
7883
7884 case 1740: hash_type = HASH_TYPE_SHA512;
7885 salt_type = SALT_TYPE_INTERN;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_BE
7888 | OPTS_TYPE_PT_ADD80
7889 | OPTS_TYPE_PT_ADDBITS15
7890 | OPTS_TYPE_PT_UNICODE;
7891 kern_type = KERN_TYPE_SHA512_SLTPWU;
7892 dgst_size = DGST_SIZE_8_8;
7893 parse_func = sha512s_parse_hash;
7894 sort_by_digest = sort_by_digest_8_8;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED
7900 | OPTI_TYPE_PREPENDED_SALT
7901 | OPTI_TYPE_USES_BITS_64
7902 | OPTI_TYPE_RAW_HASH;
7903 dgst_pos0 = 14;
7904 dgst_pos1 = 15;
7905 dgst_pos2 = 6;
7906 dgst_pos3 = 7;
7907 break;
7908
7909 case 1750: hash_type = HASH_TYPE_SHA512;
7910 salt_type = SALT_TYPE_INTERN;
7911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7912 opts_type = OPTS_TYPE_PT_GENERATE_BE
7913 | OPTS_TYPE_ST_ADD80;
7914 kern_type = KERN_TYPE_HMACSHA512_PW;
7915 dgst_size = DGST_SIZE_8_8;
7916 parse_func = hmacsha512_parse_hash;
7917 sort_by_digest = sort_by_digest_8_8;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_USES_BITS_64
7920 | OPTI_TYPE_NOT_ITERATED;
7921 dgst_pos0 = 14;
7922 dgst_pos1 = 15;
7923 dgst_pos2 = 6;
7924 dgst_pos3 = 7;
7925 break;
7926
7927 case 1760: hash_type = HASH_TYPE_SHA512;
7928 salt_type = SALT_TYPE_INTERN;
7929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_BE
7931 | OPTS_TYPE_PT_ADD80
7932 | OPTS_TYPE_PT_ADDBITS15;
7933 kern_type = KERN_TYPE_HMACSHA512_SLT;
7934 dgst_size = DGST_SIZE_8_8;
7935 parse_func = hmacsha512_parse_hash;
7936 sort_by_digest = sort_by_digest_8_8;
7937 opti_type = OPTI_TYPE_ZERO_BYTE
7938 | OPTI_TYPE_USES_BITS_64
7939 | OPTI_TYPE_NOT_ITERATED;
7940 dgst_pos0 = 14;
7941 dgst_pos1 = 15;
7942 dgst_pos2 = 6;
7943 dgst_pos3 = 7;
7944 break;
7945
7946 case 1800: hash_type = HASH_TYPE_SHA512;
7947 salt_type = SALT_TYPE_EMBEDDED;
7948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7950 kern_type = KERN_TYPE_SHA512CRYPT;
7951 dgst_size = DGST_SIZE_8_8;
7952 parse_func = sha512crypt_parse_hash;
7953 sort_by_digest = sort_by_digest_8_8;
7954 opti_type = OPTI_TYPE_ZERO_BYTE
7955 | OPTI_TYPE_USES_BITS_64;
7956 dgst_pos0 = 0;
7957 dgst_pos1 = 1;
7958 dgst_pos2 = 2;
7959 dgst_pos3 = 3;
7960 break;
7961
7962 case 2100: hash_type = HASH_TYPE_DCC2;
7963 salt_type = SALT_TYPE_EMBEDDED;
7964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7965 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7966 | OPTS_TYPE_ST_LOWER
7967 | OPTS_TYPE_ST_UNICODE;
7968 kern_type = KERN_TYPE_DCC2;
7969 dgst_size = DGST_SIZE_4_4;
7970 parse_func = dcc2_parse_hash;
7971 sort_by_digest = sort_by_digest_4_4;
7972 opti_type = OPTI_TYPE_ZERO_BYTE;
7973 dgst_pos0 = 0;
7974 dgst_pos1 = 1;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 3;
7977 break;
7978
7979 case 2400: hash_type = HASH_TYPE_MD5;
7980 salt_type = SALT_TYPE_NONE;
7981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7983 kern_type = KERN_TYPE_MD5PIX;
7984 dgst_size = DGST_SIZE_4_4;
7985 parse_func = md5pix_parse_hash;
7986 sort_by_digest = sort_by_digest_4_4;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_NOT_SALTED;
7993 dgst_pos0 = 0;
7994 dgst_pos1 = 3;
7995 dgst_pos2 = 2;
7996 dgst_pos3 = 1;
7997 break;
7998
7999 case 2410: hash_type = HASH_TYPE_MD5;
8000 salt_type = SALT_TYPE_INTERN;
8001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8003 kern_type = KERN_TYPE_MD5ASA;
8004 dgst_size = DGST_SIZE_4_4;
8005 parse_func = md5asa_parse_hash;
8006 sort_by_digest = sort_by_digest_4_4;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED;
8012 dgst_pos0 = 0;
8013 dgst_pos1 = 3;
8014 dgst_pos2 = 2;
8015 dgst_pos3 = 1;
8016 break;
8017
8018 case 2500: hash_type = HASH_TYPE_WPA;
8019 salt_type = SALT_TYPE_EMBEDDED;
8020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8022 kern_type = KERN_TYPE_WPA;
8023 dgst_size = DGST_SIZE_4_4;
8024 parse_func = wpa_parse_hash;
8025 sort_by_digest = sort_by_digest_4_4;
8026 opti_type = OPTI_TYPE_ZERO_BYTE;
8027 dgst_pos0 = 0;
8028 dgst_pos1 = 1;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 3;
8031 break;
8032
8033 case 2600: hash_type = HASH_TYPE_MD5;
8034 salt_type = SALT_TYPE_VIRTUAL;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_LE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS14
8039 | OPTS_TYPE_ST_ADD80;
8040 kern_type = KERN_TYPE_MD55_PWSLT1;
8041 dgst_size = DGST_SIZE_4_4;
8042 parse_func = md5md5_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 dgst_pos0 = 0;
8049 dgst_pos1 = 3;
8050 dgst_pos2 = 2;
8051 dgst_pos3 = 1;
8052 break;
8053
8054 case 2611: hash_type = HASH_TYPE_MD5;
8055 salt_type = SALT_TYPE_INTERN;
8056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8057 opts_type = OPTS_TYPE_PT_GENERATE_LE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS14
8060 | OPTS_TYPE_ST_ADD80;
8061 kern_type = KERN_TYPE_MD55_PWSLT1;
8062 dgst_size = DGST_SIZE_4_4;
8063 parse_func = vb3_parse_hash;
8064 sort_by_digest = sort_by_digest_4_4;
8065 opti_type = OPTI_TYPE_ZERO_BYTE
8066 | OPTI_TYPE_PRECOMPUTE_INIT
8067 | OPTI_TYPE_PRECOMPUTE_MERKLE
8068 | OPTI_TYPE_EARLY_SKIP;
8069 dgst_pos0 = 0;
8070 dgst_pos1 = 3;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 1;
8073 break;
8074
8075 case 2612: hash_type = HASH_TYPE_MD5;
8076 salt_type = SALT_TYPE_EMBEDDED;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE
8079 | OPTS_TYPE_PT_ADD80
8080 | OPTS_TYPE_PT_ADDBITS14
8081 | OPTS_TYPE_ST_ADD80
8082 | OPTS_TYPE_ST_HEX;
8083 kern_type = KERN_TYPE_MD55_PWSLT1;
8084 dgst_size = DGST_SIZE_4_4;
8085 parse_func = phps_parse_hash;
8086 sort_by_digest = sort_by_digest_4_4;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP;
8091 dgst_pos0 = 0;
8092 dgst_pos1 = 3;
8093 dgst_pos2 = 2;
8094 dgst_pos3 = 1;
8095 break;
8096
8097 case 2711: hash_type = HASH_TYPE_MD5;
8098 salt_type = SALT_TYPE_INTERN;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_LE
8101 | OPTS_TYPE_PT_ADD80
8102 | OPTS_TYPE_PT_ADDBITS14
8103 | OPTS_TYPE_ST_ADD80;
8104 kern_type = KERN_TYPE_MD55_PWSLT2;
8105 dgst_size = DGST_SIZE_4_4;
8106 parse_func = vb30_parse_hash;
8107 sort_by_digest = sort_by_digest_4_4;
8108 opti_type = OPTI_TYPE_ZERO_BYTE
8109 | OPTI_TYPE_PRECOMPUTE_INIT
8110 | OPTI_TYPE_EARLY_SKIP;
8111 dgst_pos0 = 0;
8112 dgst_pos1 = 3;
8113 dgst_pos2 = 2;
8114 dgst_pos3 = 1;
8115 break;
8116
8117 case 2811: hash_type = HASH_TYPE_MD5;
8118 salt_type = SALT_TYPE_INTERN;
8119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8120 opts_type = OPTS_TYPE_PT_GENERATE_LE
8121 | OPTS_TYPE_PT_ADD80
8122 | OPTS_TYPE_PT_ADDBITS14;
8123 kern_type = KERN_TYPE_MD55_SLTPW;
8124 dgst_size = DGST_SIZE_4_4;
8125 parse_func = ipb2_parse_hash;
8126 sort_by_digest = sort_by_digest_4_4;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_PRECOMPUTE_INIT
8129 | OPTI_TYPE_EARLY_SKIP;
8130 dgst_pos0 = 0;
8131 dgst_pos1 = 3;
8132 dgst_pos2 = 2;
8133 dgst_pos3 = 1;
8134 break;
8135
8136 case 3000: hash_type = HASH_TYPE_LM;
8137 salt_type = SALT_TYPE_NONE;
8138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8139 opts_type = OPTS_TYPE_PT_GENERATE_LE
8140 | OPTS_TYPE_PT_UPPER
8141 | OPTS_TYPE_PT_BITSLICE;
8142 kern_type = KERN_TYPE_LM;
8143 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8144 parse_func = lm_parse_hash;
8145 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8146 opti_type = OPTI_TYPE_ZERO_BYTE
8147 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8148 dgst_pos0 = 0;
8149 dgst_pos1 = 1;
8150 dgst_pos2 = 2;
8151 dgst_pos3 = 3;
8152 break;
8153
8154 case 3100: hash_type = HASH_TYPE_ORACLEH;
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_UPPER
8159 | OPTS_TYPE_ST_UPPER;
8160 kern_type = KERN_TYPE_ORACLEH;
8161 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8162 parse_func = oracleh_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8164 opti_type = OPTI_TYPE_ZERO_BYTE;
8165 dgst_pos0 = 0;
8166 dgst_pos1 = 1;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 3;
8169 break;
8170
8171 case 3200: hash_type = HASH_TYPE_BCRYPT;
8172 salt_type = SALT_TYPE_EMBEDDED;
8173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_LE
8175 | OPTS_TYPE_ST_GENERATE_LE;
8176 kern_type = KERN_TYPE_BCRYPT;
8177 dgst_size = DGST_SIZE_4_6;
8178 parse_func = bcrypt_parse_hash;
8179 sort_by_digest = sort_by_digest_4_6;
8180 opti_type = OPTI_TYPE_ZERO_BYTE;
8181 dgst_pos0 = 0;
8182 dgst_pos1 = 1;
8183 dgst_pos2 = 2;
8184 dgst_pos3 = 3;
8185 break;
8186
8187 case 3710: hash_type = HASH_TYPE_MD5;
8188 salt_type = SALT_TYPE_INTERN;
8189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8190 opts_type = OPTS_TYPE_PT_GENERATE_LE
8191 | OPTS_TYPE_PT_ADD80
8192 | OPTS_TYPE_PT_ADDBITS14;
8193 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8194 dgst_size = DGST_SIZE_4_4;
8195 parse_func = md5s_parse_hash;
8196 sort_by_digest = sort_by_digest_4_4;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_PRECOMPUTE_INIT
8199 | OPTI_TYPE_PRECOMPUTE_MERKLE
8200 | OPTI_TYPE_EARLY_SKIP;
8201 dgst_pos0 = 0;
8202 dgst_pos1 = 3;
8203 dgst_pos2 = 2;
8204 dgst_pos3 = 1;
8205 break;
8206
8207 case 3711: hash_type = HASH_TYPE_MD5;
8208 salt_type = SALT_TYPE_EMBEDDED;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_LE
8211 | OPTS_TYPE_PT_ADD80
8212 | OPTS_TYPE_PT_ADDBITS14;
8213 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8214 dgst_size = DGST_SIZE_4_4;
8215 parse_func = mediawiki_b_parse_hash;
8216 sort_by_digest = sort_by_digest_4_4;
8217 opti_type = OPTI_TYPE_ZERO_BYTE
8218 | OPTI_TYPE_PRECOMPUTE_INIT
8219 | OPTI_TYPE_PRECOMPUTE_MERKLE
8220 | OPTI_TYPE_EARLY_SKIP;
8221 dgst_pos0 = 0;
8222 dgst_pos1 = 3;
8223 dgst_pos2 = 2;
8224 dgst_pos3 = 1;
8225 break;
8226
8227 case 3800: hash_type = HASH_TYPE_MD5;
8228 salt_type = SALT_TYPE_INTERN;
8229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8230 opts_type = OPTS_TYPE_PT_GENERATE_LE
8231 | OPTS_TYPE_ST_ADDBITS14;
8232 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = md5s_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP
8240 | OPTI_TYPE_NOT_ITERATED
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 1;
8246 break;
8247
8248 case 4300: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_VIRTUAL;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14
8254 | OPTS_TYPE_ST_ADD80;
8255 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8256 dgst_size = DGST_SIZE_4_4;
8257 parse_func = md5md5_parse_hash;
8258 sort_by_digest = sort_by_digest_4_4;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP;
8263 dgst_pos0 = 0;
8264 dgst_pos1 = 3;
8265 dgst_pos2 = 2;
8266 dgst_pos3 = 1;
8267 break;
8268
8269
8270 case 4400: hash_type = HASH_TYPE_MD5;
8271 salt_type = SALT_TYPE_NONE;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_BE
8274 | OPTS_TYPE_PT_ADD80
8275 | OPTS_TYPE_PT_ADDBITS15;
8276 kern_type = KERN_TYPE_MD5_SHA1;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = md5_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_PRECOMPUTE_MERKLE
8283 | OPTI_TYPE_EARLY_SKIP
8284 | OPTI_TYPE_NOT_ITERATED
8285 | OPTI_TYPE_NOT_SALTED
8286 | OPTI_TYPE_RAW_HASH;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 3;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 1;
8291 break;
8292
8293 case 4500: hash_type = HASH_TYPE_SHA1;
8294 salt_type = SALT_TYPE_NONE;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_BE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS15;
8299 kern_type = KERN_TYPE_SHA11;
8300 dgst_size = DGST_SIZE_4_5;
8301 parse_func = sha1_parse_hash;
8302 sort_by_digest = sort_by_digest_4_5;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_EARLY_SKIP
8307 | OPTI_TYPE_NOT_SALTED;
8308 dgst_pos0 = 3;
8309 dgst_pos1 = 4;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 1;
8312 break;
8313
8314 case 4700: hash_type = HASH_TYPE_SHA1;
8315 salt_type = SALT_TYPE_NONE;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14;
8320 kern_type = KERN_TYPE_SHA1_MD5;
8321 dgst_size = DGST_SIZE_4_5;
8322 parse_func = sha1_parse_hash;
8323 sort_by_digest = sort_by_digest_4_5;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED
8329 | OPTI_TYPE_NOT_SALTED
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 3;
8332 dgst_pos1 = 4;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 1;
8335 break;
8336
8337 case 4800: hash_type = HASH_TYPE_MD5;
8338 salt_type = SALT_TYPE_EMBEDDED;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_LE
8341 | OPTS_TYPE_PT_ADDBITS14;
8342 kern_type = KERN_TYPE_MD5_CHAP;
8343 dgst_size = DGST_SIZE_4_4;
8344 parse_func = chap_parse_hash;
8345 sort_by_digest = sort_by_digest_4_4;
8346 opti_type = OPTI_TYPE_ZERO_BYTE
8347 | OPTI_TYPE_PRECOMPUTE_INIT
8348 | OPTI_TYPE_PRECOMPUTE_MERKLE
8349 | OPTI_TYPE_MEET_IN_MIDDLE
8350 | OPTI_TYPE_EARLY_SKIP
8351 | OPTI_TYPE_NOT_ITERATED
8352 | OPTI_TYPE_RAW_HASH;
8353 dgst_pos0 = 0;
8354 dgst_pos1 = 3;
8355 dgst_pos2 = 2;
8356 dgst_pos3 = 1;
8357 break;
8358
8359 case 4900: hash_type = HASH_TYPE_SHA1;
8360 salt_type = SALT_TYPE_INTERN;
8361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8363 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8364 dgst_size = DGST_SIZE_4_5;
8365 parse_func = sha1s_parse_hash;
8366 sort_by_digest = sort_by_digest_4_5;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP;
8371 dgst_pos0 = 3;
8372 dgst_pos1 = 4;
8373 dgst_pos2 = 2;
8374 dgst_pos3 = 1;
8375 break;
8376
8377 case 5000: hash_type = HASH_TYPE_KECCAK;
8378 salt_type = SALT_TYPE_EMBEDDED;
8379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE
8381 | OPTS_TYPE_PT_ADD01;
8382 kern_type = KERN_TYPE_KECCAK;
8383 dgst_size = DGST_SIZE_8_25;
8384 parse_func = keccak_parse_hash;
8385 sort_by_digest = sort_by_digest_8_25;
8386 opti_type = OPTI_TYPE_ZERO_BYTE
8387 | OPTI_TYPE_USES_BITS_64
8388 | OPTI_TYPE_RAW_HASH;
8389 dgst_pos0 = 2;
8390 dgst_pos1 = 3;
8391 dgst_pos2 = 4;
8392 dgst_pos3 = 5;
8393 break;
8394
8395 case 5100: hash_type = HASH_TYPE_MD5H;
8396 salt_type = SALT_TYPE_NONE;
8397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8398 opts_type = OPTS_TYPE_PT_GENERATE_LE
8399 | OPTS_TYPE_PT_ADD80
8400 | OPTS_TYPE_PT_ADDBITS14;
8401 kern_type = KERN_TYPE_MD5H;
8402 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8403 parse_func = md5half_parse_hash;
8404 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8405 opti_type = OPTI_TYPE_ZERO_BYTE
8406 | OPTI_TYPE_RAW_HASH;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 1;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 3;
8411 break;
8412
8413 case 5200: hash_type = HASH_TYPE_SHA256;
8414 salt_type = SALT_TYPE_EMBEDDED;
8415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8417 kern_type = KERN_TYPE_PSAFE3;
8418 dgst_size = DGST_SIZE_4_8;
8419 parse_func = psafe3_parse_hash;
8420 sort_by_digest = sort_by_digest_4_8;
8421 opti_type = OPTI_TYPE_ZERO_BYTE;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 5300: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_EMBEDDED;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_ST_ADD80;
8433 kern_type = KERN_TYPE_IKEPSK_MD5;
8434 dgst_size = DGST_SIZE_4_4;
8435 parse_func = ikepsk_md5_parse_hash;
8436 sort_by_digest = sort_by_digest_4_4;
8437 opti_type = OPTI_TYPE_ZERO_BYTE;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 5400: hash_type = HASH_TYPE_SHA1;
8445 salt_type = SALT_TYPE_EMBEDDED;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_BE
8448 | OPTS_TYPE_ST_ADD80;
8449 kern_type = KERN_TYPE_IKEPSK_SHA1;
8450 dgst_size = DGST_SIZE_4_5;
8451 parse_func = ikepsk_sha1_parse_hash;
8452 sort_by_digest = sort_by_digest_4_5;
8453 opti_type = OPTI_TYPE_ZERO_BYTE;
8454 dgst_pos0 = 3;
8455 dgst_pos1 = 4;
8456 dgst_pos2 = 2;
8457 dgst_pos3 = 1;
8458 break;
8459
8460 case 5500: hash_type = HASH_TYPE_NETNTLM;
8461 salt_type = SALT_TYPE_EMBEDDED;
8462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8463 opts_type = OPTS_TYPE_PT_GENERATE_LE
8464 | OPTS_TYPE_PT_ADD80
8465 | OPTS_TYPE_PT_ADDBITS14
8466 | OPTS_TYPE_PT_UNICODE
8467 | OPTS_TYPE_ST_HEX;
8468 kern_type = KERN_TYPE_NETNTLMv1;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = netntlmv1_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 1;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 3;
8478 break;
8479
8480 case 5600: hash_type = HASH_TYPE_MD5;
8481 salt_type = SALT_TYPE_EMBEDDED;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_LE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS14
8486 | OPTS_TYPE_PT_UNICODE;
8487 kern_type = KERN_TYPE_NETNTLMv2;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = netntlmv2_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE;
8492 dgst_pos0 = 0;
8493 dgst_pos1 = 3;
8494 dgst_pos2 = 2;
8495 dgst_pos3 = 1;
8496 break;
8497
8498 case 5700: hash_type = HASH_TYPE_SHA256;
8499 salt_type = SALT_TYPE_NONE;
8500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8501 opts_type = OPTS_TYPE_PT_GENERATE_BE
8502 | OPTS_TYPE_PT_ADD80
8503 | OPTS_TYPE_PT_ADDBITS15;
8504 kern_type = KERN_TYPE_SHA256;
8505 dgst_size = DGST_SIZE_4_8;
8506 parse_func = cisco4_parse_hash;
8507 sort_by_digest = sort_by_digest_4_8;
8508 opti_type = OPTI_TYPE_ZERO_BYTE
8509 | OPTI_TYPE_PRECOMPUTE_INIT
8510 | OPTI_TYPE_PRECOMPUTE_MERKLE
8511 | OPTI_TYPE_EARLY_SKIP
8512 | OPTI_TYPE_NOT_ITERATED
8513 | OPTI_TYPE_NOT_SALTED
8514 | OPTI_TYPE_RAW_HASH;
8515 dgst_pos0 = 3;
8516 dgst_pos1 = 7;
8517 dgst_pos2 = 2;
8518 dgst_pos3 = 6;
8519 break;
8520
8521 case 5800: hash_type = HASH_TYPE_SHA1;
8522 salt_type = SALT_TYPE_INTERN;
8523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8524 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8525 | OPTS_TYPE_ST_ADD80;
8526 kern_type = KERN_TYPE_ANDROIDPIN;
8527 dgst_size = DGST_SIZE_4_5;
8528 parse_func = androidpin_parse_hash;
8529 sort_by_digest = sort_by_digest_4_5;
8530 opti_type = OPTI_TYPE_ZERO_BYTE;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 1;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 3;
8535 break;
8536
8537 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8538 salt_type = SALT_TYPE_NONE;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_LE
8541 | OPTS_TYPE_PT_ADD80;
8542 kern_type = KERN_TYPE_RIPEMD160;
8543 dgst_size = DGST_SIZE_4_5;
8544 parse_func = ripemd160_parse_hash;
8545 sort_by_digest = sort_by_digest_4_5;
8546 opti_type = OPTI_TYPE_ZERO_BYTE;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 1;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 3;
8551 break;
8552
8553 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8554 salt_type = SALT_TYPE_NONE;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_PT_ADD80;
8558 kern_type = KERN_TYPE_WHIRLPOOL;
8559 dgst_size = DGST_SIZE_4_16;
8560 parse_func = whirlpool_parse_hash;
8561 sort_by_digest = sort_by_digest_4_16;
8562 opti_type = OPTI_TYPE_ZERO_BYTE;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 1;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 3;
8567 break;
8568
8569 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8570 salt_type = SALT_TYPE_EMBEDDED;
8571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8573 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8574 dgst_size = DGST_SIZE_4_5;
8575 parse_func = truecrypt_parse_hash_2k;
8576 sort_by_digest = sort_by_digest_4_5;
8577 opti_type = OPTI_TYPE_ZERO_BYTE;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8585 salt_type = SALT_TYPE_EMBEDDED;
8586 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8588 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8589 dgst_size = DGST_SIZE_4_5;
8590 parse_func = truecrypt_parse_hash_2k;
8591 sort_by_digest = sort_by_digest_4_5;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8603 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8604 dgst_size = DGST_SIZE_4_5;
8605 parse_func = truecrypt_parse_hash_2k;
8606 sort_by_digest = sort_by_digest_4_5;
8607 opti_type = OPTI_TYPE_ZERO_BYTE;
8608 dgst_pos0 = 0;
8609 dgst_pos1 = 1;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 3;
8612 break;
8613
8614 case 6221: hash_type = HASH_TYPE_SHA512;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8618 kern_type = KERN_TYPE_TCSHA512_XTS512;
8619 dgst_size = DGST_SIZE_8_8;
8620 parse_func = truecrypt_parse_hash_1k;
8621 sort_by_digest = sort_by_digest_8_8;
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_USES_BITS_64;
8624 dgst_pos0 = 0;
8625 dgst_pos1 = 1;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 3;
8628 break;
8629
8630 case 6222: hash_type = HASH_TYPE_SHA512;
8631 salt_type = SALT_TYPE_EMBEDDED;
8632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8634 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8635 dgst_size = DGST_SIZE_8_8;
8636 parse_func = truecrypt_parse_hash_1k;
8637 sort_by_digest = sort_by_digest_8_8;
8638 opti_type = OPTI_TYPE_ZERO_BYTE
8639 | OPTI_TYPE_USES_BITS_64;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 1;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 3;
8644 break;
8645
8646 case 6223: hash_type = HASH_TYPE_SHA512;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8650 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8651 dgst_size = DGST_SIZE_8_8;
8652 parse_func = truecrypt_parse_hash_1k;
8653 sort_by_digest = sort_by_digest_8_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_USES_BITS_64;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8666 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8667 dgst_size = DGST_SIZE_4_8;
8668 parse_func = truecrypt_parse_hash_1k;
8669 sort_by_digest = sort_by_digest_4_8;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8682 dgst_size = DGST_SIZE_4_8;
8683 parse_func = truecrypt_parse_hash_1k;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8696 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8697 dgst_size = DGST_SIZE_4_8;
8698 parse_func = truecrypt_parse_hash_1k;
8699 sort_by_digest = sort_by_digest_4_8;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8711 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8712 dgst_size = DGST_SIZE_4_5;
8713 parse_func = truecrypt_parse_hash_1k;
8714 sort_by_digest = sort_by_digest_4_5;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8726 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8727 dgst_size = DGST_SIZE_4_5;
8728 parse_func = truecrypt_parse_hash_1k;
8729 sort_by_digest = sort_by_digest_4_5;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8741 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8742 dgst_size = DGST_SIZE_4_5;
8743 parse_func = truecrypt_parse_hash_1k;
8744 sort_by_digest = sort_by_digest_4_5;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6300: hash_type = HASH_TYPE_MD5;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8756 kern_type = KERN_TYPE_MD5AIX;
8757 dgst_size = DGST_SIZE_4_4;
8758 parse_func = md5aix_parse_hash;
8759 sort_by_digest = sort_by_digest_4_4;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6400: hash_type = HASH_TYPE_SHA256;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8771 kern_type = KERN_TYPE_SHA256AIX;
8772 dgst_size = DGST_SIZE_4_8;
8773 parse_func = sha256aix_parse_hash;
8774 sort_by_digest = sort_by_digest_4_8;
8775 opti_type = OPTI_TYPE_ZERO_BYTE;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6500: hash_type = HASH_TYPE_SHA512;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8786 kern_type = KERN_TYPE_SHA512AIX;
8787 dgst_size = DGST_SIZE_8_8;
8788 parse_func = sha512aix_parse_hash;
8789 sort_by_digest = sort_by_digest_8_8;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_USES_BITS_64;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6600: hash_type = HASH_TYPE_AES;
8799 salt_type = SALT_TYPE_EMBEDDED;
8800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_AGILEKEY;
8803 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8804 parse_func = agilekey_parse_hash;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6700: hash_type = HASH_TYPE_SHA1;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8817 kern_type = KERN_TYPE_SHA1AIX;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = sha1aix_parse_hash;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6800: hash_type = HASH_TYPE_AES;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_LASTPASS;
8833 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8834 parse_func = lastpass_parse_hash;
8835 sort_by_digest = sort_by_digest_4_8;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6900: hash_type = HASH_TYPE_GOST;
8844 salt_type = SALT_TYPE_NONE;
8845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_GOST;
8848 dgst_size = DGST_SIZE_4_8;
8849 parse_func = gost_parse_hash;
8850 sort_by_digest = sort_by_digest_4_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 7100: hash_type = HASH_TYPE_SHA512;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_PBKDF2_SHA512;
8863 dgst_size = DGST_SIZE_8_16;
8864 parse_func = sha512osx_parse_hash;
8865 sort_by_digest = sort_by_digest_8_16;
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_USES_BITS_64;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 7200: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_PBKDF2_SHA512;
8879 dgst_size = DGST_SIZE_8_16;
8880 parse_func = sha512grub_parse_hash;
8881 sort_by_digest = sort_by_digest_8_16;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 7300: hash_type = HASH_TYPE_SHA1;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_BE
8894 | OPTS_TYPE_ST_ADD80
8895 | OPTS_TYPE_ST_ADDBITS15;
8896 kern_type = KERN_TYPE_RAKP;
8897 dgst_size = DGST_SIZE_4_5;
8898 parse_func = rakp_parse_hash;
8899 sort_by_digest = sort_by_digest_4_5;
8900 opti_type = OPTI_TYPE_ZERO_BYTE
8901 | OPTI_TYPE_NOT_ITERATED;
8902 dgst_pos0 = 3;
8903 dgst_pos1 = 4;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 1;
8906 break;
8907
8908 case 7400: hash_type = HASH_TYPE_SHA256;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8912 kern_type = KERN_TYPE_SHA256CRYPT;
8913 dgst_size = DGST_SIZE_4_8;
8914 parse_func = sha256crypt_parse_hash;
8915 sort_by_digest = sort_by_digest_4_8;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 7500: hash_type = HASH_TYPE_KRB5PA;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8927 kern_type = KERN_TYPE_KRB5PA;
8928 dgst_size = DGST_SIZE_4_4;
8929 parse_func = krb5pa_parse_hash;
8930 sort_by_digest = sort_by_digest_4_4;
8931 opti_type = OPTI_TYPE_ZERO_BYTE
8932 | OPTI_TYPE_NOT_ITERATED;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 7600: hash_type = HASH_TYPE_SHA1;
8940 salt_type = SALT_TYPE_INTERN;
8941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_BE
8943 | OPTS_TYPE_PT_ADD80
8944 | OPTS_TYPE_PT_ADDBITS15;
8945 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8946 dgst_size = DGST_SIZE_4_5;
8947 parse_func = redmine_parse_hash;
8948 sort_by_digest = sort_by_digest_4_5;
8949 opti_type = OPTI_TYPE_ZERO_BYTE
8950 | OPTI_TYPE_PRECOMPUTE_INIT
8951 | OPTI_TYPE_EARLY_SKIP
8952 | OPTI_TYPE_NOT_ITERATED
8953 | OPTI_TYPE_PREPENDED_SALT;
8954 dgst_pos0 = 3;
8955 dgst_pos1 = 4;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 1;
8958 break;
8959
8960 case 7700: hash_type = HASH_TYPE_SAPB;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE
8964 | OPTS_TYPE_PT_UPPER
8965 | OPTS_TYPE_ST_UPPER;
8966 kern_type = KERN_TYPE_SAPB;
8967 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8968 parse_func = sapb_parse_hash;
8969 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8970 opti_type = OPTI_TYPE_ZERO_BYTE
8971 | OPTI_TYPE_PRECOMPUTE_INIT
8972 | OPTI_TYPE_NOT_ITERATED;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 7800: hash_type = HASH_TYPE_SAPG;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_BE
8983 | OPTS_TYPE_ST_ADD80
8984 | OPTS_TYPE_ST_UPPER;
8985 kern_type = KERN_TYPE_SAPG;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = sapg_parse_hash;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE
8990 | OPTI_TYPE_PRECOMPUTE_INIT
8991 | OPTI_TYPE_NOT_ITERATED;
8992 dgst_pos0 = 3;
8993 dgst_pos1 = 4;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 1;
8996 break;
8997
8998 case 7900: hash_type = HASH_TYPE_SHA512;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9002 kern_type = KERN_TYPE_DRUPAL7;
9003 dgst_size = DGST_SIZE_8_8;
9004 parse_func = drupal7_parse_hash;
9005 sort_by_digest = sort_by_digest_8_8;
9006 opti_type = OPTI_TYPE_ZERO_BYTE
9007 | OPTI_TYPE_USES_BITS_64;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 8000: hash_type = HASH_TYPE_SHA256;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_BE
9018 | OPTS_TYPE_PT_UNICODE
9019 | OPTS_TYPE_ST_ADD80
9020 | OPTS_TYPE_ST_HEX;
9021 kern_type = KERN_TYPE_SYBASEASE;
9022 dgst_size = DGST_SIZE_4_8;
9023 parse_func = sybasease_parse_hash;
9024 sort_by_digest = sort_by_digest_4_8;
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_PRECOMPUTE_INIT
9027 | OPTI_TYPE_EARLY_SKIP
9028 | OPTI_TYPE_NOT_ITERATED
9029 | OPTI_TYPE_RAW_HASH;
9030 dgst_pos0 = 3;
9031 dgst_pos1 = 7;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 6;
9034 break;
9035
9036 case 8100: hash_type = HASH_TYPE_SHA1;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9040 kern_type = KERN_TYPE_NETSCALER;
9041 dgst_size = DGST_SIZE_4_5;
9042 parse_func = netscaler_parse_hash;
9043 sort_by_digest = sort_by_digest_4_5;
9044 opti_type = OPTI_TYPE_ZERO_BYTE
9045 | OPTI_TYPE_PRECOMPUTE_INIT
9046 | OPTI_TYPE_PRECOMPUTE_MERKLE
9047 | OPTI_TYPE_EARLY_SKIP
9048 | OPTI_TYPE_NOT_ITERATED
9049 | OPTI_TYPE_PREPENDED_SALT
9050 | OPTI_TYPE_RAW_HASH;
9051 dgst_pos0 = 3;
9052 dgst_pos1 = 4;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 1;
9055 break;
9056
9057 case 8200: hash_type = HASH_TYPE_SHA256;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_CLOUDKEY;
9062 dgst_size = DGST_SIZE_4_8;
9063 parse_func = cloudkey_parse_hash;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 8300: hash_type = HASH_TYPE_SHA1;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE
9076 | OPTS_TYPE_ST_HEX
9077 | OPTS_TYPE_ST_ADD80;
9078 kern_type = KERN_TYPE_NSEC3;
9079 dgst_size = DGST_SIZE_4_5;
9080 parse_func = nsec3_parse_hash;
9081 sort_by_digest = sort_by_digest_4_5;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 3;
9084 dgst_pos1 = 4;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 1;
9087 break;
9088
9089 case 8400: hash_type = HASH_TYPE_SHA1;
9090 salt_type = SALT_TYPE_INTERN;
9091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_BE
9093 | OPTS_TYPE_PT_ADD80
9094 | OPTS_TYPE_PT_ADDBITS15;
9095 kern_type = KERN_TYPE_WBB3;
9096 dgst_size = DGST_SIZE_4_5;
9097 parse_func = wbb3_parse_hash;
9098 sort_by_digest = sort_by_digest_4_5;
9099 opti_type = OPTI_TYPE_ZERO_BYTE
9100 | OPTI_TYPE_PRECOMPUTE_INIT
9101 | OPTI_TYPE_NOT_ITERATED;
9102 dgst_pos0 = 3;
9103 dgst_pos1 = 4;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 1;
9106 break;
9107
9108 case 8500: hash_type = HASH_TYPE_DESRACF;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE
9112 | OPTS_TYPE_ST_UPPER;
9113 kern_type = KERN_TYPE_RACF;
9114 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9115 parse_func = racf_parse_hash;
9116 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9117 opti_type = OPTI_TYPE_ZERO_BYTE
9118 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 8600: hash_type = HASH_TYPE_LOTUS5;
9126 salt_type = SALT_TYPE_NONE;
9127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9129 kern_type = KERN_TYPE_LOTUS5;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = lotus5_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_EARLY_SKIP
9134 | OPTI_TYPE_NOT_ITERATED
9135 | OPTI_TYPE_NOT_SALTED
9136 | OPTI_TYPE_RAW_HASH;
9137 dgst_pos0 = 0;
9138 dgst_pos1 = 1;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 3;
9141 break;
9142
9143 case 8700: hash_type = HASH_TYPE_LOTUS6;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9147 kern_type = KERN_TYPE_LOTUS6;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = lotus6_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_EARLY_SKIP
9152 | OPTI_TYPE_NOT_ITERATED
9153 | OPTI_TYPE_RAW_HASH;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9164 kern_type = KERN_TYPE_ANDROIDFDE;
9165 dgst_size = DGST_SIZE_4_4;
9166 parse_func = androidfde_parse_hash;
9167 sort_by_digest = sort_by_digest_4_4;
9168 opti_type = OPTI_TYPE_ZERO_BYTE;
9169 dgst_pos0 = 0;
9170 dgst_pos1 = 1;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 3;
9173 break;
9174
9175 case 8900: hash_type = HASH_TYPE_SCRYPT;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9179 kern_type = KERN_TYPE_SCRYPT;
9180 dgst_size = DGST_SIZE_4_8;
9181 parse_func = scrypt_parse_hash;
9182 sort_by_digest = sort_by_digest_4_8;
9183 opti_type = OPTI_TYPE_ZERO_BYTE;
9184 dgst_pos0 = 0;
9185 dgst_pos1 = 1;
9186 dgst_pos2 = 2;
9187 dgst_pos3 = 3;
9188 break;
9189
9190 case 9000: hash_type = HASH_TYPE_SHA1;
9191 salt_type = SALT_TYPE_EMBEDDED;
9192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9193 opts_type = OPTS_TYPE_PT_GENERATE_LE
9194 | OPTS_TYPE_ST_GENERATE_LE;
9195 kern_type = KERN_TYPE_PSAFE2;
9196 dgst_size = DGST_SIZE_4_5;
9197 parse_func = psafe2_parse_hash;
9198 sort_by_digest = sort_by_digest_4_5;
9199 opti_type = OPTI_TYPE_ZERO_BYTE;
9200 dgst_pos0 = 0;
9201 dgst_pos1 = 1;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 3;
9204 break;
9205
9206 case 9100: hash_type = HASH_TYPE_LOTUS8;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9210 kern_type = KERN_TYPE_LOTUS8;
9211 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9212 parse_func = lotus8_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9214 opti_type = OPTI_TYPE_ZERO_BYTE;
9215 dgst_pos0 = 0;
9216 dgst_pos1 = 1;
9217 dgst_pos2 = 2;
9218 dgst_pos3 = 3;
9219 break;
9220
9221 case 9200: hash_type = HASH_TYPE_SHA256;
9222 salt_type = SALT_TYPE_EMBEDDED;
9223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9224 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9225 kern_type = KERN_TYPE_PBKDF2_SHA256;
9226 dgst_size = DGST_SIZE_4_32;
9227 parse_func = cisco8_parse_hash;
9228 sort_by_digest = sort_by_digest_4_32;
9229 opti_type = OPTI_TYPE_ZERO_BYTE;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 9300: hash_type = HASH_TYPE_SCRYPT;
9237 salt_type = SALT_TYPE_EMBEDDED;
9238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9240 kern_type = KERN_TYPE_SCRYPT;
9241 dgst_size = DGST_SIZE_4_8;
9242 parse_func = cisco9_parse_hash;
9243 sort_by_digest = sort_by_digest_4_8;
9244 opti_type = OPTI_TYPE_ZERO_BYTE;
9245 dgst_pos0 = 0;
9246 dgst_pos1 = 1;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 3;
9249 break;
9250
9251 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9255 kern_type = KERN_TYPE_OFFICE2007;
9256 dgst_size = DGST_SIZE_4_4;
9257 parse_func = office2007_parse_hash;
9258 sort_by_digest = sort_by_digest_4_4;
9259 opti_type = OPTI_TYPE_ZERO_BYTE;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9270 kern_type = KERN_TYPE_OFFICE2010;
9271 dgst_size = DGST_SIZE_4_4;
9272 parse_func = office2010_parse_hash;
9273 sort_by_digest = sort_by_digest_4_4;
9274 opti_type = OPTI_TYPE_ZERO_BYTE;
9275 dgst_pos0 = 0;
9276 dgst_pos1 = 1;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 3;
9279 break;
9280
9281 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9285 kern_type = KERN_TYPE_OFFICE2013;
9286 dgst_size = DGST_SIZE_4_4;
9287 parse_func = office2013_parse_hash;
9288 sort_by_digest = sort_by_digest_4_4;
9289 opti_type = OPTI_TYPE_ZERO_BYTE;
9290 dgst_pos0 = 0;
9291 dgst_pos1 = 1;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 3;
9294 break;
9295
9296 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE
9300 | OPTS_TYPE_PT_ADD80
9301 | OPTS_TYPE_PT_UNICODE;
9302 kern_type = KERN_TYPE_OLDOFFICE01;
9303 dgst_size = DGST_SIZE_4_4;
9304 parse_func = oldoffice01_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4;
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_PRECOMPUTE_INIT
9308 | OPTI_TYPE_NOT_ITERATED;
9309 dgst_pos0 = 0;
9310 dgst_pos1 = 1;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 3;
9313 break;
9314
9315 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9316 salt_type = SALT_TYPE_EMBEDDED;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_LE
9319 | OPTS_TYPE_PT_ADD80;
9320 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9321 dgst_size = DGST_SIZE_4_4;
9322 parse_func = oldoffice01cm1_parse_hash;
9323 sort_by_digest = sort_by_digest_4_4;
9324 opti_type = OPTI_TYPE_ZERO_BYTE
9325 | OPTI_TYPE_PRECOMPUTE_INIT
9326 | OPTI_TYPE_NOT_ITERATED;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 9720: 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 | OPTS_TYPE_PT_NEVERCRACK;
9340 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9341 dgst_size = DGST_SIZE_4_4;
9342 parse_func = oldoffice01cm2_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4;
9344 opti_type = OPTI_TYPE_ZERO_BYTE
9345 | OPTI_TYPE_PRECOMPUTE_INIT
9346 | OPTI_TYPE_NOT_ITERATED;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_BE
9357 | OPTS_TYPE_PT_ADD80
9358 | OPTS_TYPE_PT_UNICODE;
9359 kern_type = KERN_TYPE_OLDOFFICE34;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = oldoffice34_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_PRECOMPUTE_INIT
9365 | OPTI_TYPE_NOT_ITERATED;
9366 dgst_pos0 = 0;
9367 dgst_pos1 = 1;
9368 dgst_pos2 = 2;
9369 dgst_pos3 = 3;
9370 break;
9371
9372 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9373 salt_type = SALT_TYPE_EMBEDDED;
9374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9375 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9376 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9377 dgst_size = DGST_SIZE_4_4;
9378 parse_func = oldoffice34cm1_parse_hash;
9379 sort_by_digest = sort_by_digest_4_4;
9380 opti_type = OPTI_TYPE_ZERO_BYTE
9381 | OPTI_TYPE_PRECOMPUTE_INIT
9382 | OPTI_TYPE_NOT_ITERATED;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_BE
9393 | OPTS_TYPE_PT_ADD80
9394 | OPTS_TYPE_PT_UNICODE
9395 | OPTS_TYPE_PT_NEVERCRACK;
9396 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9397 dgst_size = DGST_SIZE_4_4;
9398 parse_func = oldoffice34cm2_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 9900: hash_type = HASH_TYPE_MD5;
9410 salt_type = SALT_TYPE_NONE;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_RADMIN2;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = radmin2_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_EARLY_SKIP
9420 | OPTI_TYPE_NOT_ITERATED
9421 | OPTI_TYPE_NOT_SALTED;
9422 dgst_pos0 = 0;
9423 dgst_pos1 = 3;
9424 dgst_pos2 = 2;
9425 dgst_pos3 = 1;
9426 break;
9427
9428 case 10000: hash_type = HASH_TYPE_SHA256;
9429 salt_type = SALT_TYPE_EMBEDDED;
9430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9431 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9432 kern_type = KERN_TYPE_PBKDF2_SHA256;
9433 dgst_size = DGST_SIZE_4_32;
9434 parse_func = djangopbkdf2_parse_hash;
9435 sort_by_digest = sort_by_digest_4_32;
9436 opti_type = OPTI_TYPE_ZERO_BYTE;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 10100: hash_type = HASH_TYPE_SIPHASH;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9447 kern_type = KERN_TYPE_SIPHASH;
9448 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9449 parse_func = siphash_parse_hash;
9450 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9451 opti_type = OPTI_TYPE_ZERO_BYTE
9452 | OPTI_TYPE_NOT_ITERATED
9453 | OPTI_TYPE_RAW_HASH;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 1;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 3;
9458 break;
9459
9460 case 10200: hash_type = HASH_TYPE_MD5;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE
9464 | OPTS_TYPE_ST_ADD80
9465 | OPTS_TYPE_ST_ADDBITS14;
9466 kern_type = KERN_TYPE_HMACMD5_PW;
9467 dgst_size = DGST_SIZE_4_4;
9468 parse_func = crammd5_parse_hash;
9469 sort_by_digest = sort_by_digest_4_4;
9470 opti_type = OPTI_TYPE_ZERO_BYTE
9471 | OPTI_TYPE_NOT_ITERATED;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 3;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 1;
9476 break;
9477
9478 case 10300: hash_type = HASH_TYPE_SHA1;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9482 kern_type = KERN_TYPE_SAPH_SHA1;
9483 dgst_size = DGST_SIZE_4_5;
9484 parse_func = saph_sha1_parse_hash;
9485 sort_by_digest = sort_by_digest_4_5;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 10400: hash_type = HASH_TYPE_PDFU16;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9497 kern_type = KERN_TYPE_PDF11;
9498 dgst_size = DGST_SIZE_4_4;
9499 parse_func = pdf11_parse_hash;
9500 sort_by_digest = sort_by_digest_4_4;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_NOT_ITERATED;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 10410: hash_type = HASH_TYPE_PDFU16;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9513 kern_type = KERN_TYPE_PDF11CM1;
9514 dgst_size = DGST_SIZE_4_4;
9515 parse_func = pdf11cm1_parse_hash;
9516 sort_by_digest = sort_by_digest_4_4;
9517 opti_type = OPTI_TYPE_ZERO_BYTE
9518 | OPTI_TYPE_NOT_ITERATED;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 10420: hash_type = HASH_TYPE_PDFU16;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_PDF11CM2;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = pdf11cm2_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE
9534 | OPTI_TYPE_NOT_ITERATED;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 10500: hash_type = HASH_TYPE_PDFU16;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_PDF14;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = pdf14_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE
9550 | OPTI_TYPE_NOT_ITERATED;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 10600: hash_type = HASH_TYPE_SHA256;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_BE
9561 | OPTS_TYPE_ST_ADD80
9562 | OPTS_TYPE_ST_ADDBITS15
9563 | OPTS_TYPE_HASH_COPY;
9564 kern_type = KERN_TYPE_SHA256_PWSLT;
9565 dgst_size = DGST_SIZE_4_8;
9566 parse_func = pdf17l3_parse_hash;
9567 sort_by_digest = sort_by_digest_4_8;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_PRECOMPUTE_MERKLE
9571 | OPTI_TYPE_EARLY_SKIP
9572 | OPTI_TYPE_NOT_ITERATED
9573 | OPTI_TYPE_APPENDED_SALT
9574 | OPTI_TYPE_RAW_HASH;
9575 dgst_pos0 = 3;
9576 dgst_pos1 = 7;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 6;
9579 break;
9580
9581 case 10700: hash_type = HASH_TYPE_PDFU32;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE
9585 | OPTS_TYPE_HASH_COPY;
9586 kern_type = KERN_TYPE_PDF17L8;
9587 dgst_size = DGST_SIZE_4_8;
9588 parse_func = pdf17l8_parse_hash;
9589 sort_by_digest = sort_by_digest_4_8;
9590 opti_type = OPTI_TYPE_ZERO_BYTE
9591 | OPTI_TYPE_NOT_ITERATED;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 10800: hash_type = HASH_TYPE_SHA384;
9599 salt_type = SALT_TYPE_NONE;
9600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_BE
9602 | OPTS_TYPE_PT_ADD80
9603 | OPTS_TYPE_PT_ADDBITS15;
9604 kern_type = KERN_TYPE_SHA384;
9605 dgst_size = DGST_SIZE_8_8;
9606 parse_func = sha384_parse_hash;
9607 sort_by_digest = sort_by_digest_8_8;
9608 opti_type = OPTI_TYPE_ZERO_BYTE
9609 | OPTI_TYPE_PRECOMPUTE_INIT
9610 | OPTI_TYPE_PRECOMPUTE_MERKLE
9611 | OPTI_TYPE_EARLY_SKIP
9612 | OPTI_TYPE_NOT_ITERATED
9613 | OPTI_TYPE_NOT_SALTED
9614 | OPTI_TYPE_USES_BITS_64
9615 | OPTI_TYPE_RAW_HASH;
9616 dgst_pos0 = 6;
9617 dgst_pos1 = 7;
9618 dgst_pos2 = 4;
9619 dgst_pos3 = 5;
9620 break;
9621
9622 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE
9626 | OPTS_TYPE_ST_BASE64
9627 | OPTS_TYPE_HASH_COPY;
9628 kern_type = KERN_TYPE_PBKDF2_SHA256;
9629 dgst_size = DGST_SIZE_4_32;
9630 parse_func = pbkdf2_sha256_parse_hash;
9631 sort_by_digest = sort_by_digest_4_32;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 11000: hash_type = HASH_TYPE_MD5;
9640 salt_type = SALT_TYPE_INTERN;
9641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE
9643 | OPTS_TYPE_PT_ADD80;
9644 kern_type = KERN_TYPE_PRESTASHOP;
9645 dgst_size = DGST_SIZE_4_4;
9646 parse_func = prestashop_parse_hash;
9647 sort_by_digest = sort_by_digest_4_4;
9648 opti_type = OPTI_TYPE_ZERO_BYTE
9649 | OPTI_TYPE_PRECOMPUTE_INIT
9650 | OPTI_TYPE_NOT_ITERATED
9651 | OPTI_TYPE_PREPENDED_SALT;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 3;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 1;
9656 break;
9657
9658 case 11100: hash_type = HASH_TYPE_MD5;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_ST_ADD80;
9663 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9664 dgst_size = DGST_SIZE_4_4;
9665 parse_func = postgresql_auth_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_PRECOMPUTE_INIT
9669 | OPTI_TYPE_PRECOMPUTE_MERKLE
9670 | OPTI_TYPE_EARLY_SKIP;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 3;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 1;
9675 break;
9676
9677 case 11200: hash_type = HASH_TYPE_SHA1;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_BE
9681 | OPTS_TYPE_PT_ADD80
9682 | OPTS_TYPE_ST_HEX;
9683 kern_type = KERN_TYPE_MYSQL_AUTH;
9684 dgst_size = DGST_SIZE_4_5;
9685 parse_func = mysql_auth_parse_hash;
9686 sort_by_digest = sort_by_digest_4_5;
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_EARLY_SKIP;
9689 dgst_pos0 = 3;
9690 dgst_pos1 = 4;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE
9699 | OPTS_TYPE_ST_HEX
9700 | OPTS_TYPE_ST_ADD80;
9701 kern_type = KERN_TYPE_BITCOIN_WALLET;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = bitcoin_wallet_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 11400: hash_type = HASH_TYPE_MD5;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE
9716 | OPTS_TYPE_PT_ADD80
9717 | OPTS_TYPE_HASH_COPY;
9718 kern_type = KERN_TYPE_SIP_AUTH;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = sip_auth_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 3;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 1;
9727 break;
9728
9729 case 11500: hash_type = HASH_TYPE_CRC32;
9730 salt_type = SALT_TYPE_INTERN;
9731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE
9733 | OPTS_TYPE_ST_GENERATE_LE
9734 | OPTS_TYPE_ST_HEX;
9735 kern_type = KERN_TYPE_CRC32;
9736 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9737 parse_func = crc32_parse_hash;
9738 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9739 opti_type = OPTI_TYPE_ZERO_BYTE;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 11600: hash_type = HASH_TYPE_AES;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE
9750 | OPTS_TYPE_PT_NEVERCRACK;
9751 kern_type = KERN_TYPE_SEVEN_ZIP;
9752 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9753 parse_func = seven_zip_parse_hash;
9754 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9755 opti_type = OPTI_TYPE_ZERO_BYTE;
9756 dgst_pos0 = 0;
9757 dgst_pos1 = 1;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 3;
9760 break;
9761
9762 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9763 salt_type = SALT_TYPE_NONE;
9764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE
9766 | OPTS_TYPE_PT_ADD01;
9767 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9768 dgst_size = DGST_SIZE_4_8;
9769 parse_func = gost2012sbog_256_parse_hash;
9770 sort_by_digest = sort_by_digest_4_8;
9771 opti_type = OPTI_TYPE_ZERO_BYTE;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9779 salt_type = SALT_TYPE_NONE;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE
9782 | OPTS_TYPE_PT_ADD01;
9783 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9784 dgst_size = DGST_SIZE_4_16;
9785 parse_func = gost2012sbog_512_parse_hash;
9786 sort_by_digest = sort_by_digest_4_16;
9787 opti_type = OPTI_TYPE_ZERO_BYTE;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_LE
9798 | OPTS_TYPE_ST_BASE64
9799 | OPTS_TYPE_HASH_COPY;
9800 kern_type = KERN_TYPE_PBKDF2_MD5;
9801 dgst_size = DGST_SIZE_4_32;
9802 parse_func = pbkdf2_md5_parse_hash;
9803 sort_by_digest = sort_by_digest_4_32;
9804 opti_type = OPTI_TYPE_ZERO_BYTE;
9805 dgst_pos0 = 0;
9806 dgst_pos1 = 1;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 3;
9809 break;
9810
9811 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_LE
9815 | OPTS_TYPE_ST_BASE64
9816 | OPTS_TYPE_HASH_COPY;
9817 kern_type = KERN_TYPE_PBKDF2_SHA1;
9818 dgst_size = DGST_SIZE_4_32;
9819 parse_func = pbkdf2_sha1_parse_hash;
9820 sort_by_digest = sort_by_digest_4_32;
9821 opti_type = OPTI_TYPE_ZERO_BYTE;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 1;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 3;
9826 break;
9827
9828 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE
9832 | OPTS_TYPE_ST_BASE64
9833 | OPTS_TYPE_HASH_COPY;
9834 kern_type = KERN_TYPE_PBKDF2_SHA512;
9835 dgst_size = DGST_SIZE_8_16;
9836 parse_func = pbkdf2_sha512_parse_hash;
9837 sort_by_digest = sort_by_digest_8_16;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_USES_BITS_64;
9840 dgst_pos0 = 0;
9841 dgst_pos1 = 1;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 3;
9844 break;
9845
9846 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9847 salt_type = SALT_TYPE_EMBEDDED;
9848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9850 kern_type = KERN_TYPE_ECRYPTFS;
9851 dgst_size = DGST_SIZE_8_8;
9852 parse_func = ecryptfs_parse_hash;
9853 sort_by_digest = sort_by_digest_8_8;
9854 opti_type = OPTI_TYPE_ZERO_BYTE
9855 | OPTI_TYPE_USES_BITS_64;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 12300: hash_type = HASH_TYPE_ORACLET;
9863 salt_type = SALT_TYPE_EMBEDDED;
9864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9866 kern_type = KERN_TYPE_ORACLET;
9867 dgst_size = DGST_SIZE_8_16;
9868 parse_func = oraclet_parse_hash;
9869 sort_by_digest = sort_by_digest_8_16;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_USES_BITS_64;
9872 dgst_pos0 = 0;
9873 dgst_pos1 = 1;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 3;
9876 break;
9877
9878 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9879 salt_type = SALT_TYPE_EMBEDDED;
9880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9882 kern_type = KERN_TYPE_BSDICRYPT;
9883 dgst_size = DGST_SIZE_4_4;
9884 parse_func = bsdicrypt_parse_hash;
9885 sort_by_digest = sort_by_digest_4_4;
9886 opti_type = OPTI_TYPE_ZERO_BYTE
9887 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 12500: hash_type = HASH_TYPE_RAR3HP;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9898 kern_type = KERN_TYPE_RAR3;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = rar3hp_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE;
9903 dgst_pos0 = 0;
9904 dgst_pos1 = 1;
9905 dgst_pos2 = 2;
9906 dgst_pos3 = 3;
9907 break;
9908
9909 case 12600: hash_type = HASH_TYPE_SHA256;
9910 salt_type = SALT_TYPE_INTERN;
9911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9912 opts_type = OPTS_TYPE_PT_GENERATE_BE
9913 | OPTS_TYPE_PT_ADD80;
9914 kern_type = KERN_TYPE_CF10;
9915 dgst_size = DGST_SIZE_4_8;
9916 parse_func = cf10_parse_hash;
9917 sort_by_digest = sort_by_digest_4_8;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_PRECOMPUTE_INIT
9920 | OPTI_TYPE_EARLY_SKIP
9921 | OPTI_TYPE_NOT_ITERATED;
9922 dgst_pos0 = 3;
9923 dgst_pos1 = 7;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 6;
9926 break;
9927
9928 case 12700: hash_type = HASH_TYPE_AES;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE
9932 | OPTS_TYPE_HASH_COPY;
9933 kern_type = KERN_TYPE_MYWALLET;
9934 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9935 parse_func = mywallet_parse_hash;
9936 sort_by_digest = sort_by_digest_4_5;
9937 opti_type = OPTI_TYPE_ZERO_BYTE;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 1;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 3;
9942 break;
9943
9944 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9945 salt_type = SALT_TYPE_EMBEDDED;
9946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9948 kern_type = KERN_TYPE_MS_DRSR;
9949 dgst_size = DGST_SIZE_4_8;
9950 parse_func = ms_drsr_parse_hash;
9951 sort_by_digest = sort_by_digest_4_8;
9952 opti_type = OPTI_TYPE_ZERO_BYTE;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9963 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9964 dgst_size = DGST_SIZE_4_8;
9965 parse_func = androidfde_samsung_parse_hash;
9966 sort_by_digest = sort_by_digest_4_8;
9967 opti_type = OPTI_TYPE_ZERO_BYTE;
9968 dgst_pos0 = 0;
9969 dgst_pos1 = 1;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 3;
9972 break;
9973
9974 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9978 kern_type = KERN_TYPE_RAR5;
9979 dgst_size = DGST_SIZE_4_4;
9980 parse_func = rar5_parse_hash;
9981 sort_by_digest = sort_by_digest_4_4;
9982 opti_type = OPTI_TYPE_ZERO_BYTE;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 default: usage_mini_print (PROGNAME); return (-1);
9990 }
9991
9992 /**
9993 * transpose
9994 */
9995
9996 data.parse_func = parse_func;
9997
9998 /**
9999 * misc stuff
10000 */
10001
10002 if (hex_salt)
10003 {
10004 if (salt_type == SALT_TYPE_INTERN)
10005 {
10006 opts_type |= OPTS_TYPE_ST_HEX;
10007 }
10008 else
10009 {
10010 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10011
10012 return (-1);
10013 }
10014 }
10015
10016 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10017 | (salt_type == SALT_TYPE_EXTERN)
10018 | (salt_type == SALT_TYPE_EMBEDDED)
10019 | (salt_type == SALT_TYPE_VIRTUAL));
10020
10021 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10022
10023 data.hash_type = hash_type;
10024 data.attack_mode = attack_mode;
10025 data.attack_kern = attack_kern;
10026 data.attack_exec = attack_exec;
10027 data.kern_type = kern_type;
10028 data.opts_type = opts_type;
10029 data.dgst_size = dgst_size;
10030 data.salt_type = salt_type;
10031 data.isSalted = isSalted;
10032 data.sort_by_digest = sort_by_digest;
10033 data.dgst_pos0 = dgst_pos0;
10034 data.dgst_pos1 = dgst_pos1;
10035 data.dgst_pos2 = dgst_pos2;
10036 data.dgst_pos3 = dgst_pos3;
10037
10038 esalt_size = 0;
10039
10040 switch (hash_mode)
10041 {
10042 case 2500: esalt_size = sizeof (wpa_t); break;
10043 case 5300: esalt_size = sizeof (ikepsk_t); break;
10044 case 5400: esalt_size = sizeof (ikepsk_t); break;
10045 case 5500: esalt_size = sizeof (netntlm_t); break;
10046 case 5600: esalt_size = sizeof (netntlm_t); break;
10047 case 6211:
10048 case 6212:
10049 case 6213:
10050 case 6221:
10051 case 6222:
10052 case 6223:
10053 case 6231:
10054 case 6232:
10055 case 6233:
10056 case 6241:
10057 case 6242:
10058 case 6243: esalt_size = sizeof (tc_t); break;
10059 case 6600: esalt_size = sizeof (agilekey_t); break;
10060 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10061 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10062 case 7300: esalt_size = sizeof (rakp_t); break;
10063 case 7500: esalt_size = sizeof (krb5pa_t); break;
10064 case 8200: esalt_size = sizeof (cloudkey_t); break;
10065 case 8800: esalt_size = sizeof (androidfde_t); break;
10066 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10067 case 9400: esalt_size = sizeof (office2007_t); break;
10068 case 9500: esalt_size = sizeof (office2010_t); break;
10069 case 9600: esalt_size = sizeof (office2013_t); break;
10070 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10071 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10072 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10073 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10074 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10075 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10076 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10077 case 10200: esalt_size = sizeof (cram_md5_t); break;
10078 case 10400: esalt_size = sizeof (pdf_t); break;
10079 case 10410: esalt_size = sizeof (pdf_t); break;
10080 case 10420: esalt_size = sizeof (pdf_t); break;
10081 case 10500: esalt_size = sizeof (pdf_t); break;
10082 case 10600: esalt_size = sizeof (pdf_t); break;
10083 case 10700: esalt_size = sizeof (pdf_t); break;
10084 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10085 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10086 case 11400: esalt_size = sizeof (sip_t); break;
10087 case 11600: esalt_size = sizeof (seven_zip_t); break;
10088 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10089 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10090 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10091 case 13000: esalt_size = sizeof (rar5_t); break;
10092 }
10093
10094 data.esalt_size = esalt_size;
10095
10096 /**
10097 * choose dictionary parser
10098 */
10099
10100 if (hash_type == HASH_TYPE_LM)
10101 {
10102 get_next_word_func = get_next_word_lm;
10103 }
10104 else if (opts_type & OPTS_TYPE_PT_UPPER)
10105 {
10106 get_next_word_func = get_next_word_uc;
10107 }
10108 else
10109 {
10110 get_next_word_func = get_next_word_std;
10111 }
10112
10113 /**
10114 * dictstat
10115 */
10116
10117 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10118
10119 #ifdef _POSIX
10120 size_t dictstat_nmemb = 0;
10121 #endif
10122
10123 #ifdef _WIN
10124 uint dictstat_nmemb = 0;
10125 #endif
10126
10127 char dictstat[256] = { 0 };
10128
10129 FILE *dictstat_fp = NULL;
10130
10131 if (keyspace == 0)
10132 {
10133 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10134
10135 dictstat_fp = fopen (dictstat, "rb");
10136
10137 if (dictstat_fp)
10138 {
10139 #ifdef _POSIX
10140 struct stat tmpstat;
10141
10142 fstat (fileno (dictstat_fp), &tmpstat);
10143 #endif
10144
10145 #ifdef _WIN
10146 struct stat64 tmpstat;
10147
10148 _fstat64 (fileno (dictstat_fp), &tmpstat);
10149 #endif
10150
10151 if (tmpstat.st_mtime < COMPTIME)
10152 {
10153 /* with v0.15 the format changed so we have to ensure user is using a good version
10154 since there is no version-header in the dictstat file */
10155
10156 fclose (dictstat_fp);
10157
10158 unlink (dictstat);
10159 }
10160 else
10161 {
10162 while (!feof (dictstat_fp))
10163 {
10164 dictstat_t d;
10165
10166 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10167
10168 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10169
10170 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10171 {
10172 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10173
10174 return -1;
10175 }
10176 }
10177
10178 fclose (dictstat_fp);
10179 }
10180 }
10181 }
10182
10183 /**
10184 * potfile
10185 */
10186
10187 char potfile[256] = { 0 };
10188
10189 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10190
10191 data.pot_fp = NULL;
10192
10193 FILE *out_fp = NULL;
10194 FILE *pot_fp = NULL;
10195
10196 if (show == 1 || left == 1)
10197 {
10198 pot_fp = fopen (potfile, "rb");
10199
10200 if (pot_fp == NULL)
10201 {
10202 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10203
10204 return (-1);
10205 }
10206
10207 if (outfile != NULL)
10208 {
10209 if ((out_fp = fopen (outfile, "ab")) == NULL)
10210 {
10211 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10212
10213 fclose (pot_fp);
10214
10215 return (-1);
10216 }
10217 }
10218 else
10219 {
10220 out_fp = stdout;
10221 }
10222 }
10223 else
10224 {
10225 if (potfile_disable == 0)
10226 {
10227 pot_fp = fopen (potfile, "ab");
10228
10229 if (pot_fp == NULL)
10230 {
10231 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10232
10233 return (-1);
10234 }
10235
10236 data.pot_fp = pot_fp;
10237 }
10238 }
10239
10240 pot_t *pot = NULL;
10241
10242 uint pot_cnt = 0;
10243 uint pot_avail = 0;
10244
10245 if (show == 1 || left == 1)
10246 {
10247 SUPPRESS_OUTPUT = 1;
10248
10249 pot_avail = count_lines (pot_fp);
10250
10251 rewind (pot_fp);
10252
10253 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10254
10255 uint pot_hashes_avail = 0;
10256
10257 uint line_num = 0;
10258
10259 while (!feof (pot_fp))
10260 {
10261 line_num++;
10262
10263 char line_buf[BUFSIZ] = { 0 };
10264
10265 int line_len = fgetl (pot_fp, line_buf);
10266
10267 if (line_len == 0) continue;
10268
10269 char *plain_buf = line_buf + line_len;
10270
10271 pot_t *pot_ptr = &pot[pot_cnt];
10272
10273 hash_t *hashes_buf = &pot_ptr->hash;
10274
10275 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10276 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10277
10278 if (pot_cnt == pot_hashes_avail)
10279 {
10280 uint pos = 0;
10281
10282 for (pos = 0; pos < INCR_POT; pos++)
10283 {
10284 if ((pot_cnt + pos) >= pot_avail) break;
10285
10286 pot_t *tmp_pot = &pot[pot_cnt + pos];
10287
10288 hash_t *tmp_hash = &tmp_pot->hash;
10289
10290 tmp_hash->digest = mymalloc (dgst_size);
10291
10292 if (isSalted)
10293 {
10294 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10295 }
10296
10297 if (esalt_size)
10298 {
10299 tmp_hash->esalt = mymalloc (esalt_size);
10300 }
10301
10302 pot_hashes_avail++;
10303 }
10304 }
10305
10306 int plain_len = 0;
10307
10308 int parser_status;
10309
10310 int iter = MAX_CUT_TRIES;
10311
10312 do
10313 {
10314 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10315 {
10316 if (line_buf[i] == ':')
10317 {
10318 line_len--;
10319
10320 break;
10321 }
10322 }
10323
10324 if (data.hash_mode != 2500)
10325 {
10326 parser_status = parse_func (line_buf, line_len, hashes_buf);
10327 }
10328 else
10329 {
10330 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10331
10332 if (line_len > max_salt_size)
10333 {
10334 parser_status = PARSER_GLOBAL_LENGTH;
10335 }
10336 else
10337 {
10338 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10339
10340 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10341
10342 hashes_buf->salt->salt_len = line_len;
10343
10344 parser_status = PARSER_OK;
10345 }
10346 }
10347
10348 // if NOT parsed without error, we add the ":" to the plain
10349
10350 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10351 {
10352 plain_len++;
10353 plain_buf--;
10354 }
10355
10356 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10357
10358 if (parser_status < PARSER_GLOBAL_ZERO)
10359 {
10360 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10361
10362 continue;
10363 }
10364
10365 if (plain_len >= 255) continue;
10366
10367 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10368
10369 pot_ptr->plain_len = plain_len;
10370
10371 pot_cnt++;
10372 }
10373
10374 fclose (pot_fp);
10375
10376 SUPPRESS_OUTPUT = 0;
10377
10378 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10379 }
10380
10381 /**
10382 * kernel accel and loops auto adjustment
10383 */
10384
10385 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10386 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10387
10388 if (workload_profile == 1)
10389 {
10390 kernel_loops /= 8;
10391 kernel_accel /= 4;
10392
10393 if (kernel_loops == 0) kernel_loops = 8;
10394 if (kernel_accel == 0) kernel_accel = 2;
10395 }
10396 else if (workload_profile == 3)
10397 {
10398 kernel_loops *= 8;
10399 kernel_accel *= 4;
10400
10401 if (kernel_loops > 1024) kernel_loops = 1024;
10402 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10403 }
10404
10405 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10406
10407 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10408 {
10409 kernel_loops = 1024;
10410 }
10411
10412 if (hash_mode == 12500)
10413 {
10414 kernel_loops = ROUNDS_RAR3 / 16;
10415 }
10416
10417 data.kernel_accel = kernel_accel;
10418 data.kernel_loops = kernel_loops;
10419
10420 /**
10421 * word len
10422 */
10423
10424 uint pw_min = PW_MIN;
10425 uint pw_max = PW_MAX;
10426
10427 switch (hash_mode)
10428 {
10429 case 400: if (pw_max > 40) pw_max = 40;
10430 break;
10431 case 500: if (pw_max > 16) pw_max = 16;
10432 break;
10433 case 1500: if (pw_max > 8) pw_max = 8;
10434 break;
10435 case 1600: if (pw_max > 16) pw_max = 16;
10436 break;
10437 case 1800: if (pw_max > 16) pw_max = 16;
10438 break;
10439 case 2100: if (pw_max > 16) pw_max = 16;
10440 break;
10441 case 2500: if (pw_min < 8) pw_min = 8;
10442 break;
10443 case 3000: if (pw_max > 7) pw_max = 7;
10444 break;
10445 case 5200: if (pw_max > 24) pw_max = 24;
10446 break;
10447 case 5800: if (pw_max > 16) pw_max = 16;
10448 break;
10449 case 6300: if (pw_max > 16) pw_max = 16;
10450 break;
10451 case 7400: if (pw_max > 16) pw_max = 16;
10452 break;
10453 case 7900: if (pw_max > 48) pw_max = 48;
10454 break;
10455 case 8500: if (pw_max > 8) pw_max = 8;
10456 break;
10457 case 8600: if (pw_max > 16) pw_max = 16;
10458 break;
10459 case 9710: pw_min = 5;
10460 pw_max = 5;
10461 break;
10462 case 9810: pw_min = 5;
10463 pw_max = 5;
10464 break;
10465 case 10410: pw_min = 5;
10466 pw_max = 5;
10467 break;
10468 case 10300: if (pw_max < 3) pw_min = 3;
10469 if (pw_max > 40) pw_max = 40;
10470 break;
10471 case 10500: if (pw_max < 3) pw_min = 3;
10472 if (pw_max > 40) pw_max = 40;
10473 break;
10474 case 10700: if (pw_max > 16) pw_max = 16;
10475 break;
10476 case 11300: if (pw_max > 40) pw_max = 40;
10477 break;
10478 case 12500: if (pw_max > 20) pw_max = 20;
10479 break;
10480 case 12800: if (pw_max > 24) pw_max = 24;
10481 break;
10482 }
10483
10484 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10485 {
10486 switch (attack_kern)
10487 {
10488 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10489 break;
10490 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10491 break;
10492 }
10493 }
10494
10495 /**
10496 * charsets : keep them together for more easy maintainnce
10497 */
10498
10499 cs_t mp_sys[6] = { { { 0 }, 0 } };
10500 cs_t mp_usr[4] = { { { 0 }, 0 } };
10501
10502 mp_setup_sys (mp_sys);
10503
10504 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10505 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10506 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10507 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10508
10509 /**
10510 * load hashes, part I: find input mode, count hashes
10511 */
10512
10513 uint hashlist_mode = 0;
10514 uint hashlist_format = HLFMT_HASHCAT;
10515
10516 uint hashes_avail = 0;
10517
10518 if (benchmark == 0)
10519 {
10520 struct stat f;
10521
10522 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10523
10524 if ((hash_mode == 2500) ||
10525 (hash_mode == 5200) ||
10526 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10527 (hash_mode == 9000))
10528 {
10529 hashlist_mode = HL_MODE_ARG;
10530
10531 char *hashfile = myargv[optind];
10532
10533 data.hashfile = hashfile;
10534
10535 logfile_top_var_string ("target", hashfile);
10536 }
10537
10538 if (hashlist_mode == HL_MODE_ARG)
10539 {
10540 if (hash_mode == 2500)
10541 {
10542 struct stat st;
10543
10544 if (stat (data.hashfile, &st) == -1)
10545 {
10546 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10547
10548 return (-1);
10549 }
10550
10551 hashes_avail = st.st_size / sizeof (hccap_t);
10552 }
10553 else
10554 {
10555 hashes_avail = 1;
10556 }
10557 }
10558 else if (hashlist_mode == HL_MODE_FILE)
10559 {
10560 char *hashfile = myargv[optind];
10561
10562 data.hashfile = hashfile;
10563
10564 logfile_top_var_string ("target", hashfile);
10565
10566 FILE *fp = NULL;
10567
10568 if ((fp = fopen (hashfile, "rb")) == NULL)
10569 {
10570 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10571
10572 return (-1);
10573 }
10574
10575 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10576
10577 hashes_avail = count_lines (fp);
10578
10579 rewind (fp);
10580
10581 if (hashes_avail == 0)
10582 {
10583 log_error ("ERROR: hashfile is empty or corrupt");
10584
10585 fclose (fp);
10586
10587 return (-1);
10588 }
10589
10590 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10591
10592 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10593 {
10594 log_error ("ERROR: remove not supported in native hashfile-format mode");
10595
10596 fclose (fp);
10597
10598 return (-1);
10599 }
10600
10601 fclose (fp);
10602 }
10603 }
10604 else
10605 {
10606 hashlist_mode = HL_MODE_ARG;
10607
10608 hashes_avail = 1;
10609 }
10610
10611 if (hash_mode == 3000) hashes_avail *= 2;
10612
10613 data.hashlist_mode = hashlist_mode;
10614 data.hashlist_format = hashlist_format;
10615
10616 logfile_top_uint (hashlist_mode);
10617 logfile_top_uint (hashlist_format);
10618
10619 /**
10620 * load hashes, part II: allocate required memory, set pointers
10621 */
10622
10623 hash_t *hashes_buf = NULL;
10624 void *digests_buf = NULL;
10625 salt_t *salts_buf = NULL;
10626 void *esalts_buf = NULL;
10627
10628 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10629
10630 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10631
10632 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10633 {
10634 u32 hash_pos;
10635
10636 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10637 {
10638 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10639
10640 hashes_buf[hash_pos].hash_info = hash_info;
10641
10642 if (username && (remove || show || left))
10643 {
10644 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10645 }
10646
10647 if (benchmark)
10648 {
10649 hash_info->orighash = (char *) mymalloc (256);
10650 }
10651 }
10652 }
10653
10654 if (isSalted)
10655 {
10656 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10657
10658 if (esalt_size)
10659 {
10660 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10661 }
10662 }
10663 else
10664 {
10665 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10666 }
10667
10668 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10669 {
10670 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10671
10672 if (isSalted)
10673 {
10674 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10675
10676 if (esalt_size)
10677 {
10678 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10679 }
10680 }
10681 else
10682 {
10683 hashes_buf[hash_pos].salt = &salts_buf[0];
10684 }
10685 }
10686
10687 /**
10688 * load hashes, part III: parse hashes or generate them if benchmark
10689 */
10690
10691 uint hashes_cnt = 0;
10692
10693 if (benchmark == 0)
10694 {
10695 if (keyspace == 1)
10696 {
10697 // useless to read hash file for keyspace, cheat a little bit w/ optind
10698 }
10699 else if (hashes_avail == 0)
10700 {
10701 }
10702 else if (hashlist_mode == HL_MODE_ARG)
10703 {
10704 char *input_buf = myargv[optind];
10705
10706 uint input_len = strlen (input_buf);
10707
10708 logfile_top_var_string ("target", input_buf);
10709
10710 char *hash_buf = NULL;
10711 int hash_len = 0;
10712
10713 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10714
10715 if (hash_len)
10716 {
10717 if (opts_type & OPTS_TYPE_HASH_COPY)
10718 {
10719 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10720
10721 hash_info_tmp->orighash = mystrdup (hash_buf);
10722 }
10723
10724 if (isSalted)
10725 {
10726 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10727 }
10728
10729 int parser_status = PARSER_OK;
10730
10731 if (hash_mode == 2500)
10732 {
10733 if (hash_len == 0)
10734 {
10735 log_error ("ERROR: hccap file not specified");
10736
10737 return (-1);
10738 }
10739
10740 hashlist_mode = HL_MODE_FILE;
10741
10742 data.hashlist_mode = hashlist_mode;
10743
10744 FILE *fp = fopen (hash_buf, "rb");
10745
10746 if (fp == NULL)
10747 {
10748 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10749
10750 return (-1);
10751 }
10752
10753 if (hashes_avail < 1)
10754 {
10755 log_error ("ERROR: hccap file is empty or corrupt");
10756
10757 fclose (fp);
10758
10759 return (-1);
10760 }
10761
10762 uint hccap_size = sizeof (hccap_t);
10763
10764 char *in = (char *) mymalloc (hccap_size);
10765
10766 while (!feof (fp))
10767 {
10768 int n = fread (in, hccap_size, 1, fp);
10769
10770 if (n != 1)
10771 {
10772 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10773
10774 break;
10775 }
10776
10777 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10778
10779 if (parser_status != PARSER_OK)
10780 {
10781 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10782
10783 continue;
10784 }
10785
10786 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10787
10788 if ((show == 1) || (left == 1))
10789 {
10790 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10791
10792 char *salt_ptr = (char *) tmp_salt->salt_buf;
10793
10794 int cur_pos = tmp_salt->salt_len;
10795 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10796
10797 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10798
10799 u8 *pke_ptr = (u8 *) wpa->pke;
10800
10801 // do the appending task
10802
10803 snprintf (salt_ptr + cur_pos,
10804 rem_len,
10805 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10806 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10807 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10808
10809
10810 // memset () the remaining part of the salt
10811
10812 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10813 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10814
10815 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10816
10817 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10818 }
10819
10820 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);
10821 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);
10822
10823 hashes_cnt++;
10824 }
10825
10826 fclose (fp);
10827
10828 myfree (in);
10829 }
10830 else if (hash_mode == 3000)
10831 {
10832 if (hash_len == 32)
10833 {
10834 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10835
10836 hash_t *lm_hash_left = NULL;
10837
10838 if (parser_status == PARSER_OK)
10839 {
10840 lm_hash_left = &hashes_buf[hashes_cnt];
10841
10842 hashes_cnt++;
10843 }
10844 else
10845 {
10846 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10847 }
10848
10849 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10850
10851 hash_t *lm_hash_right = NULL;
10852
10853 if (parser_status == PARSER_OK)
10854 {
10855 lm_hash_right = &hashes_buf[hashes_cnt];
10856
10857 hashes_cnt++;
10858 }
10859 else
10860 {
10861 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10862 }
10863
10864 // show / left
10865
10866 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10867 {
10868 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);
10869 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);
10870 }
10871 }
10872 else
10873 {
10874 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10875
10876 if (parser_status == PARSER_OK)
10877 {
10878 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10879 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10880 }
10881
10882 if (parser_status == PARSER_OK)
10883 {
10884 hashes_cnt++;
10885 }
10886 else
10887 {
10888 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10889 }
10890 }
10891 }
10892 else
10893 {
10894 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10895
10896 if (parser_status == PARSER_OK)
10897 {
10898 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10899 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10900 }
10901
10902 if (parser_status == PARSER_OK)
10903 {
10904 hashes_cnt++;
10905 }
10906 else
10907 {
10908 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10909 }
10910 }
10911 }
10912 }
10913 else if (hashlist_mode == HL_MODE_FILE)
10914 {
10915 char *hashfile = data.hashfile;
10916
10917 FILE *fp;
10918
10919 if ((fp = fopen (hashfile, "rb")) == NULL)
10920 {
10921 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10922
10923 return (-1);
10924 }
10925
10926 uint line_num = 0;
10927
10928 while (!feof (fp))
10929 {
10930 line_num++;
10931
10932 char line_buf[BUFSIZ] = { 0 };
10933
10934 int line_len = fgetl (fp, line_buf);
10935
10936 if (line_len == 0) continue;
10937
10938 char *hash_buf = NULL;
10939 int hash_len = 0;
10940
10941 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10942
10943 if (username)
10944 {
10945 char *user_buf = NULL;
10946 int user_len = 0;
10947
10948 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10949
10950 if (remove || show)
10951 {
10952 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10953
10954 *user = (user_t *) malloc (sizeof (user_t));
10955
10956 user_t *user_ptr = *user;
10957
10958 if (user_buf != NULL)
10959 {
10960 user_ptr->user_name = mystrdup (user_buf);
10961 }
10962 else
10963 {
10964 user_ptr->user_name = mystrdup ("");
10965 }
10966
10967 user_ptr->user_len = user_len;
10968 }
10969 }
10970
10971 if (opts_type & OPTS_TYPE_HASH_COPY)
10972 {
10973 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10974
10975 hash_info_tmp->orighash = mystrdup (hash_buf);
10976 }
10977
10978 if (isSalted)
10979 {
10980 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10981 }
10982
10983 if (hash_mode == 3000)
10984 {
10985 if (hash_len == 32)
10986 {
10987 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10988
10989 if (parser_status < PARSER_GLOBAL_ZERO)
10990 {
10991 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10992
10993 continue;
10994 }
10995
10996 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10997
10998 hashes_cnt++;
10999
11000 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11001
11002 if (parser_status < PARSER_GLOBAL_ZERO)
11003 {
11004 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11005
11006 continue;
11007 }
11008
11009 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11010
11011 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);
11012
11013 hashes_cnt++;
11014
11015 // show / left
11016
11017 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);
11018 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);
11019 }
11020 else
11021 {
11022 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11023
11024 if (parser_status < PARSER_GLOBAL_ZERO)
11025 {
11026 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11027
11028 continue;
11029 }
11030
11031 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);
11032
11033 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11034 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11035
11036 hashes_cnt++;
11037 }
11038 }
11039 else
11040 {
11041 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11042
11043 if (parser_status < PARSER_GLOBAL_ZERO)
11044 {
11045 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11046
11047 continue;
11048 }
11049
11050 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);
11051
11052 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11053 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11054
11055 hashes_cnt++;
11056 }
11057 }
11058
11059 fclose (fp);
11060
11061 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11062
11063 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11064 }
11065 }
11066 else
11067 {
11068 if (isSalted)
11069 {
11070 hashes_buf[0].salt->salt_len = 8;
11071
11072 // special salt handling
11073
11074 switch (hash_mode)
11075 {
11076 case 1500: hashes_buf[0].salt->salt_len = 2;
11077 break;
11078 case 1731: hashes_buf[0].salt->salt_len = 4;
11079 break;
11080 case 2410: hashes_buf[0].salt->salt_len = 4;
11081 break;
11082 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11083 break;
11084 case 3100: hashes_buf[0].salt->salt_len = 1;
11085 break;
11086 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11087 break;
11088 case 5800: hashes_buf[0].salt->salt_len = 16;
11089 break;
11090 case 6800: hashes_buf[0].salt->salt_len = 32;
11091 break;
11092 case 8400: hashes_buf[0].salt->salt_len = 40;
11093 break;
11094 case 8800: hashes_buf[0].salt->salt_len = 16;
11095 break;
11096 case 8900: hashes_buf[0].salt->salt_len = 16;
11097 hashes_buf[0].salt->scrypt_N = 1024;
11098 hashes_buf[0].salt->scrypt_r = 1;
11099 hashes_buf[0].salt->scrypt_p = 1;
11100 break;
11101 case 9100: hashes_buf[0].salt->salt_len = 16;
11102 break;
11103 case 9300: hashes_buf[0].salt->salt_len = 14;
11104 hashes_buf[0].salt->scrypt_N = 16384;
11105 hashes_buf[0].salt->scrypt_r = 1;
11106 hashes_buf[0].salt->scrypt_p = 1;
11107 break;
11108 case 9400: hashes_buf[0].salt->salt_len = 16;
11109 break;
11110 case 9500: hashes_buf[0].salt->salt_len = 16;
11111 break;
11112 case 9600: hashes_buf[0].salt->salt_len = 16;
11113 break;
11114 case 9700: hashes_buf[0].salt->salt_len = 16;
11115 break;
11116 case 9710: hashes_buf[0].salt->salt_len = 16;
11117 break;
11118 case 9720: hashes_buf[0].salt->salt_len = 16;
11119 break;
11120 case 9800: hashes_buf[0].salt->salt_len = 16;
11121 break;
11122 case 9810: hashes_buf[0].salt->salt_len = 16;
11123 break;
11124 case 9820: hashes_buf[0].salt->salt_len = 16;
11125 break;
11126 case 10300: hashes_buf[0].salt->salt_len = 12;
11127 break;
11128 case 11500: hashes_buf[0].salt->salt_len = 4;
11129 break;
11130 case 11600: hashes_buf[0].salt->salt_len = 4;
11131 break;
11132 case 12400: hashes_buf[0].salt->salt_len = 4;
11133 break;
11134 case 12500: hashes_buf[0].salt->salt_len = 8;
11135 break;
11136 case 12600: hashes_buf[0].salt->salt_len = 64;
11137 break;
11138 }
11139
11140 // special esalt handling
11141
11142 switch (hash_mode)
11143 {
11144 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11145 break;
11146 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11147 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11148 break;
11149 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11150 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11151 break;
11152 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11153 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11154 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11155 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11156 break;
11157 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11158 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11159 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11160 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11161 break;
11162 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11163 break;
11164 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11165 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11166 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11167 break;
11168 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11169 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11170 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11171 break;
11172 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11173 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11174 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11175 break;
11176 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11177 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11178 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11179 break;
11180 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11181 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11182 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11183 break;
11184 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11185 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11186 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11187 break;
11188 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11189 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11190 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11191 break;
11192 }
11193 }
11194
11195 // set hashfile
11196
11197 switch (hash_mode)
11198 {
11199 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11200 break;
11201 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11202 break;
11203 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11204 break;
11205 case 6211:
11206 case 6212:
11207 case 6213:
11208 case 6221:
11209 case 6222:
11210 case 6223:
11211 case 6231:
11212 case 6232:
11213 case 6233:
11214 case 6241:
11215 case 6242:
11216 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11217 break;
11218 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11219 break;
11220 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11221 break;
11222 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11223 break;
11224 }
11225
11226 // set default iterations
11227
11228 switch (hash_mode)
11229 {
11230 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11231 break;
11232 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11233 break;
11234 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11235 break;
11236 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11237 break;
11238 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11239 break;
11240 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11241 break;
11242 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11243 break;
11244 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11245 break;
11246 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11247 break;
11248 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11249 break;
11250 case 6211:
11251 case 6212:
11252 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11253 break;
11254 case 6221:
11255 case 6222:
11256 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11257 break;
11258 case 6231:
11259 case 6232:
11260 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11261 break;
11262 case 6241:
11263 case 6242:
11264 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11265 break;
11266 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11267 break;
11268 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11269 break;
11270 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11271 break;
11272 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11273 break;
11274 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11275 break;
11276 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11277 break;
11278 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11279 break;
11280 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11281 break;
11282 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11283 break;
11284 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11285 break;
11286 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11287 break;
11288 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11289 break;
11290 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11291 break;
11292 case 8900: hashes_buf[0].salt->salt_iter = 1;
11293 break;
11294 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11295 break;
11296 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11297 break;
11298 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11299 break;
11300 case 9300: hashes_buf[0].salt->salt_iter = 1;
11301 break;
11302 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11303 break;
11304 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11305 break;
11306 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11307 break;
11308 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11309 break;
11310 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11311 break;
11312 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11313 break;
11314 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11315 break;
11316 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11317 break;
11318 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11319 break;
11320 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11321 break;
11322 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11323 break;
11324 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11325 break;
11326 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11327 break;
11328 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11329 break;
11330 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11331 break;
11332 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11333 break;
11334 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11335 break;
11336 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11337 break;
11338 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11339 break;
11340 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11341 break;
11342 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11343 break;
11344 }
11345
11346 // set special tuning for benchmark-mode 1
11347
11348 if (benchmark_mode == 1)
11349 {
11350 kernel_loops *= 8;
11351 kernel_accel *= 4;
11352
11353 switch (hash_mode)
11354 {
11355 case 400: kernel_loops = ROUNDS_PHPASS;
11356 kernel_accel = 32;
11357 break;
11358 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11359 kernel_accel = 32;
11360 break;
11361 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11362 kernel_accel = 32;
11363 break;
11364 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11365 kernel_accel = 32;
11366 break;
11367 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11368 kernel_accel = 16;
11369 break;
11370 case 2100: kernel_loops = ROUNDS_DCC2;
11371 kernel_accel = 16;
11372 break;
11373 case 2500: kernel_loops = ROUNDS_WPA2;
11374 kernel_accel = 32;
11375 break;
11376 case 3200: kernel_loops = ROUNDS_BCRYPT;
11377 kernel_accel = 8;
11378 break;
11379 case 5200: kernel_loops = ROUNDS_PSAFE3;
11380 kernel_accel = 16;
11381 break;
11382 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11383 kernel_accel = 16;
11384 break;
11385 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11386 kernel_accel = 64;
11387 break;
11388 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11389 kernel_accel = 32;
11390 break;
11391 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11392 kernel_accel = 32;
11393 break;
11394 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11395 kernel_accel = 8;
11396 break;
11397 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11398 kernel_accel = 8;
11399 break;
11400 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11401 kernel_accel = 8;
11402 break;
11403 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11404 kernel_accel = 8;
11405 break;
11406 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11407 kernel_accel = 8;
11408 break;
11409 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11410 kernel_accel = 8;
11411 break;
11412 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11413 kernel_accel = 128;
11414 break;
11415 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11416 kernel_accel = 64;
11417 break;
11418 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11419 kernel_accel = 64;
11420 break;
11421 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11422 kernel_accel = 32;
11423 break;
11424 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11425 kernel_accel = 128;
11426 break;
11427 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11428 kernel_accel = 128;
11429 break;
11430 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11431 kernel_accel = 32;
11432 break;
11433 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11434 kernel_accel = 64;
11435 break;
11436 case 6800: kernel_loops = ROUNDS_LASTPASS;
11437 kernel_accel = 64;
11438 break;
11439 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11440 kernel_accel = 8;
11441 break;
11442 case 7200: kernel_loops = ROUNDS_GRUB;
11443 kernel_accel = 16;
11444 break;
11445 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11446 kernel_accel = 8;
11447 break;
11448 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11449 kernel_accel = 8;
11450 break;
11451 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11452 kernel_accel = 8;
11453 break;
11454 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11455 kernel_accel = 32;
11456 break;
11457 case 8900: kernel_loops = 1;
11458 kernel_accel = 64;
11459 break;
11460 case 9000: kernel_loops = ROUNDS_PSAFE2;
11461 kernel_accel = 16;
11462 break;
11463 case 9100: kernel_loops = ROUNDS_LOTUS8;
11464 kernel_accel = 64;
11465 break;
11466 case 9200: kernel_loops = ROUNDS_CISCO8;
11467 kernel_accel = 8;
11468 break;
11469 case 9300: kernel_loops = 1;
11470 kernel_accel = 4;
11471 break;
11472 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11473 kernel_accel = 32;
11474 break;
11475 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11476 kernel_accel = 32;
11477 break;
11478 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11479 kernel_accel = 8;
11480 break;
11481 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11482 kernel_accel = 8;
11483 break;
11484 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11485 kernel_accel = 16;
11486 break;
11487 case 10500: kernel_loops = ROUNDS_PDF14;
11488 kernel_accel = 256;
11489 break;
11490 case 10700: kernel_loops = ROUNDS_PDF17L8;
11491 kernel_accel = 8;
11492 break;
11493 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11494 kernel_accel = 8;
11495 break;
11496 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11497 kernel_accel = 8;
11498 break;
11499 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11500 kernel_accel = 8;
11501 break;
11502 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11503 kernel_accel = 8;
11504 break;
11505 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11506 kernel_accel = 8;
11507 break;
11508 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11509 kernel_accel = 8;
11510 break;
11511 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11512 kernel_accel = 8;
11513 break;
11514 case 12300: kernel_loops = ROUNDS_ORACLET;
11515 kernel_accel = 8;
11516 break;
11517 case 12500: kernel_loops = ROUNDS_RAR3;
11518 kernel_accel = 32;
11519 break;
11520 case 12700: kernel_loops = ROUNDS_MYWALLET;
11521 kernel_accel = 512;
11522 break;
11523 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11524 kernel_accel = 512;
11525 break;
11526 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11527 kernel_accel = 8;
11528 break;
11529 case 13000: kernel_loops = ROUNDS_RAR5;
11530 kernel_accel = 8;
11531 break;
11532 }
11533
11534 // some algorithm collide too fast, make that impossible
11535
11536 switch (hash_mode)
11537 {
11538 case 11500: ((uint *) digests_buf)[1] = 1;
11539 break;
11540 }
11541
11542 if (kernel_loops > 1024) kernel_loops = 1024;
11543 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11544 }
11545
11546 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11547 {
11548 kernel_loops = 1024;
11549 }
11550
11551 if (hash_mode == 12500)
11552 {
11553 kernel_loops = ROUNDS_RAR3 / 16;
11554 }
11555
11556 data.kernel_accel = kernel_accel;
11557 data.kernel_loops = kernel_loops;
11558
11559 hashes_cnt = 1;
11560 }
11561
11562 if (show == 1 || left == 1)
11563 {
11564 for (uint i = 0; i < pot_cnt; i++)
11565 {
11566 pot_t *pot_ptr = &pot[i];
11567
11568 hash_t *hashes_buf = &pot_ptr->hash;
11569
11570 local_free (hashes_buf->digest);
11571
11572 if (isSalted)
11573 {
11574 local_free (hashes_buf->salt);
11575 }
11576 }
11577
11578 local_free (pot);
11579
11580 if (data.quiet == 0) log_info_nn ("");
11581
11582 return (0);
11583 }
11584
11585 if (keyspace == 0)
11586 {
11587 if (hashes_cnt == 0)
11588 {
11589 log_error ("ERROR: No hashes loaded");
11590
11591 return (-1);
11592 }
11593 }
11594
11595 /**
11596 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11597 */
11598
11599 if (data.outfile != NULL)
11600 {
11601 if (data.hashfile != NULL)
11602 {
11603 #ifdef _POSIX
11604 struct stat tmpstat_outfile;
11605 struct stat tmpstat_hashfile;
11606 #endif
11607
11608 #ifdef _WIN
11609 struct stat64 tmpstat_outfile;
11610 struct stat64 tmpstat_hashfile;
11611 #endif
11612
11613 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11614
11615 if (tmp_outfile_fp)
11616 {
11617 #ifdef _POSIX
11618 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11619 #endif
11620
11621 #ifdef _WIN
11622 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11623 #endif
11624
11625 fclose (tmp_outfile_fp);
11626 }
11627
11628 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11629
11630 if (tmp_hashfile_fp)
11631 {
11632 #ifdef _POSIX
11633 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11634 #endif
11635
11636 #ifdef _WIN
11637 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11638 #endif
11639
11640 fclose (tmp_hashfile_fp);
11641 }
11642
11643 if (tmp_outfile_fp && tmp_outfile_fp)
11644 {
11645 tmpstat_outfile.st_mode = 0;
11646 tmpstat_outfile.st_nlink = 0;
11647 tmpstat_outfile.st_uid = 0;
11648 tmpstat_outfile.st_gid = 0;
11649 tmpstat_outfile.st_rdev = 0;
11650 tmpstat_outfile.st_atime = 0;
11651
11652 tmpstat_hashfile.st_mode = 0;
11653 tmpstat_hashfile.st_nlink = 0;
11654 tmpstat_hashfile.st_uid = 0;
11655 tmpstat_hashfile.st_gid = 0;
11656 tmpstat_hashfile.st_rdev = 0;
11657 tmpstat_hashfile.st_atime = 0;
11658
11659 #ifdef _POSIX
11660 tmpstat_outfile.st_blksize = 0;
11661 tmpstat_outfile.st_blocks = 0;
11662
11663 tmpstat_hashfile.st_blksize = 0;
11664 tmpstat_hashfile.st_blocks = 0;
11665 #endif
11666
11667 #ifdef _POSIX
11668 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11669 {
11670 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11671
11672 return (-1);
11673 }
11674 #endif
11675
11676 #ifdef _WIN
11677 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11678 {
11679 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11680
11681 return (-1);
11682 }
11683 #endif
11684 }
11685 }
11686 }
11687
11688 /**
11689 * Remove duplicates
11690 */
11691
11692 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11693
11694 if (isSalted)
11695 {
11696 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11697 }
11698 else
11699 {
11700 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11701 }
11702
11703 uint hashes_cnt_orig = hashes_cnt;
11704
11705 hashes_cnt = 1;
11706
11707 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11708 {
11709 if (isSalted)
11710 {
11711 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11712 {
11713 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11714 }
11715 }
11716 else
11717 {
11718 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11719 }
11720
11721 if (hashes_pos > hashes_cnt)
11722 {
11723 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11724 }
11725
11726 hashes_cnt++;
11727 }
11728
11729 /**
11730 * Potfile removes
11731 */
11732
11733 uint potfile_remove_cracks = 0;
11734
11735 if (potfile_disable == 0)
11736 {
11737 hash_t hash_buf;
11738
11739 hash_buf.digest = mymalloc (dgst_size);
11740 hash_buf.salt = NULL;
11741 hash_buf.esalt = NULL;
11742 hash_buf.hash_info = NULL;
11743 hash_buf.cracked = 0;
11744
11745 if (isSalted)
11746 {
11747 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11748 }
11749
11750 if (esalt_size)
11751 {
11752 hash_buf.esalt = mymalloc (esalt_size);
11753 }
11754
11755 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11756
11757 // no solution for these special hash types (for instane because they use hashfile in output etc)
11758 if ((hash_mode != 5200) &&
11759 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11760 (hash_mode != 9000))
11761 {
11762 FILE *fp = fopen (potfile, "rb");
11763
11764 if (fp != NULL)
11765 {
11766 while (!feof (fp))
11767 {
11768 char line_buf[BUFSIZ] = { 0 };
11769
11770 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11771
11772 if (ptr == NULL) break;
11773
11774 int line_len = strlen (line_buf);
11775
11776 if (line_len == 0) continue;
11777
11778 int iter = MAX_CUT_TRIES;
11779
11780 for (int i = line_len - 1; i && iter; i--, line_len--)
11781 {
11782 if (line_buf[i] != ':') continue;
11783
11784 if (isSalted)
11785 {
11786 memset (hash_buf.salt, 0, sizeof (salt_t));
11787 }
11788
11789 hash_t *found = NULL;
11790
11791 if (hash_mode == 6800)
11792 {
11793 if (i < 48) // 48 = 12 * uint in salt_buf[]
11794 {
11795 // manipulate salt_buf
11796 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11797
11798 hash_buf.salt->salt_len = i;
11799
11800 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11801 }
11802 }
11803 else if (hash_mode == 2500)
11804 {
11805 if (i < 48) // 48 = 12 * uint in salt_buf[]
11806 {
11807 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11808 // manipulate salt_buf
11809
11810 // to be safe work with a copy (because of line_len loop, i etc)
11811
11812 char line_buf_cpy[BUFSIZ] = { 0 };
11813
11814 memcpy (line_buf_cpy, line_buf, i);
11815
11816 char *mac2_pos = strrchr (line_buf_cpy, ':');
11817
11818 if (mac2_pos == NULL) continue;
11819
11820 mac2_pos[0] = 0;
11821 mac2_pos++;
11822
11823 if (strlen (mac2_pos) != 12) continue;
11824
11825 char *mac1_pos = strrchr (line_buf_cpy, ':');
11826
11827 if (mac1_pos == NULL) continue;
11828
11829 mac1_pos[0] = 0;
11830 mac1_pos++;
11831
11832 if (strlen (mac1_pos) != 12) continue;
11833
11834 uint essid_length = mac1_pos - line_buf_cpy - 1;
11835
11836 // here we need the ESSID
11837 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11838
11839 hash_buf.salt->salt_len = essid_length;
11840
11841 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11842
11843 if (found)
11844 {
11845 wpa_t *wpa = (wpa_t *) found->esalt;
11846
11847 uint pke[25] = { 0 };
11848
11849 char *pke_ptr = (char *) pke;
11850
11851 for (uint i = 0; i < 25; i++)
11852 {
11853 pke[i] = byte_swap_32 (wpa->pke[i]);
11854 }
11855
11856 u8 mac1[6] = { 0 };
11857 u8 mac2[6] = { 0 };
11858
11859 memcpy (mac1, pke_ptr + 23, 6);
11860 memcpy (mac2, pke_ptr + 29, 6);
11861
11862 // compare hex string(s) vs binary MAC address(es)
11863
11864 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11865 {
11866 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11867 {
11868 found = NULL;
11869 break;
11870 }
11871 }
11872
11873 // early skip ;)
11874 if (!found) continue;
11875
11876 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11877 {
11878 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11879 {
11880 found = NULL;
11881 break;
11882 }
11883 }
11884 }
11885 }
11886 }
11887 else
11888 {
11889 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11890
11891 if (parser_status == PARSER_OK)
11892 {
11893 if (isSalted)
11894 {
11895 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11896 }
11897 else
11898 {
11899 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11900 }
11901 }
11902 }
11903
11904 if (found == NULL) continue;
11905
11906 if (!found->cracked) potfile_remove_cracks++;
11907
11908 found->cracked = 1;
11909
11910 if (found) break;
11911
11912 iter--;
11913 }
11914 }
11915
11916 fclose (fp);
11917 }
11918 }
11919
11920 if (esalt_size)
11921 {
11922 local_free (hash_buf.esalt);
11923 }
11924
11925 if (isSalted)
11926 {
11927 local_free (hash_buf.salt);
11928 }
11929
11930 local_free (hash_buf.digest);
11931 }
11932
11933 /**
11934 * Now generate all the buffers required for later
11935 */
11936
11937 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11938
11939 salt_t *salts_buf_new = NULL;
11940 void *esalts_buf_new = NULL;
11941
11942 if (isSalted)
11943 {
11944 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11945
11946 if (esalt_size)
11947 {
11948 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11949 }
11950 }
11951 else
11952 {
11953 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11954 }
11955
11956 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11957
11958 uint digests_cnt = hashes_cnt;
11959 uint digests_done = 0;
11960
11961 uint size_digests = digests_cnt * dgst_size;
11962 uint size_shown = digests_cnt * sizeof (uint);
11963
11964 uint *digests_shown = (uint *) mymalloc (size_shown);
11965 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11966
11967 uint salts_cnt = 0;
11968 uint salts_done = 0;
11969
11970 hashinfo_t **hash_info = NULL;
11971
11972 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11973 {
11974 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11975
11976 if (username && (remove || show))
11977 {
11978 uint user_pos;
11979
11980 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11981 {
11982 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11983
11984 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11985 }
11986 }
11987 }
11988
11989 uint *salts_shown = (uint *) mymalloc (size_shown);
11990
11991 salt_t *salt_buf;
11992
11993 {
11994 // copied from inner loop
11995
11996 salt_buf = &salts_buf_new[salts_cnt];
11997
11998 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11999
12000 if (esalt_size)
12001 {
12002 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12003 }
12004
12005 salt_buf->digests_cnt = 0;
12006 salt_buf->digests_done = 0;
12007 salt_buf->digests_offset = 0;
12008
12009 salts_cnt++;
12010 }
12011
12012 if (hashes_buf[0].cracked == 1)
12013 {
12014 digests_shown[0] = 1;
12015
12016 digests_done++;
12017
12018 salt_buf->digests_done++;
12019 }
12020
12021 salt_buf->digests_cnt++;
12022
12023 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12024
12025 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12026 {
12027 hash_info[0] = hashes_buf[0].hash_info;
12028 }
12029
12030 // copy from inner loop
12031
12032 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12033 {
12034 if (isSalted)
12035 {
12036 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12037 {
12038 salt_buf = &salts_buf_new[salts_cnt];
12039
12040 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12041
12042 if (esalt_size)
12043 {
12044 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12045 }
12046
12047 salt_buf->digests_cnt = 0;
12048 salt_buf->digests_done = 0;
12049 salt_buf->digests_offset = hashes_pos;
12050
12051 salts_cnt++;
12052 }
12053 }
12054
12055 if (hashes_buf[hashes_pos].cracked == 1)
12056 {
12057 digests_shown[hashes_pos] = 1;
12058
12059 digests_done++;
12060
12061 salt_buf->digests_done++;
12062 }
12063
12064 salt_buf->digests_cnt++;
12065
12066 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12067
12068 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12069 {
12070 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12071 }
12072 }
12073
12074 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12075 {
12076 salt_t *salt_buf = &salts_buf_new[salt_pos];
12077
12078 if (salt_buf->digests_done == salt_buf->digests_cnt)
12079 {
12080 salts_shown[salt_pos] = 1;
12081
12082 salts_done++;
12083 }
12084
12085 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12086 }
12087
12088 local_free (digests_buf);
12089 local_free (salts_buf);
12090 local_free (esalts_buf);
12091
12092 digests_buf = digests_buf_new;
12093 salts_buf = salts_buf_new;
12094 esalts_buf = esalts_buf_new;
12095
12096 local_free (hashes_buf);
12097
12098 /**
12099 * special modification not set from parser
12100 */
12101
12102 switch (hash_mode)
12103 {
12104 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12105 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12106 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12107 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12108 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12109 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12110 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12111 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12112 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12113 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12114 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12115 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12116 }
12117
12118 if (truecrypt_keyfiles)
12119 {
12120 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12121
12122 char *keyfiles = strdup (truecrypt_keyfiles);
12123
12124 char *keyfile = strtok (keyfiles, ",");
12125
12126 do
12127 {
12128 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12129
12130 } while ((keyfile = strtok (NULL, ",")) != NULL);
12131
12132 free (keyfiles);
12133 }
12134
12135 data.digests_cnt = digests_cnt;
12136 data.digests_done = digests_done;
12137 data.digests_buf = digests_buf;
12138 data.digests_shown = digests_shown;
12139 data.digests_shown_tmp = digests_shown_tmp;
12140
12141 data.salts_cnt = salts_cnt;
12142 data.salts_done = salts_done;
12143 data.salts_buf = salts_buf;
12144 data.salts_shown = salts_shown;
12145
12146 data.esalts_buf = esalts_buf;
12147 data.hash_info = hash_info;
12148
12149 /**
12150 * Automatic Optimizers
12151 */
12152
12153 if (salts_cnt == 1)
12154 opti_type |= OPTI_TYPE_SINGLE_SALT;
12155
12156 if (digests_cnt == 1)
12157 opti_type |= OPTI_TYPE_SINGLE_HASH;
12158
12159 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12160 opti_type |= OPTI_TYPE_NOT_ITERATED;
12161
12162 if (attack_mode == ATTACK_MODE_BF)
12163 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12164
12165 data.opti_type = opti_type;
12166
12167 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12168 {
12169 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12170 {
12171 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12172 {
12173 if (opts_type & OPTS_TYPE_ST_ADD80)
12174 {
12175 opts_type &= ~OPTS_TYPE_ST_ADD80;
12176 opts_type |= OPTS_TYPE_PT_ADD80;
12177 }
12178
12179 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12180 {
12181 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12182 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12183 }
12184
12185 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12186 {
12187 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12188 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12189 }
12190 }
12191 }
12192 }
12193
12194 /**
12195 * Some algorithm, like descrypt, can benefit from JIT compilation
12196 */
12197
12198 int force_jit_compilation = -1;
12199
12200 if (hash_mode == 8900)
12201 {
12202 force_jit_compilation = 8900;
12203 }
12204 else if (hash_mode == 9300)
12205 {
12206 force_jit_compilation = 8900;
12207 }
12208 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12209 {
12210 force_jit_compilation = 1500;
12211 }
12212
12213 /**
12214 * generate bitmap tables
12215 */
12216
12217 const uint bitmap_shift1 = 5;
12218 const uint bitmap_shift2 = 13;
12219
12220 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12221
12222 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12223 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12224 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12225 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12226 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12227 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12228 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12229 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12230
12231 uint bitmap_bits;
12232 uint bitmap_nums;
12233 uint bitmap_mask;
12234 uint bitmap_size;
12235
12236 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12237 {
12238 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12239
12240 bitmap_nums = 1 << bitmap_bits;
12241
12242 bitmap_mask = bitmap_nums - 1;
12243
12244 bitmap_size = bitmap_nums * sizeof (uint);
12245
12246 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12247
12248 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;
12249 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;
12250
12251 break;
12252 }
12253
12254 bitmap_nums = 1 << bitmap_bits;
12255
12256 bitmap_mask = bitmap_nums - 1;
12257
12258 bitmap_size = bitmap_nums * sizeof (uint);
12259
12260 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);
12261 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);
12262
12263 /**
12264 * prepare quick rule
12265 */
12266
12267 data.rule_buf_l = rule_buf_l;
12268 data.rule_buf_r = rule_buf_r;
12269
12270 int rule_len_l = (int) strlen (rule_buf_l);
12271 int rule_len_r = (int) strlen (rule_buf_r);
12272
12273 data.rule_len_l = rule_len_l;
12274 data.rule_len_r = rule_len_r;
12275
12276 /**
12277 * load rules
12278 */
12279
12280 uint *all_kernel_rules_cnt = NULL;
12281
12282 kernel_rule_t **all_kernel_rules_buf = NULL;
12283
12284 if (rp_files_cnt)
12285 {
12286 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12287
12288 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12289 }
12290
12291 char rule_buf[BUFSIZ] = { 0 };
12292
12293 int rule_len = 0;
12294
12295 for (uint i = 0; i < rp_files_cnt; i++)
12296 {
12297 uint kernel_rules_avail = 0;
12298
12299 uint kernel_rules_cnt = 0;
12300
12301 kernel_rule_t *kernel_rules_buf = NULL;
12302
12303 char *rp_file = rp_files[i];
12304
12305 char in[BLOCK_SIZE] = { 0 };
12306 char out[BLOCK_SIZE] = { 0 };
12307
12308 FILE *fp = NULL;
12309
12310 uint rule_line = 0;
12311
12312 if ((fp = fopen (rp_file, "rb")) == NULL)
12313 {
12314 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12315
12316 return (-1);
12317 }
12318
12319 while (!feof (fp))
12320 {
12321 memset (rule_buf, 0, BUFSIZ);
12322
12323 rule_len = fgetl (fp, rule_buf);
12324
12325 rule_line++;
12326
12327 if (rule_len == 0) continue;
12328
12329 if (rule_buf[0] == '#') continue;
12330
12331 if (kernel_rules_avail == kernel_rules_cnt)
12332 {
12333 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12334
12335 kernel_rules_avail += INCR_RULES;
12336 }
12337
12338 memset (in, 0, BLOCK_SIZE);
12339 memset (out, 0, BLOCK_SIZE);
12340
12341 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12342
12343 if (result == -1)
12344 {
12345 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12346
12347 continue;
12348 }
12349
12350 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12351 {
12352 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12353
12354 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12355
12356 continue;
12357 }
12358
12359 /* its so slow
12360 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12361 {
12362 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12363
12364 continue;
12365 }
12366 */
12367
12368 kernel_rules_cnt++;
12369 }
12370
12371 fclose (fp);
12372
12373 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12374
12375 all_kernel_rules_buf[i] = kernel_rules_buf;
12376 }
12377
12378 /**
12379 * merge rules or automatic rule generator
12380 */
12381
12382 uint kernel_rules_cnt = 0;
12383
12384 kernel_rule_t *kernel_rules_buf = NULL;
12385
12386 if (attack_mode == ATTACK_MODE_STRAIGHT)
12387 {
12388 if (rp_files_cnt)
12389 {
12390 kernel_rules_cnt = 1;
12391
12392 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12393
12394 repeats[0] = kernel_rules_cnt;
12395
12396 for (uint i = 0; i < rp_files_cnt; i++)
12397 {
12398 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12399
12400 repeats[i + 1] = kernel_rules_cnt;
12401 }
12402
12403 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12404
12405 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12406
12407 for (uint i = 0; i < kernel_rules_cnt; i++)
12408 {
12409 uint out_pos = 0;
12410
12411 kernel_rule_t *out = &kernel_rules_buf[i];
12412
12413 for (uint j = 0; j < rp_files_cnt; j++)
12414 {
12415 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12416 uint in_pos;
12417
12418 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12419
12420 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12421 {
12422 if (out_pos == RULES_MAX - 1)
12423 {
12424 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12425
12426 break;
12427 }
12428
12429 out->cmds[out_pos] = in->cmds[in_pos];
12430 }
12431 }
12432 }
12433
12434 local_free (repeats);
12435 }
12436 else if (rp_gen)
12437 {
12438 uint kernel_rules_avail = 0;
12439
12440 while (kernel_rules_cnt < rp_gen)
12441 {
12442 if (kernel_rules_avail == kernel_rules_cnt)
12443 {
12444 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12445
12446 kernel_rules_avail += INCR_RULES;
12447 }
12448
12449 memset (rule_buf, 0, BLOCK_SIZE);
12450
12451 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12452
12453 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12454
12455 kernel_rules_cnt++;
12456 }
12457 }
12458 }
12459
12460 /**
12461 * generate NOP rules
12462 */
12463
12464 if (kernel_rules_cnt == 0)
12465 {
12466 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12467
12468 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12469
12470 kernel_rules_cnt++;
12471 }
12472
12473 data.kernel_rules_cnt = kernel_rules_cnt;
12474 data.kernel_rules_buf = kernel_rules_buf;
12475
12476 /**
12477 * OpenCL platforms: detect
12478 */
12479
12480 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12481
12482 cl_uint platforms_cnt = 0;
12483
12484 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12485
12486 cl_uint platform_devices_cnt;
12487
12488 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12489
12490 if (platforms_cnt == 0)
12491 {
12492 log_error ("ERROR: No OpenCL compatible platform found");
12493
12494 return (-1);
12495 }
12496
12497 /**
12498 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12499 */
12500
12501 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12502 {
12503 cl_platform_id platform = platforms[platform_id];
12504
12505 char platform_vendor[INFOSZ] = { 0 };
12506
12507 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12508
12509 #ifdef HAVE_HWMON
12510 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12511 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12512 {
12513 // make sure that we do not directly control the fan for NVidia
12514
12515 gpu_temp_retain = 0;
12516
12517 data.gpu_temp_retain = gpu_temp_retain;
12518 }
12519 #endif // HAVE_NVML || HAVE_NVAPI
12520 #endif
12521 }
12522
12523 /**
12524 * OpenCL devices: simply push all devices from all platforms into the same device array
12525 */
12526
12527 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12528
12529 data.devices_param = devices_param;
12530
12531 uint devices_cnt = 0;
12532
12533 uint devices_active = 0;
12534
12535 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12536 {
12537 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12538
12539 cl_platform_id platform = platforms[platform_id];
12540
12541 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12542
12543 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12544 {
12545 const uint device_id = devices_cnt;
12546
12547 hc_device_param_t *device_param = &data.devices_param[device_id];
12548
12549 device_param->device = platform_devices[platform_devices_id];
12550
12551 device_param->device_id = device_id;
12552
12553 device_param->platform_devices_id = platform_devices_id;
12554
12555 // device_type
12556
12557 cl_device_type device_type;
12558
12559 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12560
12561 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12562
12563 device_param->device_type = device_type;
12564
12565 // vendor_id
12566
12567 cl_uint vendor_id = 0;
12568
12569 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12570
12571 device_param->vendor_id = vendor_id;
12572
12573 // device_name
12574
12575 char *device_name = (char *) mymalloc (INFOSZ);
12576
12577 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12578
12579 device_param->device_name = device_name;
12580
12581 // device_version
12582
12583 char *device_version = (char *) mymalloc (INFOSZ);
12584
12585 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12586
12587 device_param->device_version = device_version;
12588
12589 if (strstr (device_version, "pocl"))
12590 {
12591 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12592 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12593
12594 cl_uint vendor_id = VENDOR_ID_GENERIC;
12595
12596 device_param->vendor_id = vendor_id;
12597 }
12598
12599 // max_compute_units
12600
12601 cl_uint vector_width;
12602
12603 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12604 {
12605 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12606
12607 if ((vendor_id == VENDOR_ID_NV) && (strstr (device_name, " Ti") || strstr (device_name, " TI")))
12608 {
12609 // Yeah that's a super bad hack, but there's no other attribute we could use
12610
12611 if (vector_width < 2) vector_width *= 2;
12612 }
12613
12614 if (opti_type & OPTI_TYPE_USES_BITS_64)
12615 {
12616 if (vector_width > 1) vector_width /= 2;
12617 }
12618 }
12619 else
12620 {
12621 vector_width = opencl_vector_width;
12622 }
12623
12624 if (vector_width > 8) vector_width = 8;
12625
12626 device_param->vector_width = vector_width;
12627
12628 // max_compute_units
12629
12630 cl_uint device_processors;
12631
12632 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12633
12634 device_param->device_processors = device_processors;
12635
12636 // max_mem_alloc_size
12637
12638 cl_ulong device_maxmem_alloc;
12639
12640 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12641
12642 device_param->device_maxmem_alloc = device_maxmem_alloc;
12643
12644 // max_mem_alloc_size
12645
12646 cl_ulong device_global_mem;
12647
12648 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12649
12650 device_param->device_global_mem = device_global_mem;
12651
12652 // max_clock_frequency
12653
12654 cl_uint device_maxclock_frequency;
12655
12656 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12657
12658 device_param->device_maxclock_frequency = device_maxclock_frequency;
12659
12660 // skipped
12661
12662 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12663 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12664
12665 device_param->skipped = (skipped1 || skipped2);
12666
12667 // driver_version
12668
12669 char *driver_version = (char *) mymalloc (INFOSZ);
12670
12671 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12672
12673 device_param->driver_version = driver_version;
12674
12675 // device_name_chksum
12676
12677 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12678
12679 #if __x86_64__
12680 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);
12681 #else
12682 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);
12683 #endif
12684
12685 uint device_name_digest[4];
12686
12687 device_name_digest[0] = 0;
12688 device_name_digest[1] = 0;
12689 device_name_digest[2] = 0;
12690 device_name_digest[3] = 0;
12691
12692 md5_64 ((uint *) device_name_chksum, device_name_digest);
12693
12694 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12695
12696 device_param->device_name_chksum = device_name_chksum;
12697
12698 // device_processor_cores
12699
12700 if (device_type & CL_DEVICE_TYPE_CPU)
12701 {
12702 cl_uint device_processor_cores = 1;
12703
12704 device_param->device_processor_cores = device_processor_cores;
12705 }
12706
12707 if (device_type & CL_DEVICE_TYPE_GPU)
12708 {
12709 if (vendor_id == VENDOR_ID_AMD)
12710 {
12711 cl_uint device_processor_cores = 0;
12712
12713 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12714
12715 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12716
12717 device_param->device_processor_cores = device_processor_cores;
12718 }
12719 else if (vendor_id == VENDOR_ID_NV)
12720 {
12721 cl_uint kernel_exec_timeout = 0;
12722
12723 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12724
12725 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12726
12727 device_param->kernel_exec_timeout = kernel_exec_timeout;
12728
12729 cl_uint device_processor_cores = 0;
12730
12731 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12732
12733 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12734
12735 device_param->device_processor_cores = device_processor_cores;
12736
12737 cl_uint sm_minor = 0;
12738 cl_uint sm_major = 0;
12739
12740 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12741 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12742
12743 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12744 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12745
12746 device_param->sm_minor = sm_minor;
12747 device_param->sm_major = sm_major;
12748 }
12749 else
12750 {
12751 cl_uint device_processor_cores = 1;
12752
12753 device_param->device_processor_cores = device_processor_cores;
12754 }
12755 }
12756
12757 // display results
12758
12759 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12760 {
12761 if (device_param->skipped == 0)
12762 {
12763 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12764 device_id + 1,
12765 device_name,
12766 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12767 (unsigned int) (device_global_mem / 1024 / 1024),
12768 (unsigned int) (device_maxclock_frequency),
12769 (unsigned int) device_processors);
12770 }
12771 else
12772 {
12773 log_info ("Device #%u: %s, skipped",
12774 device_id + 1,
12775 device_name);
12776 }
12777 }
12778
12779 // common driver check
12780
12781 if (device_param->skipped == 0)
12782 {
12783 if (strstr (device_version, "pocl"))
12784 {
12785 if (force == 0)
12786 {
12787 log_info ("");
12788 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12789 log_info ("You are STRONGLY encouraged not to use it");
12790 log_info ("You can use --force to override this but do not post error reports if you do so");
12791 log_info ("");
12792
12793 return (-1);
12794 }
12795 }
12796
12797 if (device_type & CL_DEVICE_TYPE_GPU)
12798 {
12799 if (vendor_id == VENDOR_ID_NV)
12800 {
12801 if (device_param->kernel_exec_timeout != 0)
12802 {
12803 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);
12804 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12805 }
12806 }
12807 else if (vendor_id == VENDOR_ID_AMD)
12808 {
12809 int catalyst_check = (force == 1) ? 0 : 1;
12810
12811 int catalyst_warn = 0;
12812
12813 int catalyst_broken = 0;
12814
12815 if (catalyst_check == 1)
12816 {
12817 catalyst_warn = 1;
12818
12819 // v14.9 and higher
12820 if (atoi (device_param->driver_version) >= 1573)
12821 {
12822 catalyst_warn = 0;
12823 }
12824
12825 catalyst_check = 0;
12826 }
12827
12828 if (catalyst_broken == 1)
12829 {
12830 log_info ("");
12831 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12832 log_info ("It will pass over cracked hashes and does not report them as cracked");
12833 log_info ("You are STRONGLY encouraged not to use it");
12834 log_info ("You can use --force to override this but do not post error reports if you do so");
12835 log_info ("");
12836
12837 return (-1);
12838 }
12839
12840 if (catalyst_warn == 1)
12841 {
12842 log_info ("");
12843 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12844 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12845 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12846 #ifdef _WIN
12847 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12848 #endif
12849 log_info ("You can use --force to override this but do not post error reports if you do so");
12850 log_info ("");
12851
12852 return (-1);
12853 }
12854 }
12855 }
12856
12857 devices_active++;
12858 }
12859
12860 // next please
12861
12862 devices_cnt++;
12863 }
12864 }
12865
12866 if (devices_active == 0)
12867 {
12868 log_error ("ERROR: No devices found/left");
12869
12870 return (-1);
12871 }
12872
12873 data.devices_cnt = devices_cnt;
12874
12875 data.devices_active = devices_active;
12876
12877 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12878 {
12879 log_info ("");
12880 }
12881
12882 /**
12883 * OpenCL devices: allocate buffer for device specific information
12884 */
12885
12886 #ifdef HAVE_HWMON
12887 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12888
12889 #ifdef HAVE_ADL
12890 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12891
12892 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12893 #endif // ADL
12894 #endif
12895
12896 /**
12897 * enable custom signal handler(s)
12898 */
12899
12900 if (benchmark == 0)
12901 {
12902 hc_signal (sigHandler_default);
12903 }
12904 else
12905 {
12906 hc_signal (sigHandler_benchmark);
12907 }
12908
12909 /**
12910 * User-defined GPU temp handling
12911 */
12912
12913 #ifdef HAVE_HWMON
12914 if (gpu_temp_disable == 1)
12915 {
12916 gpu_temp_abort = 0;
12917 gpu_temp_retain = 0;
12918 }
12919
12920 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12921 {
12922 if (gpu_temp_abort < gpu_temp_retain)
12923 {
12924 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12925
12926 return (-1);
12927 }
12928 }
12929
12930 data.gpu_temp_disable = gpu_temp_disable;
12931 data.gpu_temp_abort = gpu_temp_abort;
12932 data.gpu_temp_retain = gpu_temp_retain;
12933 #endif
12934
12935 /**
12936 * inform the user
12937 */
12938
12939 if (data.quiet == 0)
12940 {
12941 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12942
12943 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);
12944
12945 if (attack_mode == ATTACK_MODE_STRAIGHT)
12946 {
12947 log_info ("Rules: %u", kernel_rules_cnt);
12948 }
12949
12950 if (opti_type)
12951 {
12952 log_info ("Applicable Optimizers:");
12953
12954 for (uint i = 0; i < 32; i++)
12955 {
12956 const uint opti_bit = 1u << i;
12957
12958 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12959 }
12960 }
12961
12962 /**
12963 * Watchdog and Temperature balance
12964 */
12965
12966 #ifdef HAVE_HWMON
12967 if (gpu_temp_abort == 0)
12968 {
12969 log_info ("Watchdog: Temperature abort trigger disabled");
12970 }
12971 else
12972 {
12973 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12974 }
12975
12976 if (gpu_temp_retain == 0)
12977 {
12978 log_info ("Watchdog: Temperature retain trigger disabled");
12979 }
12980 else
12981 {
12982 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12983 }
12984 #endif
12985 }
12986
12987 if (data.quiet == 0) log_info ("");
12988
12989 /**
12990 * HM devices: init
12991 */
12992
12993 #ifdef HAVE_HWMON
12994 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12995 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12996 #endif
12997
12998 #ifdef HAVE_ADL
12999 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13000 #endif
13001
13002 if (gpu_temp_disable == 0)
13003 {
13004 #if defined(WIN) && defined(HAVE_NVAPI)
13005 if (NvAPI_Initialize () == NVAPI_OK)
13006 {
13007 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13008
13009 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13010
13011 int tmp_out = 0;
13012
13013 for (int i = 0; i < tmp_in; i++)
13014 {
13015 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13016 }
13017
13018 for (int i = 0; i < tmp_out; i++)
13019 {
13020 NvU32 speed;
13021
13022 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13023 }
13024 }
13025 #endif // WIN && HAVE_NVAPI
13026
13027 #if defined(LINUX) && defined(HAVE_NVML)
13028 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13029
13030 data.hm_dll_nv = hm_dll_nv;
13031
13032 if (hm_dll_nv)
13033 {
13034 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13035 {
13036 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13037
13038 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13039
13040 int tmp_out = 0;
13041
13042 for (int i = 0; i < tmp_in; i++)
13043 {
13044 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13045 }
13046
13047 for (int i = 0; i < tmp_out; i++)
13048 {
13049 unsigned int speed;
13050
13051 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13052 }
13053 }
13054 }
13055 #endif // LINUX && HAVE_NVML
13056
13057 #ifdef HAVE_ADL
13058 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13059
13060 data.hm_dll_amd = hm_dll_amd;
13061
13062 if (hm_dll_amd)
13063 {
13064 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13065 {
13066 // total number of adapters
13067
13068 int hm_adapters_num;
13069
13070 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13071
13072 // adapter info
13073
13074 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13075
13076 if (lpAdapterInfo == NULL) return (-1);
13077
13078 // get a list (of ids of) valid/usable adapters
13079
13080 int num_adl_adapters = 0;
13081
13082 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13083
13084 if (num_adl_adapters > 0)
13085 {
13086 hc_thread_mutex_lock (mux_adl);
13087
13088 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13089
13090 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13091
13092 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13093 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13094
13095 hc_thread_mutex_unlock (mux_adl);
13096 }
13097
13098 myfree (valid_adl_device_list);
13099 myfree (lpAdapterInfo);
13100 }
13101 }
13102 #endif // HAVE_ADL
13103 }
13104
13105 /**
13106 * HM devices: copy
13107 */
13108
13109 if (gpu_temp_disable == 0)
13110 {
13111 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13112 {
13113 hc_device_param_t *device_param = &data.devices_param[device_id];
13114
13115 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13116
13117 if (device_param->skipped) continue;
13118
13119 const uint platform_devices_id = device_param->platform_devices_id;
13120
13121 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13122 if (device_param->vendor_id == VENDOR_ID_NV)
13123 {
13124 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13125 }
13126 #endif
13127
13128 #ifdef HAVE_ADL
13129 if (device_param->vendor_id == VENDOR_ID_AMD)
13130 {
13131 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13132 }
13133 #endif
13134 }
13135 }
13136
13137 /*
13138 * Temporary fix:
13139 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13140 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13141 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13142 * Driver / ADL bug?
13143 */
13144
13145 #ifdef HAVE_ADL
13146 if (powertune_enable == 1)
13147 {
13148 hc_thread_mutex_lock (mux_adl);
13149
13150 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13151 {
13152 hc_device_param_t *device_param = &data.devices_param[device_id];
13153
13154 if (device_param->skipped) continue;
13155
13156 if (data.hm_device[device_id].od_version == 6)
13157 {
13158 // set powertune value only
13159
13160 int powertune_supported = 0;
13161
13162 int ADL_rc = 0;
13163
13164 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13165 {
13166 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13167
13168 return (-1);
13169 }
13170
13171 if (powertune_supported != 0)
13172 {
13173 // powertune set
13174 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13175
13176 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13177 {
13178 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13179
13180 return (-1);
13181 }
13182
13183 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13184 {
13185 log_error ("ERROR: Failed to set new ADL PowerControl values");
13186
13187 return (-1);
13188 }
13189 }
13190 }
13191 }
13192
13193 hc_thread_mutex_unlock (mux_adl);
13194 }
13195 #endif // HAVE_ADK
13196 #endif // HAVE_HWMON
13197
13198 uint kernel_blocks_all = 0;
13199
13200 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13201 {
13202 /**
13203 * host buffer
13204 */
13205
13206 hc_device_param_t *device_param = &data.devices_param[device_id];
13207
13208 if (device_param->skipped) continue;
13209
13210 /**
13211 * device properties
13212 */
13213
13214 char *device_name_chksum = device_param->device_name_chksum;
13215
13216 uint device_processors = device_param->device_processors;
13217
13218 uint device_processor_cores = device_param->device_processor_cores;
13219
13220 cl_device_type device_type = device_param->device_type;
13221
13222 /**
13223 * create context for each device
13224 */
13225
13226 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13227
13228 /**
13229 * create command-queue
13230 */
13231
13232 // not supported with NV
13233 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13234
13235 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13236
13237 /**
13238 * create input buffers on device
13239 */
13240
13241 uint kernel_threads = KERNEL_THREADS;
13242
13243 // bcrypt
13244 if (hash_mode == 3200) kernel_threads = 8;
13245 if (hash_mode == 9000) kernel_threads = 8;
13246
13247 if (device_type & CL_DEVICE_TYPE_CPU)
13248 {
13249 if (benchmark_mode == 0)
13250 {
13251 if (kernel_accel > 16)
13252 {
13253 kernel_accel = 16;
13254 }
13255 }
13256 else
13257 {
13258 if (kernel_accel > 64)
13259 {
13260 kernel_accel = 64;
13261 }
13262 }
13263 }
13264
13265 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13266 uint kernel_blocks = kernel_power;
13267
13268 device_param->kernel_threads = kernel_threads;
13269 device_param->kernel_power_user = kernel_power;
13270 device_param->kernel_blocks_user = kernel_blocks;
13271
13272 kernel_blocks_all += kernel_blocks;
13273
13274 uint size_pws = kernel_power * sizeof (pw_t);
13275
13276 uint size_tmps = 4;
13277
13278 switch (hash_mode)
13279 {
13280 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13281 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13282 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13283 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13284 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13285 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13286 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13287 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13288 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13289 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13290 case 6211:
13291 case 6212:
13292 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13293 case 6221:
13294 case 6222:
13295 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13296 case 6231:
13297 case 6232:
13298 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13299 case 6241:
13300 case 6242:
13301 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13302 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13303 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13304 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13305 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13306 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13307 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13308 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13309 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13310 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13311 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13312 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13313 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13314 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13315 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13316 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13317 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13318 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13319 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13320 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13321 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13322 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13323 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13324 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13325 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13326 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13327 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13328 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13329 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13330 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13331 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13332 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13333 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13334 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13335 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13336 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13337 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13338 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13339 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13340 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13341 };
13342
13343 uint size_hooks = 4;
13344
13345 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13346 {
13347 // insert correct hook size
13348 }
13349
13350 // we can optimize some stuff here...
13351
13352 device_param->size_pws = size_pws;
13353 device_param->size_tmps = size_tmps;
13354 device_param->size_hooks = size_hooks;
13355
13356 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13357 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13358
13359 device_param->size_root_css = size_root_css;
13360 device_param->size_markov_css = size_markov_css;
13361
13362 uint size_results = KERNEL_THREADS * sizeof (uint);
13363
13364 device_param->size_results = size_results;
13365
13366 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13367 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13368
13369 uint size_plains = digests_cnt * sizeof (plain_t);
13370 uint size_salts = salts_cnt * sizeof (salt_t);
13371 uint size_esalts = salts_cnt * esalt_size;
13372
13373 device_param->size_plains = size_plains;
13374 device_param->size_digests = size_digests;
13375 device_param->size_shown = size_shown;
13376 device_param->size_salts = size_salts;
13377
13378 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13379 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13380 uint size_tm = 32 * sizeof (bs_word_t);
13381
13382 u64 size_scryptV = 1;
13383
13384 if ((hash_mode == 8900) || (hash_mode == 9300))
13385 {
13386 uint tmto_start = 0;
13387 uint tmto_stop = 10;
13388
13389 if (scrypt_tmto)
13390 {
13391 tmto_start = scrypt_tmto;
13392 }
13393 else
13394 {
13395 // in case the user did not specify the tmto manually
13396 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13397 // but set the lower end only in case the user has a device with too less memory
13398
13399 if (hash_mode == 8900)
13400 {
13401 if (device_param->vendor_id == VENDOR_ID_AMD)
13402 {
13403 tmto_start = 1;
13404 }
13405 else if (device_param->vendor_id == VENDOR_ID_NV)
13406 {
13407 tmto_start = 3;
13408 }
13409 }
13410 else if (hash_mode == 9300)
13411 {
13412 if (device_param->vendor_id == VENDOR_ID_AMD)
13413 {
13414 tmto_start = 3;
13415 }
13416 else if (device_param->vendor_id == VENDOR_ID_NV)
13417 {
13418 tmto_start = 5;
13419 }
13420 }
13421 }
13422
13423 if (quiet == 0) log_info ("");
13424
13425 uint shader_per_mp = 1;
13426
13427 if (device_param->vendor_id == VENDOR_ID_AMD)
13428 {
13429 shader_per_mp = 8;
13430 }
13431 else if (device_param->vendor_id == VENDOR_ID_NV)
13432 {
13433 shader_per_mp = 32;
13434 }
13435
13436 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13437 {
13438 // TODO: in theory the following calculation needs to be done per salt, not global
13439 // we assume all hashes have the same scrypt settings
13440
13441 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13442
13443 size_scryptV /= 1 << tmto;
13444
13445 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13446
13447 if (size_scryptV > device_param->device_maxmem_alloc)
13448 {
13449 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13450
13451 continue;
13452 }
13453
13454 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13455 {
13456 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13457 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13458 }
13459
13460 break;
13461 }
13462
13463 if (data.salts_buf[0].scrypt_phy == 0)
13464 {
13465 log_error ("ERROR: can't allocate enough device memory");
13466
13467 return -1;
13468 }
13469
13470 if (quiet == 0) log_info ("");
13471 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13472 }
13473
13474 /**
13475 * default building options
13476 */
13477
13478 char build_opts[1024];
13479
13480 // we don't have sm_* on vendors not NV but it doesn't matter
13481
13482 sprintf (build_opts, "-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);
13483
13484 /**
13485 * main kernel
13486 */
13487
13488 {
13489 /**
13490 * kernel source filename
13491 */
13492
13493 char source_file[256] = { 0 };
13494
13495 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13496
13497 struct stat sst;
13498
13499 if (stat (source_file, &sst) == -1)
13500 {
13501 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13502
13503 return -1;
13504 }
13505
13506 /**
13507 * kernel cached filename
13508 */
13509
13510 char cached_file[256] = { 0 };
13511
13512 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13513
13514 int cached = 1;
13515
13516 struct stat cst;
13517
13518 if (stat (cached_file, &cst) == -1)
13519 {
13520 cached = 0;
13521 }
13522
13523 /**
13524 * kernel compile or load
13525 */
13526
13527 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13528
13529 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13530
13531 if (force_jit_compilation == -1)
13532 {
13533 if (cached == 0)
13534 {
13535 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13536
13537 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13538
13539 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13540
13541 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13542
13543 size_t binary_size;
13544
13545 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13546
13547 u8 *binary = (u8 *) mymalloc (binary_size);
13548
13549 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13550
13551 writeProgramBin (cached_file, binary, binary_size);
13552
13553 local_free (binary);
13554 }
13555 else
13556 {
13557 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13558
13559 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13560
13561 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13562
13563 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13564 }
13565 }
13566 else
13567 {
13568 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13569
13570 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13571
13572 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13573
13574 if (force_jit_compilation == 1500)
13575 {
13576 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13577 }
13578 else if (force_jit_compilation == 8900)
13579 {
13580 sprintf (build_opts, "%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);
13581 }
13582
13583 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13584 }
13585
13586 local_free (kernel_lengths);
13587 local_free (kernel_sources[0]);
13588 local_free (kernel_sources);
13589
13590 // this is mostly for debug
13591
13592 size_t ret_val_size = 0;
13593
13594 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13595
13596 if (ret_val_size > 2)
13597 {
13598 char *build_log = (char *) mymalloc (ret_val_size + 1);
13599
13600 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13601
13602 puts (build_log);
13603
13604 myfree (build_log);
13605 }
13606 }
13607
13608 /**
13609 * word generator kernel
13610 */
13611
13612 if (attack_mode != ATTACK_MODE_STRAIGHT)
13613 {
13614 /**
13615 * kernel mp source filename
13616 */
13617
13618 char source_file[256] = { 0 };
13619
13620 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13621
13622 struct stat sst;
13623
13624 if (stat (source_file, &sst) == -1)
13625 {
13626 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13627
13628 return -1;
13629 }
13630
13631 /**
13632 * kernel mp cached filename
13633 */
13634
13635 char cached_file[256] = { 0 };
13636
13637 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13638
13639 int cached = 1;
13640
13641 struct stat cst;
13642
13643 if (stat (cached_file, &cst) == -1)
13644 {
13645 cached = 0;
13646 }
13647
13648 /**
13649 * kernel compile or load
13650 */
13651
13652 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13653
13654 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13655
13656 if (cached == 0)
13657 {
13658 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13659
13660 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13661
13662 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13663
13664 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13665
13666 size_t binary_size;
13667
13668 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13669
13670 u8 *binary = (u8 *) mymalloc (binary_size);
13671
13672 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13673
13674 writeProgramBin (cached_file, binary, binary_size);
13675
13676 local_free (binary);
13677 }
13678 else
13679 {
13680 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13681
13682 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13683
13684 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13685
13686 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13687 }
13688
13689 local_free (kernel_lengths);
13690 local_free (kernel_sources[0]);
13691 local_free (kernel_sources);
13692
13693 // this is mostly for debug
13694
13695 size_t ret_val_size = 0;
13696
13697 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13698
13699 if (ret_val_size > 2)
13700 {
13701 char *build_log = (char *) mymalloc (ret_val_size + 1);
13702
13703 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13704
13705 puts (build_log);
13706
13707 myfree (build_log);
13708 }
13709 }
13710
13711 /**
13712 * amplifier kernel
13713 */
13714
13715 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13716 {
13717
13718 }
13719 else
13720 {
13721 /**
13722 * kernel amp source filename
13723 */
13724
13725 char source_file[256] = { 0 };
13726
13727 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13728
13729 struct stat sst;
13730
13731 if (stat (source_file, &sst) == -1)
13732 {
13733 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13734
13735 return -1;
13736 }
13737
13738 /**
13739 * kernel amp cached filename
13740 */
13741
13742 char cached_file[256] = { 0 };
13743
13744 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13745
13746 int cached = 1;
13747
13748 struct stat cst;
13749
13750 if (stat (cached_file, &cst) == -1)
13751 {
13752 cached = 0;
13753 }
13754
13755 /**
13756 * kernel compile or load
13757 */
13758
13759 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13760
13761 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13762
13763 if (cached == 0)
13764 {
13765 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13766
13767 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13768
13769 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13770
13771 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13772
13773 size_t binary_size;
13774
13775 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13776
13777 u8 *binary = (u8 *) mymalloc (binary_size);
13778
13779 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13780
13781 writeProgramBin (cached_file, binary, binary_size);
13782
13783 local_free (binary);
13784 }
13785 else
13786 {
13787 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13788
13789 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13790
13791 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13792
13793 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13794 }
13795
13796 local_free (kernel_lengths);
13797 local_free (kernel_sources[0]);
13798 local_free (kernel_sources);
13799
13800 // this is mostly for debug
13801
13802 size_t ret_val_size = 0;
13803
13804 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13805
13806 if (ret_val_size > 2)
13807 {
13808 char *build_log = (char *) mymalloc (ret_val_size + 1);
13809
13810 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13811
13812 puts (build_log);
13813
13814 myfree (build_log);
13815 }
13816 }
13817
13818 /**
13819 * global buffers
13820 */
13821
13822 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13823 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13824 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13825 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13826 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13827 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13828 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13829 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13830 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13831 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13832 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13833 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13834 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13835 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13836 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13837 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13838 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13839 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13840
13841 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13842 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13843 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13844 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13845 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13846 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13847 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13848 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13849 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13850 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13851 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13852
13853 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13854 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13855 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13856 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13857 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13858 run_kernel_bzero (device_param, device_param->d_result, size_results);
13859
13860 /**
13861 * special buffers
13862 */
13863
13864 if (attack_kern == ATTACK_KERN_STRAIGHT)
13865 {
13866 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13867 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13868
13869 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13870
13871 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13872 }
13873 else if (attack_kern == ATTACK_KERN_COMBI)
13874 {
13875 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13876 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13877 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13878 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13879
13880 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13881 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13882 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13883 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13884 }
13885 else if (attack_kern == ATTACK_KERN_BF)
13886 {
13887 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13888 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13889 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13890 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13891 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13892
13893 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13894 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13895 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13896 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13897 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13898 }
13899
13900 if (size_esalts)
13901 {
13902 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13903
13904 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13905 }
13906
13907 /**
13908 * main host data
13909 */
13910
13911 uint *result = (uint *) mymalloc (size_results);
13912
13913 device_param->result = result;
13914
13915 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13916
13917 device_param->pws_buf = pws_buf;
13918
13919 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13920
13921 for (int i = 0; i < 64; i++)
13922 {
13923 pw_caches[i].pw_buf.pw_len = i;
13924 pw_caches[i].cnt = 0;
13925 }
13926
13927 device_param->pw_caches = pw_caches;
13928
13929 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13930
13931 device_param->combs_buf = combs_buf;
13932
13933 void *hooks_buf = mymalloc (size_hooks);
13934
13935 device_param->hooks_buf = hooks_buf;
13936
13937 device_param->pw_transpose = pw_transpose_to_hi1;
13938 device_param->pw_add = pw_add_to_hc1;
13939
13940 /**
13941 * kernel args
13942 */
13943
13944 device_param->kernel_params_buf32[21] = bitmap_mask;
13945 device_param->kernel_params_buf32[22] = bitmap_shift1;
13946 device_param->kernel_params_buf32[23] = bitmap_shift2;
13947 device_param->kernel_params_buf32[24] = 0; // salt_pos
13948 device_param->kernel_params_buf32[25] = 0; // loop_pos
13949 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13950 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13951 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13952 device_param->kernel_params_buf32[29] = 0; // digests_offset
13953 device_param->kernel_params_buf32[30] = 0; // combs_mode
13954 device_param->kernel_params_buf32[31] = 0; // gid_max
13955
13956 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13957 ? &device_param->d_pws_buf
13958 : &device_param->d_pws_amp_buf;
13959 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13960 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13961 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13962 device_param->kernel_params[ 4] = &device_param->d_tmps;
13963 device_param->kernel_params[ 5] = &device_param->d_hooks;
13964 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13965 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13966 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13967 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13968 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13969 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13970 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13971 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13972 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13973 device_param->kernel_params[15] = &device_param->d_digests_buf;
13974 device_param->kernel_params[16] = &device_param->d_digests_shown;
13975 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13976 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13977 device_param->kernel_params[19] = &device_param->d_result;
13978 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13979 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13980 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13981 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13982 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13983 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13984 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13985 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13986 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13987 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13988 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13989 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13990
13991 device_param->kernel_params_mp_buf64[3] = 0;
13992 device_param->kernel_params_mp_buf32[4] = 0;
13993 device_param->kernel_params_mp_buf32[5] = 0;
13994 device_param->kernel_params_mp_buf32[6] = 0;
13995 device_param->kernel_params_mp_buf32[7] = 0;
13996 device_param->kernel_params_mp_buf32[8] = 0;
13997
13998 device_param->kernel_params_mp[0] = NULL;
13999 device_param->kernel_params_mp[1] = NULL;
14000 device_param->kernel_params_mp[2] = NULL;
14001 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14002 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14003 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14004 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14005 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14006 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14007
14008 device_param->kernel_params_mp_l_buf64[3] = 0;
14009 device_param->kernel_params_mp_l_buf32[4] = 0;
14010 device_param->kernel_params_mp_l_buf32[5] = 0;
14011 device_param->kernel_params_mp_l_buf32[6] = 0;
14012 device_param->kernel_params_mp_l_buf32[7] = 0;
14013 device_param->kernel_params_mp_l_buf32[8] = 0;
14014 device_param->kernel_params_mp_l_buf32[9] = 0;
14015
14016 device_param->kernel_params_mp_l[0] = NULL;
14017 device_param->kernel_params_mp_l[1] = NULL;
14018 device_param->kernel_params_mp_l[2] = NULL;
14019 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14020 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14021 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14022 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14023 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14024 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14025 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14026
14027 device_param->kernel_params_mp_r_buf64[3] = 0;
14028 device_param->kernel_params_mp_r_buf32[4] = 0;
14029 device_param->kernel_params_mp_r_buf32[5] = 0;
14030 device_param->kernel_params_mp_r_buf32[6] = 0;
14031 device_param->kernel_params_mp_r_buf32[7] = 0;
14032 device_param->kernel_params_mp_r_buf32[8] = 0;
14033
14034 device_param->kernel_params_mp_r[0] = NULL;
14035 device_param->kernel_params_mp_r[1] = NULL;
14036 device_param->kernel_params_mp_r[2] = NULL;
14037 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14038 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14039 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14040 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14041 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14042 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14043
14044 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14045 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14046
14047 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14048 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14049 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14050 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14051 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14052 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14053 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14054
14055 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14056
14057 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14058 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14059
14060 /**
14061 * kernel name
14062 */
14063
14064 char kernel_name[64] = { 0 };
14065
14066 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14067 {
14068 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14069 {
14070 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14071
14072 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14073
14074 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14075
14076 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14077
14078 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14079
14080 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14081 }
14082 else
14083 {
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14085
14086 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14087
14088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14089
14090 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14091
14092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14093
14094 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14095 }
14096
14097 if (data.attack_mode == ATTACK_MODE_BF)
14098 {
14099 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14100 {
14101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14102
14103 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14104
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14106
14107 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14108 }
14109 }
14110 }
14111 else
14112 {
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14114
14115 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14116
14117 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14118
14119 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14120
14121 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14122
14123 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14124
14125 if (opts_type & OPTS_TYPE_HOOK12)
14126 {
14127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14128
14129 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14130 }
14131
14132 if (opts_type & OPTS_TYPE_HOOK23)
14133 {
14134 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14135
14136 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14137 }
14138 }
14139
14140 for (uint i = 0; i <= 20; i++)
14141 {
14142 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14143 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14144 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14145
14146 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14147 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14148 }
14149
14150 for (uint i = 21; i <= 31; i++)
14151 {
14152 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14153 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14154 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14155
14156 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14157 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14158 }
14159
14160 if (attack_mode == ATTACK_MODE_BF)
14161 {
14162 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14163 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14164
14165 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14166 {
14167 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14168
14169 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14170 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14171 }
14172 }
14173 else if (attack_mode == ATTACK_MODE_HYBRID1)
14174 {
14175 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14176 }
14177 else if (attack_mode == ATTACK_MODE_HYBRID2)
14178 {
14179 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14180 }
14181
14182 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14183 {
14184 // nothing to do
14185 }
14186 else
14187 {
14188 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14189 }
14190
14191 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14192 {
14193 // nothing to do
14194 }
14195 else
14196 {
14197 for (uint i = 0; i < 5; i++)
14198 {
14199 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14200 }
14201
14202 for (uint i = 5; i < 7; i++)
14203 {
14204 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14205 }
14206 }
14207
14208 /**
14209 * Store initial fanspeed if gpu_temp_retain is enabled
14210 */
14211
14212 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14213 int gpu_temp_retain_set = 0;
14214
14215 if (gpu_temp_disable == 0)
14216 {
14217 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14218 {
14219 hc_thread_mutex_lock (mux_adl);
14220
14221 if (data.hm_device[device_id].fan_supported == 1)
14222 {
14223 if (gpu_temp_retain_chgd == 0)
14224 {
14225 uint cur_temp = 0;
14226 uint default_temp = 0;
14227
14228 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14229
14230 if (ADL_rc == ADL_OK)
14231 {
14232 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14233
14234 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14235
14236 // special case with multi gpu setups: always use minimum retain
14237
14238 if (gpu_temp_retain_set == 0)
14239 {
14240 gpu_temp_retain = gpu_temp_retain_target;
14241 gpu_temp_retain_set = 1;
14242 }
14243 else
14244 {
14245 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14246 }
14247
14248 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14249 }
14250 }
14251
14252 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14253
14254 temp_retain_fanspeed_value[device_id] = fan_speed;
14255
14256 if (fan_speed == -1)
14257 {
14258 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14259
14260 temp_retain_fanspeed_value[device_id] = 0;
14261 }
14262 }
14263
14264 hc_thread_mutex_unlock (mux_adl);
14265 }
14266 }
14267
14268 /**
14269 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14270 */
14271
14272 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14273 {
14274 hc_thread_mutex_lock (mux_adl);
14275
14276 if (data.hm_device[device_id].od_version == 6)
14277 {
14278 int ADL_rc;
14279
14280 // check powertune capabilities first, if not available then skip device
14281
14282 int powertune_supported = 0;
14283
14284 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14285 {
14286 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14287
14288 return (-1);
14289 }
14290
14291 if (powertune_supported != 0)
14292 {
14293 // powercontrol settings
14294
14295 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14296
14297 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14298 {
14299 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14300 }
14301
14302 if (ADL_rc != ADL_OK)
14303 {
14304 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14305
14306 return (-1);
14307 }
14308
14309 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14310 {
14311 log_error ("ERROR: Failed to set new ADL PowerControl values");
14312
14313 return (-1);
14314 }
14315
14316 // clocks
14317
14318 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14319
14320 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14321
14322 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14323 {
14324 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14325
14326 return (-1);
14327 }
14328
14329 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14330
14331 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14332
14333 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14334 {
14335 log_error ("ERROR: Failed to get ADL device capabilities");
14336
14337 return (-1);
14338 }
14339
14340 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14341 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14342
14343 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14344 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14345
14346 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14347 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14348
14349 // warning if profile has too low max values
14350
14351 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14352 {
14353 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14354 }
14355
14356 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14357 {
14358 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14359 }
14360
14361 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14362
14363 performance_state->iNumberOfPerformanceLevels = 2;
14364
14365 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14366 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14367 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14368 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14369
14370 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14371 {
14372 log_info ("ERROR: Failed to set ADL performance state");
14373
14374 return (-1);
14375 }
14376
14377 local_free (performance_state);
14378 }
14379 }
14380
14381 hc_thread_mutex_unlock (mux_adl);
14382 }
14383 #endif // HAVE_HWMON && HAVE_ADL
14384 }
14385
14386 data.kernel_blocks_all = kernel_blocks_all;
14387
14388 if (data.quiet == 0) log_info ("");
14389
14390 /**
14391 * Inform user which algorithm is checked and at which workload setting
14392 */
14393
14394 if (benchmark == 1)
14395 {
14396 quiet = 0;
14397
14398 data.quiet = quiet;
14399
14400 char *hash_type = strhashtype (data.hash_mode); // not a bug
14401
14402 log_info ("Hashtype: %s", hash_type);
14403 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14404 log_info ("");
14405 }
14406
14407 /**
14408 * keep track of the progress
14409 */
14410
14411 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14412 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14413 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14414
14415 /**
14416 * open filehandles
14417 */
14418
14419 #if _WIN
14420 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14421 {
14422 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14423
14424 return (-1);
14425 }
14426
14427 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14428 {
14429 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14430
14431 return (-1);
14432 }
14433
14434 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14435 {
14436 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14437
14438 return (-1);
14439 }
14440 #endif
14441
14442 /**
14443 * dictionary pad
14444 */
14445
14446 segment_size *= (1024 * 1024);
14447
14448 data.segment_size = segment_size;
14449
14450 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14451
14452 wl_data->buf = (char *) mymalloc (segment_size);
14453 wl_data->avail = segment_size;
14454 wl_data->incr = segment_size;
14455 wl_data->cnt = 0;
14456 wl_data->pos = 0;
14457
14458 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14459
14460 data.wordlist_mode = wordlist_mode;
14461
14462 cs_t *css_buf = NULL;
14463 uint css_cnt = 0;
14464 uint dictcnt = 0;
14465 uint maskcnt = 1;
14466 char **masks = NULL;
14467 char **dictfiles = NULL;
14468
14469 uint mask_from_file = 0;
14470
14471 if (attack_mode == ATTACK_MODE_STRAIGHT)
14472 {
14473 if (wordlist_mode == WL_MODE_FILE)
14474 {
14475 int wls_left = myargc - (optind + 1);
14476
14477 for (int i = 0; i < wls_left; i++)
14478 {
14479 char *l0_filename = myargv[optind + 1 + i];
14480
14481 struct stat l0_stat;
14482
14483 if (stat (l0_filename, &l0_stat) == -1)
14484 {
14485 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14486
14487 return (-1);
14488 }
14489
14490 uint is_dir = S_ISDIR (l0_stat.st_mode);
14491
14492 if (is_dir == 0)
14493 {
14494 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14495
14496 dictcnt++;
14497
14498 dictfiles[dictcnt - 1] = l0_filename;
14499 }
14500 else
14501 {
14502 // do not allow --keyspace w/ a directory
14503
14504 if (keyspace == 1)
14505 {
14506 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14507
14508 return (-1);
14509 }
14510
14511 char **dictionary_files = NULL;
14512
14513 dictionary_files = scan_directory (l0_filename);
14514
14515 if (dictionary_files != NULL)
14516 {
14517 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14518
14519 for (int d = 0; dictionary_files[d] != NULL; d++)
14520 {
14521 char *l1_filename = dictionary_files[d];
14522
14523 struct stat l1_stat;
14524
14525 if (stat (l1_filename, &l1_stat) == -1)
14526 {
14527 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14528
14529 return (-1);
14530 }
14531
14532 if (S_ISREG (l1_stat.st_mode))
14533 {
14534 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14535
14536 dictcnt++;
14537
14538 dictfiles[dictcnt - 1] = strdup (l1_filename);
14539 }
14540 }
14541 }
14542
14543 local_free (dictionary_files);
14544 }
14545 }
14546
14547 if (dictcnt < 1)
14548 {
14549 log_error ("ERROR: No usable dictionary file found.");
14550
14551 return (-1);
14552 }
14553 }
14554 else if (wordlist_mode == WL_MODE_STDIN)
14555 {
14556 dictcnt = 1;
14557 }
14558 }
14559 else if (attack_mode == ATTACK_MODE_COMBI)
14560 {
14561 // display
14562
14563 char *dictfile1 = myargv[optind + 1 + 0];
14564 char *dictfile2 = myargv[optind + 1 + 1];
14565
14566 // find the bigger dictionary and use as base
14567
14568 FILE *fp1 = NULL;
14569 FILE *fp2 = NULL;
14570
14571 struct stat tmp_stat;
14572
14573 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14574 {
14575 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14576
14577 return (-1);
14578 }
14579
14580 if (stat (dictfile1, &tmp_stat) == -1)
14581 {
14582 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14583
14584 fclose (fp1);
14585
14586 return (-1);
14587 }
14588
14589 if (S_ISDIR (tmp_stat.st_mode))
14590 {
14591 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14592
14593 fclose (fp1);
14594
14595 return (-1);
14596 }
14597
14598 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14599 {
14600 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14601
14602 fclose (fp1);
14603
14604 return (-1);
14605 }
14606
14607 if (stat (dictfile2, &tmp_stat) == -1)
14608 {
14609 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14610
14611 fclose (fp1);
14612 fclose (fp2);
14613
14614 return (-1);
14615 }
14616
14617 if (S_ISDIR (tmp_stat.st_mode))
14618 {
14619 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14620
14621 fclose (fp1);
14622 fclose (fp2);
14623
14624 return (-1);
14625 }
14626
14627 data.combs_cnt = 1;
14628
14629 data.quiet = 1;
14630
14631 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14632
14633 data.quiet = quiet;
14634
14635 if (words1_cnt == 0)
14636 {
14637 log_error ("ERROR: %s: empty file", dictfile1);
14638
14639 fclose (fp1);
14640 fclose (fp2);
14641
14642 return (-1);
14643 }
14644
14645 data.combs_cnt = 1;
14646
14647 data.quiet = 1;
14648
14649 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14650
14651 data.quiet = quiet;
14652
14653 if (words2_cnt == 0)
14654 {
14655 log_error ("ERROR: %s: empty file", dictfile2);
14656
14657 fclose (fp1);
14658 fclose (fp2);
14659
14660 return (-1);
14661 }
14662
14663 fclose (fp1);
14664 fclose (fp2);
14665
14666 data.dictfile = dictfile1;
14667 data.dictfile2 = dictfile2;
14668
14669 if (words1_cnt >= words2_cnt)
14670 {
14671 data.combs_cnt = words2_cnt;
14672 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14673
14674 dictfiles = &data.dictfile;
14675
14676 dictcnt = 1;
14677 }
14678 else
14679 {
14680 data.combs_cnt = words1_cnt;
14681 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14682
14683 dictfiles = &data.dictfile2;
14684
14685 dictcnt = 1;
14686
14687 // we also have to switch wordlist related rules!
14688
14689 char *tmpc = data.rule_buf_l;
14690
14691 data.rule_buf_l = data.rule_buf_r;
14692 data.rule_buf_r = tmpc;
14693
14694 int tmpi = data.rule_len_l;
14695
14696 data.rule_len_l = data.rule_len_r;
14697 data.rule_len_r = tmpi;
14698 }
14699 }
14700 else if (attack_mode == ATTACK_MODE_BF)
14701 {
14702 char *mask = NULL;
14703
14704 maskcnt = 0;
14705
14706 if (benchmark == 0)
14707 {
14708 mask = myargv[optind + 1];
14709
14710 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14711
14712 if ((optind + 2) <= myargc)
14713 {
14714 struct stat file_stat;
14715
14716 if (stat (mask, &file_stat) == -1)
14717 {
14718 maskcnt = 1;
14719
14720 masks[maskcnt - 1] = mystrdup (mask);
14721 }
14722 else
14723 {
14724 int wls_left = myargc - (optind + 1);
14725
14726 uint masks_avail = INCR_MASKS;
14727
14728 for (int i = 0; i < wls_left; i++)
14729 {
14730 if (i != 0)
14731 {
14732 mask = myargv[optind + 1 + i];
14733
14734 if (stat (mask, &file_stat) == -1)
14735 {
14736 log_error ("ERROR: %s: %s", mask, strerror (errno));
14737
14738 return (-1);
14739 }
14740 }
14741
14742 uint is_file = S_ISREG (file_stat.st_mode);
14743
14744 if (is_file == 1)
14745 {
14746 FILE *mask_fp;
14747
14748 if ((mask_fp = fopen (mask, "r")) == NULL)
14749 {
14750 log_error ("ERROR: %s: %s", mask, strerror (errno));
14751
14752 return (-1);
14753 }
14754
14755 char line_buf[BUFSIZ] = { 0 };
14756
14757 while (!feof (mask_fp))
14758 {
14759 memset (line_buf, 0, BUFSIZ);
14760
14761 int line_len = fgetl (mask_fp, line_buf);
14762
14763 if (line_len == 0) continue;
14764
14765 if (line_buf[0] == '#') continue;
14766
14767 if (masks_avail == maskcnt)
14768 {
14769 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14770
14771 masks_avail += INCR_MASKS;
14772 }
14773
14774 masks[maskcnt] = mystrdup (line_buf);
14775
14776 maskcnt++;
14777 }
14778
14779 fclose (mask_fp);
14780 }
14781 else
14782 {
14783 log_error ("ERROR: %s: unsupported file-type", mask);
14784
14785 return (-1);
14786 }
14787 }
14788
14789 mask_from_file = 1;
14790 }
14791 }
14792 else
14793 {
14794 custom_charset_1 = (char *) "?l?d?u";
14795 custom_charset_2 = (char *) "?l?d";
14796 custom_charset_3 = (char *) "?l?d*!$@_";
14797
14798 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14799 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14800 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14801
14802 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14803
14804 wordlist_mode = WL_MODE_MASK;
14805
14806 data.wordlist_mode = wordlist_mode;
14807
14808 increment = 1;
14809
14810 maskcnt = 1;
14811 }
14812 }
14813 else
14814 {
14815 /**
14816 * generate full masks and charsets
14817 */
14818
14819 masks = (char **) mymalloc (sizeof (char *));
14820
14821 switch (hash_mode)
14822 {
14823 case 1731: pw_min = 5;
14824 pw_max = 5;
14825 mask = mystrdup ("?b?b?b?b?b");
14826 break;
14827 case 12500: pw_min = 5;
14828 pw_max = 5;
14829 mask = mystrdup ("?b?b?b?b?b");
14830 break;
14831 default: pw_min = 7;
14832 pw_max = 7;
14833 mask = mystrdup ("?b?b?b?b?b?b?b");
14834 break;
14835 }
14836
14837 maskcnt = 1;
14838
14839 masks[maskcnt - 1] = mystrdup (mask);
14840
14841 wordlist_mode = WL_MODE_MASK;
14842
14843 data.wordlist_mode = wordlist_mode;
14844
14845 increment = 1;
14846 }
14847
14848 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14849
14850 if (increment)
14851 {
14852 if (increment_min > pw_min) pw_min = increment_min;
14853
14854 if (increment_max < pw_max) pw_max = increment_max;
14855 }
14856 }
14857 else if (attack_mode == ATTACK_MODE_HYBRID1)
14858 {
14859 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14860
14861 // display
14862
14863 char *mask = myargv[myargc - 1];
14864
14865 maskcnt = 0;
14866
14867 masks = (char **) mymalloc (1 * sizeof (char *));
14868
14869 // mod
14870
14871 struct stat file_stat;
14872
14873 if (stat (mask, &file_stat) == -1)
14874 {
14875 maskcnt = 1;
14876
14877 masks[maskcnt - 1] = mystrdup (mask);
14878 }
14879 else
14880 {
14881 uint is_file = S_ISREG (file_stat.st_mode);
14882
14883 if (is_file == 1)
14884 {
14885 FILE *mask_fp;
14886
14887 if ((mask_fp = fopen (mask, "r")) == NULL)
14888 {
14889 log_error ("ERROR: %s: %s", mask, strerror (errno));
14890
14891 return (-1);
14892 }
14893
14894 char line_buf[BUFSIZ] = { 0 };
14895
14896 uint masks_avail = 1;
14897
14898 while (!feof (mask_fp))
14899 {
14900 memset (line_buf, 0, BUFSIZ);
14901
14902 int line_len = fgetl (mask_fp, line_buf);
14903
14904 if (line_len == 0) continue;
14905
14906 if (line_buf[0] == '#') continue;
14907
14908 if (masks_avail == maskcnt)
14909 {
14910 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14911
14912 masks_avail += INCR_MASKS;
14913 }
14914
14915 masks[maskcnt] = mystrdup (line_buf);
14916
14917 maskcnt++;
14918 }
14919
14920 fclose (mask_fp);
14921
14922 mask_from_file = 1;
14923 }
14924 else
14925 {
14926 maskcnt = 1;
14927
14928 masks[maskcnt - 1] = mystrdup (mask);
14929 }
14930 }
14931
14932 // base
14933
14934 int wls_left = myargc - (optind + 2);
14935
14936 for (int i = 0; i < wls_left; i++)
14937 {
14938 char *filename = myargv[optind + 1 + i];
14939
14940 struct stat file_stat;
14941
14942 if (stat (filename, &file_stat) == -1)
14943 {
14944 log_error ("ERROR: %s: %s", filename, strerror (errno));
14945
14946 return (-1);
14947 }
14948
14949 uint is_dir = S_ISDIR (file_stat.st_mode);
14950
14951 if (is_dir == 0)
14952 {
14953 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14954
14955 dictcnt++;
14956
14957 dictfiles[dictcnt - 1] = filename;
14958 }
14959 else
14960 {
14961 // do not allow --keyspace w/ a directory
14962
14963 if (keyspace == 1)
14964 {
14965 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14966
14967 return (-1);
14968 }
14969
14970 char **dictionary_files = NULL;
14971
14972 dictionary_files = scan_directory (filename);
14973
14974 if (dictionary_files != NULL)
14975 {
14976 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14977
14978 for (int d = 0; dictionary_files[d] != NULL; d++)
14979 {
14980 char *l1_filename = dictionary_files[d];
14981
14982 struct stat l1_stat;
14983
14984 if (stat (l1_filename, &l1_stat) == -1)
14985 {
14986 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14987
14988 return (-1);
14989 }
14990
14991 if (S_ISREG (l1_stat.st_mode))
14992 {
14993 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14994
14995 dictcnt++;
14996
14997 dictfiles[dictcnt - 1] = strdup (l1_filename);
14998 }
14999 }
15000 }
15001
15002 local_free (dictionary_files);
15003 }
15004 }
15005
15006 if (dictcnt < 1)
15007 {
15008 log_error ("ERROR: No usable dictionary file found.");
15009
15010 return (-1);
15011 }
15012
15013 if (increment)
15014 {
15015 maskcnt = 0;
15016
15017 uint mask_min = increment_min; // we can't reject smaller masks here
15018 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15019
15020 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15021 {
15022 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15023
15024 if (cur_mask == NULL) break;
15025
15026 masks[maskcnt] = cur_mask;
15027
15028 maskcnt++;
15029
15030 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15031 }
15032 }
15033 }
15034 else if (attack_mode == ATTACK_MODE_HYBRID2)
15035 {
15036 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15037
15038 // display
15039
15040 char *mask = myargv[optind + 1 + 0];
15041
15042 maskcnt = 0;
15043
15044 masks = (char **) mymalloc (1 * sizeof (char *));
15045
15046 // mod
15047
15048 struct stat file_stat;
15049
15050 if (stat (mask, &file_stat) == -1)
15051 {
15052 maskcnt = 1;
15053
15054 masks[maskcnt - 1] = mystrdup (mask);
15055 }
15056 else
15057 {
15058 uint is_file = S_ISREG (file_stat.st_mode);
15059
15060 if (is_file == 1)
15061 {
15062 FILE *mask_fp;
15063
15064 if ((mask_fp = fopen (mask, "r")) == NULL)
15065 {
15066 log_error ("ERROR: %s: %s", mask, strerror (errno));
15067
15068 return (-1);
15069 }
15070
15071 char line_buf[BUFSIZ] = { 0 };
15072
15073 uint masks_avail = 1;
15074
15075 while (!feof (mask_fp))
15076 {
15077 memset (line_buf, 0, BUFSIZ);
15078
15079 int line_len = fgetl (mask_fp, line_buf);
15080
15081 if (line_len == 0) continue;
15082
15083 if (line_buf[0] == '#') continue;
15084
15085 if (masks_avail == maskcnt)
15086 {
15087 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15088
15089 masks_avail += INCR_MASKS;
15090 }
15091
15092 masks[maskcnt] = mystrdup (line_buf);
15093
15094 maskcnt++;
15095 }
15096
15097 fclose (mask_fp);
15098
15099 mask_from_file = 1;
15100 }
15101 else
15102 {
15103 maskcnt = 1;
15104
15105 masks[maskcnt - 1] = mystrdup (mask);
15106 }
15107 }
15108
15109 // base
15110
15111 int wls_left = myargc - (optind + 2);
15112
15113 for (int i = 0; i < wls_left; i++)
15114 {
15115 char *filename = myargv[optind + 2 + i];
15116
15117 struct stat file_stat;
15118
15119 if (stat (filename, &file_stat) == -1)
15120 {
15121 log_error ("ERROR: %s: %s", filename, strerror (errno));
15122
15123 return (-1);
15124 }
15125
15126 uint is_dir = S_ISDIR (file_stat.st_mode);
15127
15128 if (is_dir == 0)
15129 {
15130 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15131
15132 dictcnt++;
15133
15134 dictfiles[dictcnt - 1] = filename;
15135 }
15136 else
15137 {
15138 // do not allow --keyspace w/ a directory
15139
15140 if (keyspace == 1)
15141 {
15142 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15143
15144 return (-1);
15145 }
15146
15147 char **dictionary_files = NULL;
15148
15149 dictionary_files = scan_directory (filename);
15150
15151 if (dictionary_files != NULL)
15152 {
15153 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15154
15155 for (int d = 0; dictionary_files[d] != NULL; d++)
15156 {
15157 char *l1_filename = dictionary_files[d];
15158
15159 struct stat l1_stat;
15160
15161 if (stat (l1_filename, &l1_stat) == -1)
15162 {
15163 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15164
15165 return (-1);
15166 }
15167
15168 if (S_ISREG (l1_stat.st_mode))
15169 {
15170 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15171
15172 dictcnt++;
15173
15174 dictfiles[dictcnt - 1] = strdup (l1_filename);
15175 }
15176 }
15177 }
15178
15179 local_free (dictionary_files);
15180 }
15181 }
15182
15183 if (dictcnt < 1)
15184 {
15185 log_error ("ERROR: No usable dictionary file found.");
15186
15187 return (-1);
15188 }
15189
15190 if (increment)
15191 {
15192 maskcnt = 0;
15193
15194 uint mask_min = increment_min; // we can't reject smaller masks here
15195 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15196
15197 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15198 {
15199 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15200
15201 if (cur_mask == NULL) break;
15202
15203 masks[maskcnt] = cur_mask;
15204
15205 maskcnt++;
15206
15207 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15208 }
15209 }
15210 }
15211
15212 data.pw_min = pw_min;
15213 data.pw_max = pw_max;
15214
15215 /**
15216 * weak hash check
15217 */
15218
15219 if (weak_hash_threshold >= salts_cnt)
15220 {
15221 uint first_device_id = 0;
15222
15223 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15224 {
15225 hc_device_param_t *device_param = &data.devices_param[device_id];
15226
15227 if (device_param->skipped) continue;
15228
15229 first_device_id = device_id;
15230
15231 break;
15232 }
15233
15234 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15235
15236 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15237 {
15238 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15239 }
15240 }
15241
15242 // Display hack, guarantee that there is at least one \r before real start
15243
15244 if (data.quiet == 0) log_info_nn ("");
15245
15246 /**
15247 * status and monitor threads
15248 */
15249
15250 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15251
15252 hc_thread_t i_thread = 0;
15253
15254 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15255 {
15256 hc_thread_create (i_thread, thread_keypress, &benchmark);
15257 }
15258
15259 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15260
15261 uint ni_threads_cnt = 0;
15262
15263 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15264
15265 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15266
15267 ni_threads_cnt++;
15268
15269 /**
15270 * Outfile remove
15271 */
15272
15273 if (keyspace == 0)
15274 {
15275 if (outfile_check_timer != 0)
15276 {
15277 if (data.outfile_check_directory != NULL)
15278 {
15279 if ((hash_mode != 5200) &&
15280 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15281 (hash_mode != 9000))
15282 {
15283 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15284
15285 ni_threads_cnt++;
15286 }
15287 else
15288 {
15289 outfile_check_timer = 0;
15290 }
15291 }
15292 else
15293 {
15294 outfile_check_timer = 0;
15295 }
15296 }
15297 }
15298
15299 /**
15300 * Inform the user if we got some hashes remove because of the pot file remove feature
15301 */
15302
15303 if (data.quiet == 0)
15304 {
15305 if (potfile_remove_cracks > 0)
15306 {
15307 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15308 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15309 }
15310 }
15311
15312 data.outfile_check_timer = outfile_check_timer;
15313
15314 /**
15315 * main loop
15316 */
15317
15318 char **induction_dictionaries = NULL;
15319
15320 int induction_dictionaries_cnt = 0;
15321
15322 hcstat_table_t *root_table_buf = NULL;
15323 hcstat_table_t *markov_table_buf = NULL;
15324
15325 uint initial_restore_done = 0;
15326
15327 data.maskcnt = maskcnt;
15328
15329 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15330 {
15331 if (data.devices_status == STATUS_CRACKED) break;
15332
15333 data.devices_status = STATUS_INIT;
15334
15335 if (maskpos > rd->maskpos)
15336 {
15337 rd->dictpos = 0;
15338 }
15339
15340 rd->maskpos = maskpos;
15341 data.maskpos = maskpos;
15342
15343 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15344 {
15345 char *mask = masks[maskpos];
15346
15347 if (mask_from_file == 1)
15348 {
15349 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15350
15351 char *str_ptr;
15352 uint str_pos;
15353
15354 uint mask_offset = 0;
15355
15356 uint separator_cnt;
15357
15358 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15359 {
15360 str_ptr = strstr (mask + mask_offset, ",");
15361
15362 if (str_ptr == NULL) break;
15363
15364 str_pos = str_ptr - mask;
15365
15366 // escaped separator, i.e. "\,"
15367
15368 if (str_pos > 0)
15369 {
15370 if (mask[str_pos - 1] == '\\')
15371 {
15372 separator_cnt --;
15373
15374 mask_offset = str_pos + 1;
15375
15376 continue;
15377 }
15378 }
15379
15380 // reset the offset
15381
15382 mask_offset = 0;
15383
15384 mask[str_pos] = '\0';
15385
15386 switch (separator_cnt)
15387 {
15388 case 0:
15389 mp_reset_usr (mp_usr, 0);
15390
15391 custom_charset_1 = mask;
15392 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15393 break;
15394
15395 case 1:
15396 mp_reset_usr (mp_usr, 1);
15397
15398 custom_charset_2 = mask;
15399 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15400 break;
15401
15402 case 2:
15403 mp_reset_usr (mp_usr, 2);
15404
15405 custom_charset_3 = mask;
15406 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15407 break;
15408
15409 case 3:
15410 mp_reset_usr (mp_usr, 3);
15411
15412 custom_charset_4 = mask;
15413 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15414 break;
15415 }
15416
15417 mask = mask + str_pos + 1;
15418 }
15419 }
15420
15421 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15422 {
15423 if (maskpos > 0)
15424 {
15425 local_free (css_buf);
15426 local_free (data.root_css_buf);
15427 local_free (data.markov_css_buf);
15428
15429 local_free (masks[maskpos - 1]);
15430 }
15431
15432 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15433
15434 data.mask = mask;
15435 data.css_cnt = css_cnt;
15436 data.css_buf = css_buf;
15437
15438 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15439
15440 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15441
15442 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15443 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15444
15445 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15446
15447 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15448
15449 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15450 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15451
15452 data.root_css_buf = root_css_buf;
15453 data.markov_css_buf = markov_css_buf;
15454
15455 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15456
15457 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15458
15459 local_free (root_table_buf);
15460 local_free (markov_table_buf);
15461
15462 // args
15463
15464 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15465 {
15466 hc_device_param_t *device_param = &data.devices_param[device_id];
15467
15468 if (device_param->skipped) continue;
15469
15470 device_param->kernel_params_mp[0] = &device_param->d_combs;
15471 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15472 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15473
15474 device_param->kernel_params_mp_buf64[3] = 0;
15475 device_param->kernel_params_mp_buf32[4] = css_cnt;
15476 device_param->kernel_params_mp_buf32[5] = 0;
15477 device_param->kernel_params_mp_buf32[6] = 0;
15478 device_param->kernel_params_mp_buf32[7] = 0;
15479
15480 if (attack_mode == ATTACK_MODE_HYBRID1)
15481 {
15482 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15483 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15484 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15485 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15486 }
15487 else if (attack_mode == ATTACK_MODE_HYBRID2)
15488 {
15489 device_param->kernel_params_mp_buf32[5] = 0;
15490 device_param->kernel_params_mp_buf32[6] = 0;
15491 device_param->kernel_params_mp_buf32[7] = 0;
15492 }
15493
15494 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15495 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15496 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15497
15498 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15499 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15500 }
15501 }
15502 else if (attack_mode == ATTACK_MODE_BF)
15503 {
15504 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15505
15506 if (increment)
15507 {
15508 for (uint i = 0; i < dictcnt; i++)
15509 {
15510 local_free (dictfiles[i]);
15511 }
15512
15513 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15514 {
15515 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15516
15517 if (l1_filename == NULL) break;
15518
15519 dictcnt++;
15520
15521 dictfiles[dictcnt - 1] = l1_filename;
15522 }
15523 }
15524 else
15525 {
15526 dictcnt++;
15527
15528 dictfiles[dictcnt - 1] = mask;
15529 }
15530
15531 if (dictcnt == 0)
15532 {
15533 log_error ("ERROR: Mask is too small");
15534
15535 return (-1);
15536 }
15537 }
15538 }
15539
15540 free (induction_dictionaries);
15541
15542 // induction_dictionaries_cnt = 0; // implied
15543
15544 if (attack_mode != ATTACK_MODE_BF)
15545 {
15546 if (keyspace == 0)
15547 {
15548 induction_dictionaries = scan_directory (induction_directory);
15549
15550 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15551 }
15552 }
15553
15554 if (induction_dictionaries_cnt)
15555 {
15556 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15557 }
15558
15559 /**
15560 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15561 */
15562 if (keyspace == 1)
15563 {
15564 if ((maskcnt > 1) || (dictcnt > 1))
15565 {
15566 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15567
15568 return (-1);
15569 }
15570 }
15571
15572 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15573 {
15574 char *subid = logfile_generate_subid ();
15575
15576 data.subid = subid;
15577
15578 logfile_sub_msg ("START");
15579
15580 data.devices_status = STATUS_INIT;
15581
15582 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15583 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15584 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15585
15586 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15587
15588 data.cpt_pos = 0;
15589
15590 data.cpt_start = time (NULL);
15591
15592 data.cpt_total = 0;
15593
15594 if (data.restore == 0)
15595 {
15596 rd->words_cur = skip;
15597
15598 skip = 0;
15599
15600 data.skip = 0;
15601 }
15602
15603 data.ms_paused = 0;
15604
15605 data.words_cur = rd->words_cur;
15606
15607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15608 {
15609 hc_device_param_t *device_param = &data.devices_param[device_id];
15610
15611 if (device_param->skipped) continue;
15612
15613 device_param->speed_pos = 0;
15614
15615 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15616 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15617 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15618
15619 device_param->kernel_power = device_param->kernel_power_user;
15620 device_param->kernel_blocks = device_param->kernel_blocks_user;
15621
15622 device_param->outerloop_pos = 0;
15623 device_param->outerloop_left = 0;
15624 device_param->innerloop_pos = 0;
15625 device_param->innerloop_left = 0;
15626
15627 // some more resets:
15628
15629 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15630
15631 memset (device_param->pws_buf, 0, device_param->size_pws);
15632
15633 device_param->pw_cnt = 0;
15634 device_param->pws_cnt = 0;
15635
15636 device_param->words_off = 0;
15637 device_param->words_done = 0;
15638 }
15639
15640 data.kernel_blocks_div = 0;
15641
15642 // figure out some workload
15643
15644 if (attack_mode == ATTACK_MODE_STRAIGHT)
15645 {
15646 if (data.wordlist_mode == WL_MODE_FILE)
15647 {
15648 char *dictfile = NULL;
15649
15650 if (induction_dictionaries_cnt)
15651 {
15652 dictfile = induction_dictionaries[0];
15653 }
15654 else
15655 {
15656 dictfile = dictfiles[dictpos];
15657 }
15658
15659 data.dictfile = dictfile;
15660
15661 logfile_sub_string (dictfile);
15662
15663 for (uint i = 0; i < rp_files_cnt; i++)
15664 {
15665 logfile_sub_var_string ("rulefile", rp_files[i]);
15666 }
15667
15668 FILE *fd2 = fopen (dictfile, "rb");
15669
15670 if (fd2 == NULL)
15671 {
15672 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15673
15674 return (-1);
15675 }
15676
15677 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15678
15679 fclose (fd2);
15680
15681 if (data.words_cnt == 0)
15682 {
15683 if (data.devices_status == STATUS_CRACKED) break;
15684 if (data.devices_status == STATUS_ABORTED) break;
15685
15686 dictpos++;
15687
15688 continue;
15689 }
15690 }
15691 }
15692 else if (attack_mode == ATTACK_MODE_COMBI)
15693 {
15694 char *dictfile = data.dictfile;
15695 char *dictfile2 = data.dictfile2;
15696
15697 logfile_sub_string (dictfile);
15698 logfile_sub_string (dictfile2);
15699
15700 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15701 {
15702 FILE *fd2 = fopen (dictfile, "rb");
15703
15704 if (fd2 == NULL)
15705 {
15706 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15707
15708 return (-1);
15709 }
15710
15711 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15712
15713 fclose (fd2);
15714 }
15715 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15716 {
15717 FILE *fd2 = fopen (dictfile2, "rb");
15718
15719 if (fd2 == NULL)
15720 {
15721 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15722
15723 return (-1);
15724 }
15725
15726 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15727
15728 fclose (fd2);
15729 }
15730
15731 if (data.words_cnt == 0)
15732 {
15733 if (data.devices_status == STATUS_CRACKED) break;
15734 if (data.devices_status == STATUS_ABORTED) break;
15735
15736 dictpos++;
15737
15738 continue;
15739 }
15740 }
15741 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15742 {
15743 char *dictfile = NULL;
15744
15745 if (induction_dictionaries_cnt)
15746 {
15747 dictfile = induction_dictionaries[0];
15748 }
15749 else
15750 {
15751 dictfile = dictfiles[dictpos];
15752 }
15753
15754 data.dictfile = dictfile;
15755
15756 char *mask = data.mask;
15757
15758 logfile_sub_string (dictfile);
15759 logfile_sub_string (mask);
15760
15761 FILE *fd2 = fopen (dictfile, "rb");
15762
15763 if (fd2 == NULL)
15764 {
15765 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15766
15767 return (-1);
15768 }
15769
15770 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15771
15772 fclose (fd2);
15773
15774 if (data.words_cnt == 0)
15775 {
15776 if (data.devices_status == STATUS_CRACKED) break;
15777 if (data.devices_status == STATUS_ABORTED) break;
15778
15779 dictpos++;
15780
15781 continue;
15782 }
15783 }
15784 else if (attack_mode == ATTACK_MODE_BF)
15785 {
15786 local_free (css_buf);
15787 local_free (data.root_css_buf);
15788 local_free (data.markov_css_buf);
15789
15790 char *mask = dictfiles[dictpos];
15791
15792 logfile_sub_string (mask);
15793
15794 // base
15795
15796 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15797
15798 if (opts_type & OPTS_TYPE_PT_UNICODE)
15799 {
15800 uint css_cnt_unicode = css_cnt * 2;
15801
15802 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15803
15804 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15805 {
15806 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15807
15808 css_buf_unicode[j + 1].cs_buf[0] = 0;
15809 css_buf_unicode[j + 1].cs_len = 1;
15810 }
15811
15812 free (css_buf);
15813
15814 css_buf = css_buf_unicode;
15815 css_cnt = css_cnt_unicode;
15816 }
15817
15818 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15819
15820 uint mask_min = pw_min;
15821 uint mask_max = pw_max;
15822
15823 if (opts_type & OPTS_TYPE_PT_UNICODE)
15824 {
15825 mask_min *= 2;
15826 mask_max *= 2;
15827 }
15828
15829 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15830 {
15831 if (css_cnt < mask_min)
15832 {
15833 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15834 }
15835
15836 if (css_cnt > mask_max)
15837 {
15838 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15839 }
15840
15841 // skip to next mask
15842
15843 dictpos++;
15844
15845 rd->dictpos = dictpos;
15846
15847 logfile_sub_msg ("STOP");
15848
15849 continue;
15850 }
15851
15852 uint save_css_cnt = css_cnt;
15853
15854 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15855 {
15856 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15857 {
15858 uint salt_len = (uint) data.salts_buf[0].salt_len;
15859 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15860
15861 uint css_cnt_salt = css_cnt + salt_len;
15862
15863 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15864
15865 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15866
15867 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15868 {
15869 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15870 css_buf_salt[j].cs_len = 1;
15871 }
15872
15873 free (css_buf);
15874
15875 css_buf = css_buf_salt;
15876 css_cnt = css_cnt_salt;
15877 }
15878 }
15879
15880 data.mask = mask;
15881 data.css_cnt = css_cnt;
15882 data.css_buf = css_buf;
15883
15884 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15885
15886 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15887
15888 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15889
15890 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15891 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15892
15893 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15894
15895 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15896
15897 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15898 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15899
15900 data.root_css_buf = root_css_buf;
15901 data.markov_css_buf = markov_css_buf;
15902
15903 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15904
15905 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15906
15907 local_free (root_table_buf);
15908 local_free (markov_table_buf);
15909
15910 // copy + args
15911
15912 uint css_cnt_l = css_cnt;
15913 uint css_cnt_r;
15914
15915 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15916 {
15917 if (save_css_cnt < 6)
15918 {
15919 css_cnt_r = 1;
15920 }
15921 else if (save_css_cnt == 6)
15922 {
15923 css_cnt_r = 2;
15924 }
15925 else
15926 {
15927 if (opts_type & OPTS_TYPE_PT_UNICODE)
15928 {
15929 if (save_css_cnt == 8 || save_css_cnt == 10)
15930 {
15931 css_cnt_r = 2;
15932 }
15933 else
15934 {
15935 css_cnt_r = 4;
15936 }
15937 }
15938 else
15939 {
15940 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15941 {
15942 css_cnt_r = 3;
15943 }
15944 else
15945 {
15946 css_cnt_r = 4;
15947 }
15948 }
15949 }
15950 }
15951 else
15952 {
15953 css_cnt_r = 1;
15954
15955 /* unfinished code?
15956 int sum = css_buf[css_cnt_r - 1].cs_len;
15957
15958 for (uint i = 1; i < 4 && i < css_cnt; i++)
15959 {
15960 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15961
15962 css_cnt_r++;
15963
15964 sum *= css_buf[css_cnt_r - 1].cs_len;
15965 }
15966 */
15967 }
15968
15969 css_cnt_l -= css_cnt_r;
15970
15971 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15972
15973 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15974 {
15975 hc_device_param_t *device_param = &data.devices_param[device_id];
15976
15977 if (device_param->skipped) continue;
15978
15979 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15980 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15981 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15982
15983 device_param->kernel_params_mp_l_buf64[3] = 0;
15984 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15985 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15986 device_param->kernel_params_mp_l_buf32[6] = 0;
15987 device_param->kernel_params_mp_l_buf32[7] = 0;
15988 device_param->kernel_params_mp_l_buf32[8] = 0;
15989
15990 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15991 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15992 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15993 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15994
15995 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15996 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15997 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15998
15999 device_param->kernel_params_mp_r_buf64[3] = 0;
16000 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16001 device_param->kernel_params_mp_r_buf32[5] = 0;
16002 device_param->kernel_params_mp_r_buf32[6] = 0;
16003 device_param->kernel_params_mp_r_buf32[7] = 0;
16004
16005 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
16006 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
16007 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
16008
16009 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
16010 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
16011 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
16012
16013 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16014 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16015 }
16016 }
16017
16018 u64 words_base = data.words_cnt;
16019
16020 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16021 {
16022 if (data.kernel_rules_cnt)
16023 {
16024 words_base /= data.kernel_rules_cnt;
16025 }
16026 }
16027 else if (data.attack_kern == ATTACK_KERN_COMBI)
16028 {
16029 if (data.combs_cnt)
16030 {
16031 words_base /= data.combs_cnt;
16032 }
16033 }
16034 else if (data.attack_kern == ATTACK_KERN_BF)
16035 {
16036 if (data.bfs_cnt)
16037 {
16038 words_base /= data.bfs_cnt;
16039 }
16040 }
16041
16042 data.words_base = words_base;
16043
16044 if (keyspace == 1)
16045 {
16046 log_info ("%llu", (unsigned long long int) words_base);
16047
16048 return (0);
16049 }
16050
16051 if (data.words_cur > data.words_base)
16052 {
16053 log_error ("ERROR: restore value greater keyspace");
16054
16055 return (-1);
16056 }
16057
16058 if (data.words_cur)
16059 {
16060 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16061 {
16062 for (uint i = 0; i < data.salts_cnt; i++)
16063 {
16064 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16065 }
16066 }
16067 else if (data.attack_kern == ATTACK_KERN_COMBI)
16068 {
16069 for (uint i = 0; i < data.salts_cnt; i++)
16070 {
16071 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16072 }
16073 }
16074 else if (data.attack_kern == ATTACK_KERN_BF)
16075 {
16076 for (uint i = 0; i < data.salts_cnt; i++)
16077 {
16078 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16079 }
16080 }
16081 }
16082
16083 /*
16084 * Inform user about possible slow speeds
16085 */
16086
16087 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16088 {
16089 if (data.words_base < kernel_blocks_all)
16090 {
16091 if (quiet == 0)
16092 {
16093 log_info ("");
16094 log_info ("ATTENTION!");
16095 log_info (" The wordlist or mask you are using is too small.");
16096 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16097 log_info (" The cracking speed will drop.");
16098 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16099 log_info ("");
16100 }
16101 }
16102 }
16103
16104 /*
16105 * Update loopback file
16106 */
16107
16108 if (loopback == 1)
16109 {
16110 time_t now;
16111
16112 time (&now);
16113
16114 uint random_num = get_random_num (0, 9999);
16115
16116 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16117
16118 data.loopback_file = loopback_file;
16119 }
16120
16121 /*
16122 * Update dictionary statistic
16123 */
16124
16125 if (keyspace == 0)
16126 {
16127 dictstat_fp = fopen (dictstat, "wb");
16128
16129 if (dictstat_fp)
16130 {
16131 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16132
16133 fclose (dictstat_fp);
16134 }
16135 }
16136
16137 data.devices_status = STATUS_RUNNING;
16138
16139 if (initial_restore_done == 0)
16140 {
16141 if (data.restore_disable == 0) cycle_restore ();
16142
16143 initial_restore_done = 1;
16144 }
16145
16146 hc_timer_set (&data.timer_running);
16147
16148 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16149 {
16150 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16151 {
16152 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16153 if (quiet == 0) fflush (stdout);
16154 }
16155 }
16156 else if (wordlist_mode == WL_MODE_STDIN)
16157 {
16158 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16159 if (data.quiet == 0) log_info ("");
16160 }
16161
16162 time_t runtime_start;
16163
16164 time (&runtime_start);
16165
16166 data.runtime_start = runtime_start;
16167
16168 /**
16169 * create cracker threads
16170 */
16171
16172 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16173
16174 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16175 {
16176 hc_device_param_t *device_param = &devices_param[device_id];
16177
16178 if (wordlist_mode == WL_MODE_STDIN)
16179 {
16180 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16181 }
16182 else
16183 {
16184 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16185 }
16186 }
16187
16188 // wait for crack threads to exit
16189
16190 hc_thread_wait (devices_cnt, c_threads);
16191
16192 local_free (c_threads);
16193
16194 data.restore = 0;
16195
16196 // finalize task
16197
16198 logfile_sub_var_uint ("status-after-work", data.devices_status);
16199
16200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16201
16202 if (data.devices_status == STATUS_CRACKED) break;
16203 if (data.devices_status == STATUS_ABORTED) break;
16204
16205 if (data.devices_status == STATUS_BYPASS)
16206 {
16207 data.devices_status = STATUS_RUNNING;
16208 }
16209
16210 if (induction_dictionaries_cnt)
16211 {
16212 unlink (induction_dictionaries[0]);
16213 }
16214
16215 free (induction_dictionaries);
16216
16217 if (attack_mode != ATTACK_MODE_BF)
16218 {
16219 induction_dictionaries = scan_directory (induction_directory);
16220
16221 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16222 }
16223
16224 if (benchmark == 0)
16225 {
16226 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16227 {
16228 if (quiet == 0) clear_prompt ();
16229
16230 if (quiet == 0) log_info ("");
16231
16232 if (status == 1)
16233 {
16234 status_display ();
16235 }
16236 else
16237 {
16238 if (quiet == 0) status_display ();
16239 }
16240
16241 if (quiet == 0) log_info ("");
16242 }
16243 }
16244
16245 if (attack_mode == ATTACK_MODE_BF)
16246 {
16247 dictpos++;
16248
16249 rd->dictpos = dictpos;
16250 }
16251 else
16252 {
16253 if (induction_dictionaries_cnt)
16254 {
16255 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16256 }
16257 else
16258 {
16259 dictpos++;
16260
16261 rd->dictpos = dictpos;
16262 }
16263 }
16264
16265 time_t runtime_stop;
16266
16267 time (&runtime_stop);
16268
16269 data.runtime_stop = runtime_stop;
16270
16271 logfile_sub_uint (runtime_start);
16272 logfile_sub_uint (runtime_stop);
16273
16274 logfile_sub_msg ("STOP");
16275
16276 global_free (subid);
16277 }
16278
16279 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16280
16281 if (data.devices_status == STATUS_CRACKED) break;
16282 if (data.devices_status == STATUS_ABORTED) break;
16283 if (data.devices_status == STATUS_QUIT) break;
16284
16285 if (data.devices_status == STATUS_BYPASS)
16286 {
16287 data.devices_status = STATUS_RUNNING;
16288 }
16289 }
16290
16291 // 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
16292
16293 if (attack_mode == ATTACK_MODE_STRAIGHT)
16294 {
16295 if (data.wordlist_mode == WL_MODE_FILE)
16296 {
16297 if (data.dictfile == NULL)
16298 {
16299 if (dictfiles != NULL)
16300 {
16301 data.dictfile = dictfiles[0];
16302
16303 hc_timer_set (&data.timer_running);
16304 }
16305 }
16306 }
16307 }
16308 // NOTE: combi is okay because it is already set beforehand
16309 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16310 {
16311 if (data.dictfile == NULL)
16312 {
16313 if (dictfiles != NULL)
16314 {
16315 hc_timer_set (&data.timer_running);
16316
16317 data.dictfile = dictfiles[0];
16318 }
16319 }
16320 }
16321 else if (attack_mode == ATTACK_MODE_BF)
16322 {
16323 if (data.mask == NULL)
16324 {
16325 hc_timer_set (&data.timer_running);
16326
16327 data.mask = masks[0];
16328 }
16329 }
16330
16331 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16332 {
16333 data.devices_status = STATUS_EXHAUSTED;
16334 }
16335
16336 // if cracked / aborted remove last induction dictionary
16337
16338 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16339 {
16340 struct stat induct_stat;
16341
16342 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16343 {
16344 unlink (induction_dictionaries[file_pos]);
16345 }
16346 }
16347
16348 // wait for non-interactive threads
16349
16350 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16351 {
16352 hc_thread_wait (1, &ni_threads[thread_idx]);
16353 }
16354
16355 local_free (ni_threads);
16356
16357 // wait for interactive threads
16358
16359 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16360 {
16361 hc_thread_wait (1, &i_thread);
16362 }
16363
16364 // we dont need restore file anymore
16365 if (data.restore_disable == 0)
16366 {
16367 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16368 {
16369 unlink (eff_restore_file);
16370 unlink (new_restore_file);
16371 }
16372 else
16373 {
16374 cycle_restore ();
16375 }
16376 }
16377
16378 // finally save left hashes
16379
16380 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16381 {
16382 save_hash ();
16383 }
16384
16385 /**
16386 * Clean up
16387 */
16388
16389 if (benchmark == 1)
16390 {
16391 status_benchmark ();
16392
16393 log_info ("");
16394 }
16395 else
16396 {
16397 if (quiet == 0) clear_prompt ();
16398
16399 if (quiet == 0) log_info ("");
16400
16401 if (status == 1)
16402 {
16403 status_display ();
16404 }
16405 else
16406 {
16407 if (quiet == 0) status_display ();
16408 }
16409
16410 if (quiet == 0) log_info ("");
16411 }
16412
16413 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16414 {
16415 hc_device_param_t *device_param = &data.devices_param[device_id];
16416
16417 if (device_param->skipped) continue;
16418
16419 local_free (device_param->result);
16420
16421 local_free (device_param->pw_caches);
16422
16423 local_free (device_param->combs_buf);
16424
16425 local_free (device_param->hooks_buf);
16426
16427 local_free (device_param->device_name);
16428
16429 local_free (device_param->device_name_chksum);
16430
16431 local_free (device_param->device_version);
16432
16433 local_free (device_param->driver_version);
16434
16435 if (device_param->pws_buf) myfree (device_param->pws_buf);
16436 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16437 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16438 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16439 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16440 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16441 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16442 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16443 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16444 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16445 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16446 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16447 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16448 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16449 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16450 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16451 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16452 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16453 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16454 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16455 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16456 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16457 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16458 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16459 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16460 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16461 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16462 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16463 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16464
16465 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16466 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16467 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16468 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16469 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16470 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16471 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16472 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16473 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16474 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16475 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16476
16477 if (device_param->program) hc_clReleaseProgram (device_param->program);
16478 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16479 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16480
16481 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16482 if (device_param->context) hc_clReleaseContext (device_param->context);
16483 }
16484
16485 // reset default fan speed
16486
16487 #ifdef HAVE_HWMON
16488 if (gpu_temp_disable == 0)
16489 {
16490 #ifdef HAVE_ADL
16491 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16492 {
16493 hc_thread_mutex_lock (mux_adl);
16494
16495 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16496 {
16497 hc_device_param_t *device_param = &data.devices_param[device_id];
16498
16499 if (device_param->skipped) continue;
16500
16501 if (data.hm_device[device_id].fan_supported == 1)
16502 {
16503 int fanspeed = temp_retain_fanspeed_value[device_id];
16504
16505 if (fanspeed == -1) continue;
16506
16507 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16508
16509 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16510 }
16511 }
16512
16513 hc_thread_mutex_unlock (mux_adl);
16514 }
16515 #endif // HAVE_ADL
16516 }
16517
16518 // reset power tuning
16519
16520 #ifdef HAVE_ADL
16521 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16522 {
16523 hc_thread_mutex_lock (mux_adl);
16524
16525 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16526 {
16527 hc_device_param_t *device_param = &data.devices_param[device_id];
16528
16529 if (device_param->skipped) continue;
16530
16531 if (data.hm_device[device_id].od_version == 6)
16532 {
16533 // check powertune capabilities first, if not available then skip device
16534
16535 int powertune_supported = 0;
16536
16537 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16538 {
16539 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16540
16541 return (-1);
16542 }
16543
16544 if (powertune_supported != 0)
16545 {
16546 // powercontrol settings
16547
16548 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16549 {
16550 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16551
16552 return (-1);
16553 }
16554
16555 // clocks
16556
16557 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16558
16559 performance_state->iNumberOfPerformanceLevels = 2;
16560
16561 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16562 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16563 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16564 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16565
16566 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16567 {
16568 log_info ("ERROR: Failed to restore ADL performance state");
16569
16570 return (-1);
16571 }
16572
16573 local_free (performance_state);
16574 }
16575 }
16576 }
16577
16578 hc_thread_mutex_unlock (mux_adl);
16579 }
16580 #endif // HAVE_ADL
16581
16582 if (gpu_temp_disable == 0)
16583 {
16584 #if defined(LINUX) && defined(HAVE_NVML)
16585 if (data.hm_dll_nv)
16586 {
16587 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16588
16589 hm_close (data.hm_dll_nv);
16590 }
16591 #endif
16592
16593 #if defined(WIN) && (HAVE_NVAPI)
16594 NvAPI_Unload ();
16595 #endif
16596
16597 #ifdef HAVE_ADL
16598 if (data.hm_dll_amd)
16599 {
16600 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16601
16602 hm_close (data.hm_dll_amd);
16603 }
16604 #endif
16605 }
16606 #endif // HAVE_HWMON
16607
16608 // free memory
16609
16610 local_free (masks);
16611
16612 local_free (dictstat_base);
16613
16614 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16615 {
16616 pot_t *pot_ptr = &pot[pot_pos];
16617
16618 hash_t *hash = &pot_ptr->hash;
16619
16620 local_free (hash->digest);
16621
16622 if (isSalted)
16623 {
16624 local_free (hash->salt);
16625 }
16626 }
16627
16628 local_free (pot);
16629
16630 local_free (all_kernel_rules_cnt);
16631 local_free (all_kernel_rules_buf);
16632
16633 local_free (wl_data->buf);
16634 local_free (wl_data);
16635
16636 local_free (bitmap_s1_a);
16637 local_free (bitmap_s1_b);
16638 local_free (bitmap_s1_c);
16639 local_free (bitmap_s1_d);
16640 local_free (bitmap_s2_a);
16641 local_free (bitmap_s2_b);
16642 local_free (bitmap_s2_c);
16643 local_free (bitmap_s2_d);
16644
16645 #ifdef HAVE_HWMON
16646 local_free (temp_retain_fanspeed_value);
16647 #ifdef HAVE_ADL
16648 local_free (od_clock_mem_status);
16649 local_free (od_power_control_status);
16650 #endif // ADL
16651 #endif
16652
16653 global_free (devices_param);
16654
16655 global_free (kernel_rules_buf);
16656
16657 global_free (root_css_buf);
16658 global_free (markov_css_buf);
16659
16660 global_free (digests_buf);
16661 global_free (digests_shown);
16662 global_free (digests_shown_tmp);
16663
16664 global_free (salts_buf);
16665 global_free (salts_shown);
16666
16667 global_free (esalts_buf);
16668
16669 global_free (words_progress_done);
16670 global_free (words_progress_rejected);
16671 global_free (words_progress_restored);
16672
16673 if (pot_fp) fclose (pot_fp);
16674
16675 if (data.devices_status == STATUS_QUIT) break;
16676 }
16677
16678 // destroy others mutex
16679
16680 hc_thread_mutex_delete (mux_dispatcher);
16681 hc_thread_mutex_delete (mux_counter);
16682 hc_thread_mutex_delete (mux_display);
16683 hc_thread_mutex_delete (mux_adl);
16684
16685 // free memory
16686
16687 local_free (eff_restore_file);
16688 local_free (new_restore_file);
16689
16690 local_free (rd);
16691
16692 // loopback
16693
16694 local_free (loopback_file);
16695
16696 if (loopback == 1) unlink (loopback_file);
16697
16698 // induction directory
16699
16700 if (induction_dir == NULL)
16701 {
16702 if (attack_mode != ATTACK_MODE_BF)
16703 {
16704 if (rmdir (induction_directory) == -1)
16705 {
16706 if (errno == ENOENT)
16707 {
16708 // good, we can ignore
16709 }
16710 else if (errno == ENOTEMPTY)
16711 {
16712 // good, we can ignore
16713 }
16714 else
16715 {
16716 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16717
16718 return (-1);
16719 }
16720 }
16721
16722 local_free (induction_directory);
16723 }
16724 }
16725
16726 // outfile-check directory
16727
16728 if (outfile_check_dir == NULL)
16729 {
16730 if (rmdir (outfile_check_directory) == -1)
16731 {
16732 if (errno == ENOENT)
16733 {
16734 // good, we can ignore
16735 }
16736 else if (errno == ENOTEMPTY)
16737 {
16738 // good, we can ignore
16739 }
16740 else
16741 {
16742 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16743
16744 return (-1);
16745 }
16746 }
16747
16748 local_free (outfile_check_directory);
16749 }
16750
16751 time_t proc_stop;
16752
16753 time (&proc_stop);
16754
16755 logfile_top_uint (proc_start);
16756 logfile_top_uint (proc_stop);
16757
16758 logfile_top_msg ("STOP");
16759
16760 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16761 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16762
16763 if (data.devices_status == STATUS_ABORTED) return 2;
16764 if (data.devices_status == STATUS_QUIT) return 2;
16765 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16766 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16767 if (data.devices_status == STATUS_CRACKED) return 0;
16768
16769 return -1;
16770 }
Hashcat additions to support pwdhash