projects / hashcat.git / blob
? search:


de96437c7de5e022ceb35c58f8936d1eaecbb7d4
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
400 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Reduced performance profile (low latency desktop)",
447 " 2 = Default performance profile",
448 " 3 = Tuned performance profile (high latency desktop)",
449 "",
450 "* Benchmark Settings:",
451 "",
452 " 0 = Manual Tuning",
453 " 1 = Performance Tuning, default",
454 "",
455 "* OpenCL device-types:",
456 "",
457 " 1 = CPU devices",
458 " 2 = GPU devices",
459 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
460 "",
461 "* Outfile Formats:",
462 "",
463 " 1 = hash[:salt]",
464 " 2 = plain",
465 " 3 = hash[:salt]:plain",
466 " 4 = hex_plain",
467 " 5 = hash[:salt]:hex_plain",
468 " 6 = plain:hex_plain",
469 " 7 = hash[:salt]:plain:hex_plain",
470 " 8 = crackpos",
471 " 9 = hash[:salt]:crackpos",
472 " 10 = plain:crackpos",
473 " 11 = hash[:salt]:plain:crackpos",
474 " 12 = hex_plain:crackpos",
475 " 13 = hash[:salt]:hex_plain:crackpos",
476 " 14 = plain:hex_plain:crackpos",
477 " 15 = hash[:salt]:plain:hex_plain:crackpos",
478 "",
479 "* Debug mode output formats (for hybrid mode only, by using rules):",
480 "",
481 " 1 = save finding rule",
482 " 2 = save original word",
483 " 3 = save original word and finding rule",
484 " 4 = save original word, finding rule and modified plain",
485 "",
486 "* Built-in charsets:",
487 "",
488 " ?l = abcdefghijklmnopqrstuvwxyz",
489 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
490 " ?d = 0123456789",
491 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
492 " ?a = ?l?u?d?s",
493 " ?b = 0x00 - 0xff",
494 "",
495 "* Attack modes:",
496 "",
497 " 0 = Straight",
498 " 1 = Combination",
499 " 3 = Brute-force",
500 " 6 = Hybrid dict + mask",
501 " 7 = Hybrid mask + dict",
502 "",
503 "* Hash types:",
504 "",
505 "[[ Roll-your-own: Raw Hashes ]]",
506 "",
507 " 900 = MD4",
508 " 0 = MD5",
509 " 5100 = Half MD5",
510 " 100 = SHA1",
511 " 10800 = SHA-384",
512 " 1400 = SHA-256",
513 " 1700 = SHA-512",
514 " 5000 = SHA-3(Keccak)",
515 " 10100 = SipHash",
516 " 6000 = RipeMD160",
517 " 6100 = Whirlpool",
518 " 6900 = GOST R 34.11-94",
519 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
520 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
521 "",
522 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
523 "",
524 " 10 = md5($pass.$salt)",
525 " 20 = md5($salt.$pass)",
526 " 30 = md5(unicode($pass).$salt)",
527 " 40 = md5($salt.unicode($pass))",
528 " 3800 = md5($salt.$pass.$salt)",
529 " 3710 = md5($salt.md5($pass))",
530 " 2600 = md5(md5($pass)",
531 " 4300 = md5(strtoupper(md5($pass)))",
532 " 4400 = md5(sha1($pass))",
533 " 110 = sha1($pass.$salt)",
534 " 120 = sha1($salt.$pass)",
535 " 130 = sha1(unicode($pass).$salt)",
536 " 140 = sha1($salt.unicode($pass))",
537 " 4500 = sha1(sha1($pass)",
538 " 4700 = sha1(md5($pass))",
539 " 4900 = sha1($salt.$pass.$salt)",
540 " 1410 = sha256($pass.$salt)",
541 " 1420 = sha256($salt.$pass)",
542 " 1430 = sha256(unicode($pass).$salt)",
543 " 1440 = sha256($salt.unicode($pass))",
544 " 1710 = sha512($pass.$salt)",
545 " 1720 = sha512($salt.$pass)",
546 " 1730 = sha512(unicode($pass).$salt)",
547 " 1740 = sha512($salt.unicode($pass))",
548 "",
549 "[[ Roll-your-own: Authenticated Hashes ]]",
550 "",
551 " 50 = HMAC-MD5 (key = $pass)",
552 " 60 = HMAC-MD5 (key = $salt)",
553 " 150 = HMAC-SHA1 (key = $pass)",
554 " 160 = HMAC-SHA1 (key = $salt)",
555 " 1450 = HMAC-SHA256 (key = $pass)",
556 " 1460 = HMAC-SHA256 (key = $salt)",
557 " 1750 = HMAC-SHA512 (key = $pass)",
558 " 1760 = HMAC-SHA512 (key = $salt)",
559 "",
560 "[[ Generic KDF ]]",
561 "",
562 " 400 = phpass",
563 " 8900 = scrypt",
564 " 11900 = PBKDF2-HMAC-MD5",
565 " 12000 = PBKDF2-HMAC-SHA1",
566 " 10900 = PBKDF2-HMAC-SHA256",
567 " 12100 = PBKDF2-HMAC-SHA512",
568 "",
569 "[[ Network protocols, Challenge-Response ]]",
570 "",
571 " 23 = Skype",
572 " 2500 = WPA/WPA2",
573 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
574 " 5300 = IKE-PSK MD5",
575 " 5400 = IKE-PSK SHA1",
576 " 5500 = NetNTLMv1",
577 " 5500 = NetNTLMv1 + ESS",
578 " 5600 = NetNTLMv2",
579 " 7300 = IPMI2 RAKP HMAC-SHA1",
580 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
581 " 8300 = DNSSEC (NSEC3)",
582 " 10200 = Cram MD5",
583 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
584 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
585 " 11400 = SIP digest authentication (MD5)",
586 "",
587 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
588 "",
589 " 121 = SMF (Simple Machines Forum)",
590 " 400 = phpBB3",
591 " 2611 = vBulletin < v3.8.5",
592 " 2711 = vBulletin > v3.8.5",
593 " 2811 = MyBB",
594 " 2811 = IPB (Invison Power Board)",
595 " 8400 = WBB3 (Woltlab Burning Board)",
596 " 11 = Joomla < 2.5.18",
597 " 400 = Joomla > 2.5.18",
598 " 400 = Wordpress",
599 " 2612 = PHPS",
600 " 7900 = Drupal7",
601 " 21 = osCommerce",
602 " 21 = xt:Commerce",
603 " 11000 = PrestaShop",
604 " 124 = Django (SHA-1)",
605 " 10000 = Django (PBKDF2-SHA256)",
606 " 3711 = Mediawiki B type",
607 " 7600 = Redmine",
608 "",
609 "[[ Database Server ]]",
610 "",
611 " 12 = PostgreSQL",
612 " 131 = MSSQL(2000)",
613 " 132 = MSSQL(2005)",
614 " 1731 = MSSQL(2012)",
615 " 1731 = MSSQL(2014)",
616 " 200 = MySQL323",
617 " 300 = MySQL4.1/MySQL5",
618 " 3100 = Oracle H: Type (Oracle 7+)",
619 " 112 = Oracle S: Type (Oracle 11+)",
620 " 12300 = Oracle T: Type (Oracle 12+)",
621 " 8000 = Sybase ASE",
622 "",
623 "[[ HTTP, SMTP, LDAP Server ]]",
624 "",
625 " 141 = EPiServer 6.x < v4",
626 " 1441 = EPiServer 6.x > v4",
627 " 1600 = Apache $apr1$",
628 " 12600 = ColdFusion 10+",
629 " 1421 = hMailServer",
630 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
631 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
632 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
633 "",
634 "[[ Checksums ]]",
635 "",
636 " 11500 = CRC32",
637 "",
638 "[[ Operating-Systems ]]",
639 "",
640 " 3000 = LM",
641 " 1000 = NTLM",
642 " 1100 = Domain Cached Credentials (DCC), MS Cache",
643 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
644 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
645 " 1500 = descrypt, DES(Unix), Traditional DES",
646 " 12400 = BSDiCrypt, Extended DES",
647 " 500 = md5crypt $1$, MD5(Unix)",
648 " 3200 = bcrypt $2*$, Blowfish(Unix)",
649 " 7400 = sha256crypt $5$, SHA256(Unix)",
650 " 1800 = sha512crypt $6$, SHA512(Unix)",
651 " 122 = OSX v10.4",
652 " 122 = OSX v10.5",
653 " 122 = OSX v10.6",
654 " 1722 = OSX v10.7",
655 " 7100 = OSX v10.8",
656 " 7100 = OSX v10.9",
657 " 7100 = OSX v10.10",
658 " 6300 = AIX {smd5}",
659 " 6700 = AIX {ssha1}",
660 " 6400 = AIX {ssha256}",
661 " 6500 = AIX {ssha512}",
662 " 2400 = Cisco-PIX",
663 " 2410 = Cisco-ASA",
664 " 500 = Cisco-IOS $1$",
665 " 5700 = Cisco-IOS $4$",
666 " 9200 = Cisco-IOS $8$",
667 " 9300 = Cisco-IOS $9$",
668 " 22 = Juniper Netscreen/SSG (ScreenOS)",
669 " 501 = Juniper IVE",
670 " 5800 = Android PIN",
671 " 8100 = Citrix Netscaler",
672 " 8500 = RACF",
673 " 7200 = GRUB 2",
674 " 9900 = Radmin2",
675 "",
676 "[[ Enterprise Application Software (EAS) ]]",
677 "",
678 " 7700 = SAP CODVN B (BCODE)",
679 " 7800 = SAP CODVN F/G (PASSCODE)",
680 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
681 " 8600 = Lotus Notes/Domino 5",
682 " 8700 = Lotus Notes/Domino 6",
683 " 9100 = Lotus Notes/Domino 8",
684 " 133 = PeopleSoft",
685 "",
686 "[[ Archives ]]",
687 "",
688 " 11600 = 7-Zip",
689 " 12500 = RAR3-hp",
690 " 13000 = RAR5",
691 "",
692 "[[ Full-Disk encryptions (FDE) ]]",
693 "",
694 " 62XY = TrueCrypt 5.0+",
695 " X = 1 = PBKDF2-HMAC-RipeMD160",
696 " X = 2 = PBKDF2-HMAC-SHA512",
697 " X = 3 = PBKDF2-HMAC-Whirlpool",
698 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
699 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
700 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
701 " Y = 3 = XTS 1536 bit (Ciphers: All)",
702 " 8800 = Android FDE < v4.3",
703 " 12900 = Android FDE (Samsung DEK)",
704 " 12200 = eCryptfs",
705 "",
706 "[[ Documents ]]",
707 "",
708 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
709 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
710 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
711 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
712 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
713 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
714 " 9400 = MS Office 2007",
715 " 9500 = MS Office 2010",
716 " 9600 = MS Office 2013",
717 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
718 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
719 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
720 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
721 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
722 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
723 "",
724 "[[ Password Managers ]]",
725 "",
726 " 9000 = Password Safe v2",
727 " 5200 = Password Safe v3",
728 " 6800 = Lastpass",
729 " 6600 = 1Password, agilekeychain",
730 " 8200 = 1Password, cloudkeychain",
731 " 11300 = Bitcoin/Litecoin wallet.dat",
732 " 12700 = Blockchain, My Wallet",
733 "",
734 NULL
735 };
736
737 /**
738 * oclHashcat specific functions
739 */
740
741 void status_display_automat ()
742 {
743 FILE *out = stdout;
744
745 fprintf (out, "STATUS\t%u\t", data.devices_status);
746
747 /**
748 * speed new
749 */
750
751 fprintf (out, "SPEED\t");
752
753 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
754 {
755 hc_device_param_t *device_param = &data.devices_param[device_id];
756
757 if (device_param->skipped) continue;
758
759 u64 speed_cnt = 0;
760 float speed_ms = 0;
761
762 for (int i = 0; i < SPEED_CACHE; i++)
763 {
764 float rec_ms;
765
766 hc_timer_get (device_param->speed_rec[i], rec_ms);
767
768 if (rec_ms > SPEED_MAXAGE) continue;
769
770 speed_cnt += device_param->speed_cnt[i];
771 speed_ms += device_param->speed_ms[i];
772 }
773
774 speed_cnt /= SPEED_CACHE;
775 speed_ms /= SPEED_CACHE;
776
777 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
778 }
779
780 /**
781 * exec time
782 */
783
784 fprintf (out, "EXEC_RUNTIME\t");
785
786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
787 {
788 hc_device_param_t *device_param = &data.devices_param[device_id];
789
790 if (device_param->skipped) continue;
791
792 double exec_ms_total = 0;
793
794 int exec_ms_cnt = 0;
795
796 for (int i = 0; i < EXEC_CACHE; i++)
797 {
798 double exec_ms = device_param->exec_ms[i];
799
800 if (exec_ms)
801 {
802 exec_ms_total += exec_ms;
803
804 exec_ms_cnt++;
805 }
806 }
807
808 exec_ms_total /= exec_ms_cnt;
809
810 fprintf (out, "%f\t", exec_ms_total);
811 }
812
813 /**
814 * words_cur
815 */
816
817 u64 words_cur = get_lowest_words_done ();
818
819 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
820
821 /**
822 * counter
823 */
824
825 uint salts_left = data.salts_cnt - data.salts_done;
826
827 if (salts_left == 0) salts_left = 1;
828
829 u64 progress_total = data.words_cnt * salts_left;
830
831 u64 all_done = 0;
832 u64 all_rejected = 0;
833 u64 all_restored = 0;
834
835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
836 {
837 if (salts_left > 1)
838 {
839 // otherwise the final cracked status shows 0/XXX progress
840
841 if (data.salts_shown[salt_pos] == 1) continue;
842 }
843
844 all_done += data.words_progress_done[salt_pos];
845 all_rejected += data.words_progress_rejected[salt_pos];
846 all_restored += data.words_progress_restored[salt_pos];
847 }
848
849 u64 progress_cur = all_restored + all_done + all_rejected;
850 u64 progress_end = progress_total;
851
852 u64 progress_skip = 0;
853
854 if (data.skip)
855 {
856 progress_skip = MIN (data.skip, data.words_base) * salts_left;
857
858 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
859 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
860 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
861 }
862
863 if (data.limit)
864 {
865 progress_end = MIN (data.limit, data.words_base) * salts_left;
866
867 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
868 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
869 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
870 }
871
872 u64 progress_cur_relative_skip = progress_cur - progress_skip;
873 u64 progress_end_relative_skip = progress_end - progress_skip;
874
875 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
876
877 /**
878 * cracks
879 */
880
881 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
882 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
883
884 /**
885 * temperature
886 */
887
888 #ifdef HAVE_HWMON
889 if (data.gpu_temp_disable == 0)
890 {
891 fprintf (out, "TEMP\t");
892
893 hc_thread_mutex_lock (mux_adl);
894
895 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
896 {
897 hc_device_param_t *device_param = &data.devices_param[device_id];
898
899 if (device_param->skipped) continue;
900
901 int temp = hm_get_temperature_with_device_id (device_id);
902
903 fprintf (out, "%d\t", temp);
904 }
905
906 hc_thread_mutex_unlock (mux_adl);
907 }
908 #endif // HAVE_HWMON
909
910 /**
911 * flush
912 */
913
914 #ifdef _WIN
915 fputc ('\r', out);
916 fputc ('\n', out);
917 #endif
918
919 #ifdef _POSIX
920 fputc ('\n', out);
921 #endif
922
923 fflush (out);
924 }
925
926 void status_display ()
927 {
928 if (data.devices_status == STATUS_INIT) return;
929 if (data.devices_status == STATUS_STARTING) return;
930 if (data.devices_status == STATUS_BYPASS) return;
931
932 if (data.status_automat == 1)
933 {
934 status_display_automat ();
935
936 return;
937 }
938
939 char tmp_buf[1000] = { 0 };
940
941 uint tmp_len = 0;
942
943 log_info ("Session.Name...: %s", data.session);
944
945 char *status_type = strstatus (data.devices_status);
946
947 uint hash_mode = data.hash_mode;
948
949 char *hash_type = strhashtype (hash_mode); // not a bug
950
951 log_info ("Status.........: %s", status_type);
952
953 /**
954 * show rules
955 */
956
957 if (data.rp_files_cnt)
958 {
959 uint i;
960
961 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
962 {
963 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
964 }
965
966 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
967
968 log_info ("Rules.Type.....: %s", tmp_buf);
969
970 tmp_len = 0;
971 }
972
973 if (data.rp_gen)
974 {
975 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
976
977 if (data.rp_gen_seed)
978 {
979 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
980 }
981 }
982
983 /**
984 * show input
985 */
986
987 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
988 {
989 if (data.wordlist_mode == WL_MODE_FILE)
990 {
991 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
992 }
993 else if (data.wordlist_mode == WL_MODE_STDIN)
994 {
995 log_info ("Input.Mode.....: Pipe");
996 }
997 }
998 else if (data.attack_mode == ATTACK_MODE_COMBI)
999 {
1000 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1001 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1002 }
1003 else if (data.attack_mode == ATTACK_MODE_BF)
1004 {
1005 char *mask = data.mask;
1006
1007 if (mask != NULL)
1008 {
1009 uint mask_len = data.css_cnt;
1010
1011 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1012
1013 if (mask_len > 0)
1014 {
1015 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1016 {
1017 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1018 {
1019 mask_len -= data.salts_buf[0].salt_len;
1020 }
1021 }
1022
1023 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1024
1025 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1026 }
1027
1028 if (data.maskcnt > 1)
1029 {
1030 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1031
1032 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1033 }
1034
1035 log_info ("Input.Mode.....: %s", tmp_buf);
1036 }
1037
1038 tmp_len = 0;
1039 }
1040 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1041 {
1042 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1043 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 }
1045 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1046 {
1047 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1048 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1049 }
1050
1051 if (data.digests_cnt == 1)
1052 {
1053 if (data.hash_mode == 2500)
1054 {
1055 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1056
1057 uint pke[25] = { 0 };
1058
1059 char *pke_ptr = (char *) pke;
1060
1061 for (uint i = 0; i < 25; i++)
1062 {
1063 pke[i] = byte_swap_32 (wpa->pke[i]);
1064 }
1065
1066 char mac1[6] = { 0 };
1067 char mac2[6] = { 0 };
1068
1069 memcpy (mac1, pke_ptr + 23, 6);
1070 memcpy (mac2, pke_ptr + 29, 6);
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 mac1[0] & 0xff,
1075 mac1[1] & 0xff,
1076 mac1[2] & 0xff,
1077 mac1[3] & 0xff,
1078 mac1[4] & 0xff,
1079 mac1[5] & 0xff,
1080 mac2[0] & 0xff,
1081 mac2[1] & 0xff,
1082 mac2[2] & 0xff,
1083 mac2[3] & 0xff,
1084 mac2[4] & 0xff,
1085 mac2[5] & 0xff);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[4096] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[4096] = { 0 };
1122 char out_buf2[4096] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 float speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 // we need to clear values (set to 0) because in case the device does
1151 // not get new candidates it idles around but speed display would
1152 // show it as working.
1153 // if we instantly set it to 0 after reading it happens that the
1154 // speed can be shown as zero if the users refreshes too fast.
1155 // therefore, we add a timestamp when a stat was recorded and if its
1156 // too old we will not use it
1157
1158 speed_cnt[device_id] = 0;
1159 speed_ms[device_id] = 0;
1160
1161 for (int i = 0; i < SPEED_CACHE; i++)
1162 {
1163 float rec_ms;
1164
1165 hc_timer_get (device_param->speed_rec[i], rec_ms);
1166
1167 if (rec_ms > SPEED_MAXAGE) continue;
1168
1169 speed_cnt[device_id] += device_param->speed_cnt[i];
1170 speed_ms[device_id] += device_param->speed_ms[i];
1171 }
1172
1173 speed_cnt[device_id] /= SPEED_CACHE;
1174 speed_ms[device_id] /= SPEED_CACHE;
1175 }
1176
1177 float hashes_all_ms = 0;
1178
1179 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1180
1181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1182 {
1183 hc_device_param_t *device_param = &data.devices_param[device_id];
1184
1185 if (device_param->skipped) continue;
1186
1187 hashes_dev_ms[device_id] = 0;
1188
1189 if (speed_ms[device_id])
1190 {
1191 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1192
1193 hashes_all_ms += hashes_dev_ms[device_id];
1194 }
1195 }
1196
1197 /**
1198 * exec time
1199 */
1200
1201 double exec_all_ms[DEVICES_MAX] = { 0 };
1202
1203 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1204 {
1205 hc_device_param_t *device_param = &data.devices_param[device_id];
1206
1207 if (device_param->skipped) continue;
1208
1209 double exec_ms_total = 0;
1210
1211 int exec_ms_cnt = 0;
1212
1213 for (int i = 0; i < EXEC_CACHE; i++)
1214 {
1215 double exec_ms = device_param->exec_ms[i];
1216
1217 if (exec_ms)
1218 {
1219 exec_ms_total += exec_ms;
1220
1221 exec_ms_cnt++;
1222 }
1223 }
1224
1225 exec_ms_total /= exec_ms_cnt;
1226
1227 exec_all_ms[device_id] = exec_ms_total;
1228 }
1229
1230 /**
1231 * timers
1232 */
1233
1234 float ms_running = 0;
1235
1236 hc_timer_get (data.timer_running, ms_running);
1237
1238 float ms_paused = data.ms_paused;
1239
1240 if (data.devices_status == STATUS_PAUSED)
1241 {
1242 float ms_paused_tmp = 0;
1243
1244 hc_timer_get (data.timer_paused, ms_paused_tmp);
1245
1246 ms_paused += ms_paused_tmp;
1247 }
1248
1249 #ifdef WIN
1250
1251 __time64_t sec_run = ms_running / 1000;
1252
1253 #else
1254
1255 time_t sec_run = ms_running / 1000;
1256
1257 #endif
1258
1259 if (sec_run)
1260 {
1261 char display_run[32] = { 0 };
1262
1263 struct tm tm_run;
1264
1265 struct tm *tmp = NULL;
1266
1267 #ifdef WIN
1268
1269 tmp = _gmtime64 (&sec_run);
1270
1271 #else
1272
1273 tmp = gmtime (&sec_run);
1274
1275 #endif
1276
1277 if (tmp != NULL)
1278 {
1279 memset (&tm_run, 0, sizeof (tm_run));
1280
1281 memcpy (&tm_run, tmp, sizeof (tm_run));
1282
1283 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1284
1285 char *start = ctime (&data.proc_start);
1286
1287 size_t start_len = strlen (start);
1288
1289 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1290 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1291
1292 log_info ("Time.Started...: %s (%s)", start, display_run);
1293 }
1294 }
1295 else
1296 {
1297 log_info ("Time.Started...: 0 secs");
1298 }
1299
1300 /**
1301 * counters
1302 */
1303
1304 uint salts_left = data.salts_cnt - data.salts_done;
1305
1306 if (salts_left == 0) salts_left = 1;
1307
1308 u64 progress_total = data.words_cnt * salts_left;
1309
1310 u64 all_done = 0;
1311 u64 all_rejected = 0;
1312 u64 all_restored = 0;
1313
1314 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1315 {
1316 if (salts_left > 1)
1317 {
1318 // otherwise the final cracked status shows 0/XXX progress
1319
1320 if (data.salts_shown[salt_pos] == 1) continue;
1321 }
1322
1323 all_done += data.words_progress_done[salt_pos];
1324 all_rejected += data.words_progress_rejected[salt_pos];
1325 all_restored += data.words_progress_restored[salt_pos];
1326 }
1327
1328 u64 progress_cur = all_restored + all_done + all_rejected;
1329 u64 progress_end = progress_total;
1330
1331 u64 progress_skip = 0;
1332
1333 if (data.skip)
1334 {
1335 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1336
1337 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1340 }
1341
1342 if (data.limit)
1343 {
1344 progress_end = MIN (data.limit, data.words_base) * salts_left;
1345
1346 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1347 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1348 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1349 }
1350
1351 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1352 u64 progress_end_relative_skip = progress_end - progress_skip;
1353
1354 float speed_ms_real = ms_running - ms_paused;
1355 u64 speed_plains_real = all_done;
1356
1357 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1358 {
1359 if (data.devices_status != STATUS_CRACKED)
1360 {
1361 u64 words_per_ms = 0;
1362
1363 if (speed_plains_real && speed_ms_real)
1364 {
1365 words_per_ms = speed_plains_real / speed_ms_real;
1366 }
1367
1368 #ifdef WIN
1369 __time64_t sec_etc = 0;
1370 #else
1371 time_t sec_etc = 0;
1372 #endif
1373
1374 if (words_per_ms)
1375 {
1376 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1377
1378 u64 ms_left = progress_left_relative_skip / words_per_ms;
1379
1380 sec_etc = ms_left / 1000;
1381 }
1382
1383 if (sec_etc == 0)
1384 {
1385 log_info ("Time.Estimated.: 0 secs");
1386 }
1387 else if ((u64) sec_etc > ETC_MAX)
1388 {
1389 log_info ("Time.Estimated.: > 10 Years");
1390 }
1391 else
1392 {
1393 char display_etc[32] = { 0 };
1394
1395 struct tm tm_etc;
1396
1397 struct tm *tmp = NULL;
1398
1399 #ifdef WIN
1400
1401 tmp = _gmtime64 (&sec_etc);
1402
1403 #else
1404
1405 tmp = gmtime (&sec_etc);
1406
1407 #endif
1408
1409 if (tmp != NULL)
1410 {
1411 memset (&tm_etc, 0, sizeof (tm_etc));
1412
1413 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1414
1415 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1416
1417 time_t now;
1418
1419 time (&now);
1420
1421 now += sec_etc;
1422
1423 char *etc = ctime (&now);
1424
1425 size_t etc_len = strlen (etc);
1426
1427 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1428 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1429
1430 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1431 }
1432 }
1433 }
1434 }
1435
1436 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1437 {
1438 hc_device_param_t *device_param = &data.devices_param[device_id];
1439
1440 if (device_param->skipped) continue;
1441
1442 char display_dev_cur[16] = { 0 };
1443
1444 strncpy (display_dev_cur, "0.00", 4);
1445
1446 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1447
1448 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1449 }
1450
1451 char display_all_cur[16] = { 0 };
1452
1453 strncpy (display_all_cur, "0.00", 4);
1454
1455 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1456
1457 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1458
1459 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1460 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1461
1462 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);
1463
1464 // crack-per-time
1465
1466 if (data.digests_cnt > 100)
1467 {
1468 time_t now = time (NULL);
1469
1470 int cpt_cur_min = 0;
1471 int cpt_cur_hour = 0;
1472 int cpt_cur_day = 0;
1473
1474 for (int i = 0; i < CPT_BUF; i++)
1475 {
1476 const uint cracked = data.cpt_buf[i].cracked;
1477 const time_t timestamp = data.cpt_buf[i].timestamp;
1478
1479 if ((timestamp + 60) > now)
1480 {
1481 cpt_cur_min += cracked;
1482 }
1483
1484 if ((timestamp + 3600) > now)
1485 {
1486 cpt_cur_hour += cracked;
1487 }
1488
1489 if ((timestamp + 86400) > now)
1490 {
1491 cpt_cur_day += cracked;
1492 }
1493 }
1494
1495 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1496 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1497 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1498
1499 if ((data.cpt_start + 86400) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_cur_hour,
1504 cpt_cur_day,
1505 cpt_avg_min,
1506 cpt_avg_hour,
1507 cpt_avg_day);
1508 }
1509 else if ((data.cpt_start + 3600) < now)
1510 {
1511 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1512 cpt_cur_min,
1513 cpt_cur_hour,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else if ((data.cpt_start + 60) < now)
1519 {
1520 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_cur_min,
1522 cpt_avg_min,
1523 cpt_avg_hour,
1524 cpt_avg_day);
1525 }
1526 else
1527 {
1528 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1529 cpt_avg_min,
1530 cpt_avg_hour,
1531 cpt_avg_day);
1532 }
1533 }
1534
1535 // Restore point
1536
1537 u64 restore_point = get_lowest_words_done ();
1538
1539 u64 restore_total = data.words_base;
1540
1541 float percent_restore = 0;
1542
1543 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1544
1545 if (progress_end_relative_skip)
1546 {
1547 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1548 {
1549 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1550 float percent_rejected = 0.0;
1551
1552 if (progress_cur)
1553 {
1554 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1555 }
1556
1557 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);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 if (percent_finished != 1)
1563 {
1564 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1565 }
1566 }
1567 }
1568 }
1569 else
1570 {
1571 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1572 {
1573 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1574 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1575
1576 if (data.restore_disable == 0)
1577 {
1578 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1579 }
1580 }
1581 else
1582 {
1583 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1584 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1585
1586 // --restore not allowed if stdin is used -- really? why?
1587
1588 //if (data.restore_disable == 0)
1589 //{
1590 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1591 //}
1592 }
1593 }
1594
1595 #ifdef HAVE_HWMON
1596 if (data.gpu_temp_disable == 0)
1597 {
1598 hc_thread_mutex_lock (mux_adl);
1599
1600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1601 {
1602 hc_device_param_t *device_param = &data.devices_param[device_id];
1603
1604 if (device_param->skipped) continue;
1605
1606 #define HM_STR_BUF_SIZE 255
1607
1608 if (data.hm_device[device_id].fan_supported == 1)
1609 {
1610 char utilization[HM_STR_BUF_SIZE] = { 0 };
1611 char temperature[HM_STR_BUF_SIZE] = { 0 };
1612 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1613
1614 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1615 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1616
1617 if (device_param->vendor_id == VENDOR_ID_AMD)
1618 {
1619 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1620 }
1621 else if (device_param->vendor_id == VENDOR_ID_NV)
1622 {
1623 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1624 }
1625
1626 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1627 }
1628 else
1629 {
1630 char utilization[HM_STR_BUF_SIZE] = { 0 };
1631 char temperature[HM_STR_BUF_SIZE] = { 0 };
1632
1633 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1634 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1635
1636 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1637 }
1638 }
1639
1640 hc_thread_mutex_unlock (mux_adl);
1641 }
1642 #endif // HAVE_HWMON
1643 }
1644
1645 static void status_benchmark ()
1646 {
1647 if (data.devices_status == STATUS_INIT) return;
1648 if (data.devices_status == STATUS_STARTING) return;
1649
1650 if (data.words_cnt == 0) return;
1651
1652 u64 speed_cnt[DEVICES_MAX] = { 0 };
1653 float speed_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 speed_cnt[device_id] = 0;
1662 speed_ms[device_id] = 0;
1663
1664 for (int i = 0; i < SPEED_CACHE; i++)
1665 {
1666 speed_cnt[device_id] += device_param->speed_cnt[i];
1667 speed_ms[device_id] += device_param->speed_ms[i];
1668 }
1669
1670 speed_cnt[device_id] /= SPEED_CACHE;
1671 speed_ms[device_id] /= SPEED_CACHE;
1672 }
1673
1674 float hashes_all_ms = 0;
1675
1676 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1677
1678 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1679 {
1680 hc_device_param_t *device_param = &data.devices_param[device_id];
1681
1682 if (device_param->skipped) continue;
1683
1684 hashes_dev_ms[device_id] = 0;
1685
1686 if (speed_ms[device_id])
1687 {
1688 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1689
1690 hashes_all_ms += hashes_dev_ms[device_id];
1691 }
1692 }
1693
1694 /**
1695 * exec time
1696 */
1697
1698 double exec_all_ms[DEVICES_MAX] = { 0 };
1699
1700 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1701 {
1702 hc_device_param_t *device_param = &data.devices_param[device_id];
1703
1704 if (device_param->skipped) continue;
1705
1706 double exec_ms_total = 0;
1707
1708 int exec_ms_cnt = 0;
1709
1710 for (int i = 0; i < EXEC_CACHE; i++)
1711 {
1712 double exec_ms = device_param->exec_ms[i];
1713
1714 if (exec_ms)
1715 {
1716 exec_ms_total += exec_ms;
1717
1718 exec_ms_cnt++;
1719 }
1720 }
1721
1722 exec_ms_total /= exec_ms_cnt;
1723
1724 exec_all_ms[device_id] = exec_ms_total;
1725 }
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 char display_dev_cur[16] = { 0 };
1734
1735 strncpy (display_dev_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1738
1739 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1740 }
1741
1742 char display_all_cur[16] = { 0 };
1743
1744 strncpy (display_all_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1747
1748 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1749 }
1750
1751 /**
1752 * oclHashcat -only- functions
1753 */
1754
1755 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1756 {
1757 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1758 {
1759 if (attack_kern == ATTACK_KERN_STRAIGHT)
1760 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1761 else if (attack_kern == ATTACK_KERN_COMBI)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_BF)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1765 }
1766 else
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1768 }
1769
1770 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)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1792 }
1793 else
1794 {
1795 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1796 }
1797 }
1798
1799 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)
1800 {
1801 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1802 {
1803 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1812 {
1813 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1814 }
1815
1816 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1819 }
1820
1821 static uint convert_from_hex (char *line_buf, const uint line_len)
1822 {
1823 if (line_len & 1) return (line_len); // not in hex
1824
1825 if (data.hex_wordlist == 1)
1826 {
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839 else if (line_len >= 6) // $HEX[] = 6
1840 {
1841 if (line_buf[0] != '$') return (line_len);
1842 if (line_buf[1] != 'H') return (line_len);
1843 if (line_buf[2] != 'E') return (line_len);
1844 if (line_buf[3] != 'X') return (line_len);
1845 if (line_buf[4] != '[') return (line_len);
1846 if (line_buf[line_len - 1] != ']') return (line_len);
1847
1848 uint i;
1849 uint j;
1850
1851 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1852 {
1853 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1854 }
1855
1856 memset (line_buf + i, 0, line_len - i);
1857
1858 return (i);
1859 }
1860
1861 return (line_len);
1862 }
1863
1864 static void clear_prompt ()
1865 {
1866 fputc ('\r', stdout);
1867
1868 for (size_t i = 0; i < strlen (PROMPT); i++)
1869 {
1870 fputc (' ', stdout);
1871 }
1872
1873 fputc ('\r', stdout);
1874
1875 fflush (stdout);
1876 }
1877
1878 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1879 {
1880 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1881 }
1882
1883 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1884 {
1885 char *outfile = data.outfile;
1886 uint quiet = data.quiet;
1887 FILE *pot_fp = data.pot_fp;
1888 uint loopback = data.loopback;
1889 uint debug_mode = data.debug_mode;
1890 char *debug_file = data.debug_file;
1891
1892 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1893 int debug_rule_len = 0; // -1 error
1894 uint debug_plain_len = 0;
1895
1896 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1897
1898 // hash
1899
1900 char out_buf[4096] = { 0 };
1901
1902 ascii_digest (out_buf, salt_pos, digest_pos);
1903
1904 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1905
1906 // plain
1907
1908 plain_t plain;
1909
1910 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1911
1912 uint gidvid = plain.gidvid;
1913 uint il_pos = plain.il_pos;
1914
1915 u64 crackpos = device_param->words_off;
1916
1917 uint plain_buf[16] = { 0 };
1918
1919 u8 *plain_ptr = (u8 *) plain_buf;
1920 unsigned int plain_len = 0;
1921
1922 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
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.h.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 const uint off = device_param->innerloop_pos + il_pos;
1939
1940 if (debug_mode > 0)
1941 {
1942 debug_rule_len = 0;
1943
1944 // save rule
1945 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1946 {
1947 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1948
1949 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1950 }
1951
1952 // save plain
1953 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1954 {
1955 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1956
1957 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1958
1959 debug_plain_len = plain_len;
1960 }
1961 }
1962
1963 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1964
1965 crackpos += gidvid;
1966 crackpos *= data.kernel_rules_cnt;
1967 crackpos += device_param->innerloop_pos + il_pos;
1968
1969 if (plain_len > data.pw_max) plain_len = data.pw_max;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_COMBI)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.h.hi1[0][j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1988 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1989
1990 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1991 {
1992 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1993 }
1994 else
1995 {
1996 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1997
1998 memcpy (plain_ptr, comb_buf, comb_len);
1999 }
2000
2001 plain_len += comb_len;
2002
2003 crackpos += gidvid;
2004 crackpos *= data.combs_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006
2007 if (data.pw_max != PW_DICTMAX1)
2008 {
2009 if (plain_len > data.pw_max) plain_len = data.pw_max;
2010 }
2011 }
2012 else if (data.attack_mode == ATTACK_MODE_BF)
2013 {
2014 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2015 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2016
2017 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2018 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2019
2020 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2021 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2022
2023 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2024 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2025
2026 plain_len = data.css_cnt;
2027
2028 crackpos += gidvid;
2029 crackpos *= data.bfs_cnt;
2030 crackpos += device_param->innerloop_pos + il_pos;
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2033 {
2034 u64 gidd = gidvid;
2035 u64 gidm = 0;
2036
2037 pw_t pw;
2038
2039 gidd_to_pw_t (device_param, gidd, &pw);
2040
2041 for (int i = 0, j = gidm; i < 16; i++, j++)
2042 {
2043 plain_buf[i] = pw.h.hi1[0][j];
2044 }
2045
2046 plain_len = pw.pw_len;
2047
2048 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2049
2050 uint start = 0;
2051 uint stop = device_param->kernel_params_mp_buf32[4];
2052
2053 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2054
2055 plain_len += start + stop;
2056
2057 crackpos += gidvid;
2058 crackpos *= data.combs_cnt;
2059 crackpos += device_param->innerloop_pos + il_pos;
2060
2061 if (data.pw_max != PW_DICTMAX1)
2062 {
2063 if (plain_len > data.pw_max) plain_len = data.pw_max;
2064 }
2065 }
2066 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2067 {
2068 u64 gidd = gidvid;
2069 u64 gidm = 0;
2070
2071 pw_t pw;
2072
2073 gidd_to_pw_t (device_param, gidd, &pw);
2074
2075 for (int i = 0, j = gidm; i < 16; i++, j++)
2076 {
2077 plain_buf[i] = pw.h.hi1[0][j];
2078 }
2079
2080 plain_len = pw.pw_len;
2081
2082 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2083
2084 uint start = 0;
2085 uint stop = device_param->kernel_params_mp_buf32[4];
2086
2087 memmove (plain_ptr + stop, plain_ptr, plain_len);
2088
2089 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2090
2091 plain_len += start + stop;
2092
2093 crackpos += gidvid;
2094 crackpos *= data.combs_cnt;
2095 crackpos += device_param->innerloop_pos + il_pos;
2096
2097 if (data.pw_max != PW_DICTMAX1)
2098 {
2099 if (plain_len > data.pw_max) plain_len = data.pw_max;
2100 }
2101 }
2102
2103 if (data.attack_mode == ATTACK_MODE_BF)
2104 {
2105 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2106 {
2107 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2108 {
2109 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2110 {
2111 plain_len = plain_len - data.salts_buf[0].salt_len;
2112 }
2113 }
2114
2115 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2116 {
2117 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2118 {
2119 plain_ptr[j] = plain_ptr[i];
2120 }
2121
2122 plain_len = plain_len / 2;
2123 }
2124 }
2125 }
2126
2127 // if enabled, update also the potfile
2128
2129 if (pot_fp)
2130 {
2131 lock_file (pot_fp);
2132
2133 fprintf (pot_fp, "%s:", out_buf);
2134
2135 format_plain (pot_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', pot_fp);
2138
2139 fflush (pot_fp);
2140
2141 unlock_file (pot_fp);
2142 }
2143
2144 // outfile
2145
2146 FILE *out_fp = NULL;
2147
2148 if (outfile != NULL)
2149 {
2150 if ((out_fp = fopen (outfile, "ab")) == NULL)
2151 {
2152 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2153
2154 out_fp = stdout;
2155 }
2156 lock_file (out_fp);
2157 }
2158 else
2159 {
2160 out_fp = stdout;
2161
2162 if (quiet == 0) clear_prompt ();
2163 }
2164
2165 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2166
2167 if (outfile != NULL)
2168 {
2169 if (out_fp != stdout)
2170 {
2171 fclose (out_fp);
2172 }
2173 }
2174 else
2175 {
2176 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2177 {
2178 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2179 {
2180 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2181 if (quiet == 0) fflush (stdout);
2182 }
2183 }
2184 }
2185
2186 // loopback
2187
2188 if (loopback)
2189 {
2190 char *loopback_file = data.loopback_file;
2191
2192 FILE *fb_fp = NULL;
2193
2194 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2195 {
2196 lock_file (fb_fp);
2197
2198 format_plain (fb_fp, plain_ptr, plain_len, 1);
2199
2200 fputc ('\n', fb_fp);
2201
2202 fclose (fb_fp);
2203 }
2204 }
2205
2206 // (rule) debug mode
2207
2208 // the next check implies that:
2209 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2210 // - debug_mode > 0
2211
2212 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2213 {
2214 if (debug_rule_len < 0) debug_rule_len = 0;
2215
2216 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2217
2218 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2219
2220 if ((quiet == 0) && (debug_file == NULL))
2221 {
2222 fprintf (stdout, "%s", PROMPT);
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 int found = 0;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2235
2236 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2237
2238 if (found == 1)
2239 {
2240 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2241
2242 log_info_nn ("");
2243
2244 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2249 {
2250 uint idx = salt_buf->digests_offset + digest_pos;
2251
2252 if (data.digests_shown_tmp[idx] == 0) continue;
2253
2254 if (data.digests_shown[idx] == 1) continue;
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[idx] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 check_hash (device_param, salt_pos, digest_pos);
2277 }
2278
2279 if (cpt_cracked > 0)
2280 {
2281 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2282 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2283
2284 data.cpt_pos++;
2285
2286 data.cpt_total += cpt_cracked;
2287
2288 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2289 }
2290
2291 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2292 {
2293 // we need to reset cracked state on the device
2294 // otherwise host thinks again and again the hash was cracked
2295 // and returns invalid password each time
2296
2297 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2298
2299 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2300 }
2301
2302 memset (device_param->result, 0, device_param->size_results);
2303
2304 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2305 }
2306 }
2307
2308 static void save_hash ()
2309 {
2310 char *hashfile = data.hashfile;
2311
2312 char new_hashfile[256] = { 0 };
2313 char old_hashfile[256] = { 0 };
2314
2315 snprintf (new_hashfile, 255, "%s.new", hashfile);
2316 snprintf (old_hashfile, 255, "%s.old", hashfile);
2317
2318 unlink (new_hashfile);
2319
2320 char separator = data.separator;
2321
2322 FILE *fp = fopen (new_hashfile, "wb");
2323
2324 if (fp == NULL)
2325 {
2326 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2327
2328 exit (-1);
2329 }
2330
2331 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2332 {
2333 if (data.salts_shown[salt_pos] == 1) continue;
2334
2335 salt_t *salt_buf = &data.salts_buf[salt_pos];
2336
2337 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2338 {
2339 uint idx = salt_buf->digests_offset + digest_pos;
2340
2341 if (data.digests_shown[idx] == 1) continue;
2342
2343 if (data.hash_mode != 2500)
2344 {
2345 char out_buf[4096] = { 0 };
2346
2347 if (data.username == 1)
2348 {
2349 user_t *user = data.hash_info[idx]->user;
2350
2351 uint i;
2352
2353 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2354
2355 fputc (separator, fp);
2356 }
2357
2358 ascii_digest (out_buf, salt_pos, digest_pos);
2359
2360 fputs (out_buf, fp);
2361
2362 log_out (fp, "");
2363 }
2364 else
2365 {
2366 hccap_t hccap;
2367
2368 to_hccap_t (&hccap, salt_pos, digest_pos);
2369
2370 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2371 }
2372 }
2373 }
2374
2375 fflush (fp);
2376
2377 fclose (fp);
2378
2379 unlink (old_hashfile);
2380
2381 if (rename (hashfile, old_hashfile) != 0)
2382 {
2383 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2384
2385 exit (-1);
2386 }
2387
2388 unlink (hashfile);
2389
2390 if (rename (new_hashfile, hashfile) != 0)
2391 {
2392 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2393
2394 exit (-1);
2395 }
2396
2397 unlink (old_hashfile);
2398 }
2399
2400 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2401 {
2402 // function called only in case kernel_blocks_all > words_left)
2403
2404 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2405
2406 kernel_blocks_div += kernel_blocks_div / 100;
2407
2408 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2409
2410 while (kernel_blocks_new < total_left)
2411 {
2412 kernel_blocks_div += kernel_blocks_div / 100;
2413
2414 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2415 }
2416
2417 if (data.quiet == 0)
2418 {
2419 clear_prompt ();
2420
2421 log_info ("");
2422
2423 log_info ("INFO: approaching final keyspace, workload adjusted");
2424
2425 log_info ("");
2426
2427 fprintf (stdout, "%s", PROMPT);
2428
2429 fflush (stdout);
2430 }
2431
2432 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2433
2434 return kernel_blocks_div;
2435 }
2436
2437 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2438 {
2439 uint num_elements = num;
2440
2441 device_param->kernel_params_buf32[30] = data.combs_mode;
2442 device_param->kernel_params_buf32[31] = num;
2443
2444 uint kernel_threads = device_param->kernel_threads;
2445
2446 while (num_elements % kernel_threads) num_elements++;
2447
2448 cl_kernel kernel = NULL;
2449
2450 switch (kern_run)
2451 {
2452 case KERN_RUN_1: kernel = device_param->kernel1; break;
2453 case KERN_RUN_12: kernel = device_param->kernel12; break;
2454 case KERN_RUN_2: kernel = device_param->kernel2; break;
2455 case KERN_RUN_23: kernel = device_param->kernel23; break;
2456 case KERN_RUN_3: kernel = device_param->kernel3; break;
2457 }
2458
2459 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2460 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2461 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2462 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2463 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2464 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2465 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2466 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2467 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2468 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2469 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2470
2471 cl_event event;
2472
2473 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2474 {
2475 const size_t global_work_size[3] = { num_elements, 32, 1 };
2476 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2477
2478 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2479 }
2480 else
2481 {
2482 const size_t global_work_size[3] = { num_elements, 1, 1 };
2483 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2484
2485 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2486
2487 if (rc != CL_SUCCESS)
2488 {
2489 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2490
2491 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2492 }
2493 }
2494
2495 hc_clFlush (data.ocl, device_param->command_queue);
2496
2497 hc_clWaitForEvents (data.ocl, 1, &event);
2498
2499 if (event_update)
2500 {
2501 cl_ulong time_start;
2502 cl_ulong time_end;
2503
2504 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2505 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2506
2507 const double exec_time = (time_end - time_start) / 1000000.0;
2508
2509 uint exec_pos = device_param->exec_pos;
2510
2511 device_param->exec_ms[exec_pos] = exec_time;
2512
2513 exec_pos++;
2514
2515 if (exec_pos == EXEC_CACHE)
2516 {
2517 exec_pos = 0;
2518 }
2519
2520 device_param->exec_pos = exec_pos;
2521 }
2522
2523 hc_clReleaseEvent (data.ocl, event);
2524
2525 hc_clFinish (data.ocl, device_param->command_queue);
2526 }
2527
2528 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2529 {
2530 uint num_elements = num;
2531
2532 switch (kern_run)
2533 {
2534 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2535 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2536 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2537 }
2538
2539 // causes problems with special threads like in bcrypt
2540 // const uint kernel_threads = device_param->kernel_threads;
2541
2542 const uint kernel_threads = KERNEL_THREADS;
2543
2544 while (num_elements % kernel_threads) num_elements++;
2545
2546 cl_kernel kernel = NULL;
2547
2548 switch (kern_run)
2549 {
2550 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2551 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2552 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2553 }
2554
2555 switch (kern_run)
2556 {
2557 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2558 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2559 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2560 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2561 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2562 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2563 break;
2564 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2565 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2566 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2567 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2568 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2569 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2570 break;
2571 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2572 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2573 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2574 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2575 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2576 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2577 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2578 break;
2579 }
2580
2581 const size_t global_work_size[3] = { num_elements, 1, 1 };
2582 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2583
2584 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2585
2586 if (rc != CL_SUCCESS)
2587 {
2588 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2589
2590 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2591 }
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2599 {
2600 uint num_elements = num;
2601
2602 uint kernel_threads = device_param->kernel_threads;
2603
2604 while (num_elements % kernel_threads) num_elements++;
2605
2606 cl_kernel kernel = device_param->kernel_tb;
2607
2608 const size_t global_work_size[3] = { num_elements, 1, 1 };
2609 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2610
2611 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2612
2613 if (rc != CL_SUCCESS)
2614 {
2615 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2616
2617 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2618 }
2619
2620 hc_clFlush (data.ocl, device_param->command_queue);
2621
2622 hc_clFinish (data.ocl, device_param->command_queue);
2623 }
2624
2625 static void run_kernel_tm (hc_device_param_t *device_param)
2626 {
2627 const uint num_elements = 1024; // fixed
2628
2629 const uint kernel_threads = 32;
2630
2631 cl_kernel kernel = device_param->kernel_tm;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2637
2638 if (rc != CL_SUCCESS)
2639 {
2640 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2641
2642 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2643 }
2644
2645 hc_clFlush (data.ocl, device_param->command_queue);
2646
2647 hc_clFinish (data.ocl, device_param->command_queue);
2648 }
2649
2650 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2651 {
2652 uint num_elements = num;
2653
2654 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2655 device_param->kernel_params_amp_buf32[6] = num_elements;
2656
2657 // causes problems with special threads like in bcrypt
2658 // const uint kernel_threads = device_param->kernel_threads;
2659
2660 const uint kernel_threads = KERNEL_THREADS;
2661
2662 while (num_elements % kernel_threads) num_elements++;
2663
2664 cl_kernel kernel = device_param->kernel_amp;
2665
2666 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2667 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2668
2669 const size_t global_work_size[3] = { num_elements, 1, 1 };
2670 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2671
2672 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2673
2674 if (rc != CL_SUCCESS)
2675 {
2676 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2677
2678 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2679 }
2680
2681 hc_clFlush (data.ocl, device_param->command_queue);
2682
2683 hc_clFinish (data.ocl, device_param->command_queue);
2684 }
2685
2686 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2687 {
2688 int rc = -1;
2689
2690 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2691 {
2692 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2693
2694 const cl_uchar zero = 0;
2695
2696 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2697 }
2698
2699 if (rc != 0)
2700 {
2701 // NOTE: clEnqueueFillBuffer () always fails with -59
2702 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2703 // How's that possible, OpenCL 1.2 support is advertised??
2704 // We need to workaround...
2705
2706 #define FILLSZ 0x100000
2707
2708 char *tmp = (char *) mymalloc (FILLSZ);
2709
2710 for (uint i = 0; i < size; i += FILLSZ)
2711 {
2712 const int left = size - i;
2713
2714 const int fillsz = MIN (FILLSZ, left);
2715
2716 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2717 }
2718
2719 myfree (tmp);
2720 }
2721 }
2722
2723 static int run_rule_engine (const int rule_len, const char *rule_buf)
2724 {
2725 if (rule_len == 0)
2726 {
2727 return 0;
2728 }
2729 else if (rule_len == 1)
2730 {
2731 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2732 }
2733
2734 return 1;
2735 }
2736
2737 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2738 {
2739 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2740 {
2741 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2742 }
2743 else if (data.attack_kern == ATTACK_KERN_COMBI)
2744 {
2745 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2746 }
2747 else if (data.attack_kern == ATTACK_KERN_BF)
2748 {
2749 const u64 off = device_param->words_off;
2750
2751 device_param->kernel_params_mp_l_buf64[3] = off;
2752
2753 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2754 }
2755 }
2756
2757 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2758 {
2759 const uint kernel_loops = device_param->kernel_loops;
2760
2761 //only useful in debug
2762 //if (data.quiet == 0)
2763 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2764
2765 // init speed timer
2766
2767 uint speed_pos = device_param->speed_pos;
2768
2769 #ifdef _POSIX
2770 if (device_param->timer_speed.tv_sec == 0)
2771 {
2772 hc_timer_set (&device_param->timer_speed);
2773 }
2774 #endif
2775
2776 #ifdef _WIN
2777 if (device_param->timer_speed.QuadPart == 0)
2778 {
2779 hc_timer_set (&device_param->timer_speed);
2780 }
2781 #endif
2782
2783 // find higest password length, this is for optimization stuff
2784
2785 uint highest_pw_len = 0;
2786
2787 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2788 {
2789 }
2790 else if (data.attack_kern == ATTACK_KERN_COMBI)
2791 {
2792 }
2793 else if (data.attack_kern == ATTACK_KERN_BF)
2794 {
2795 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2796 + device_param->kernel_params_mp_l_buf32[5];
2797 }
2798
2799 // bitslice optimization stuff
2800
2801 if (data.attack_mode == ATTACK_MODE_BF)
2802 {
2803 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2804 {
2805 run_kernel_tb (device_param, pws_cnt);
2806 }
2807 }
2808
2809 // iteration type
2810
2811 uint innerloop_step = 0;
2812 uint innerloop_cnt = 0;
2813
2814 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2815 else innerloop_step = 1;
2816
2817 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2818 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2819 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2820
2821 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2822
2823 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2824 {
2825 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2826
2827 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2828
2829 if (data.devices_status == STATUS_CRACKED) break;
2830 if (data.devices_status == STATUS_ABORTED) break;
2831 if (data.devices_status == STATUS_QUIT) break;
2832 if (data.devices_status == STATUS_BYPASS) break;
2833
2834 if (data.salts_shown[salt_pos] == 1) continue;
2835
2836 salt_t *salt_buf = &data.salts_buf[salt_pos];
2837
2838 device_param->kernel_params_buf32[24] = salt_pos;
2839 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2840 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2841
2842 FILE *combs_fp = device_param->combs_fp;
2843
2844 if (data.attack_mode == ATTACK_MODE_COMBI)
2845 {
2846 rewind (combs_fp);
2847 }
2848
2849 // innerloops
2850
2851 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2852 {
2853 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2854
2855 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2856
2857 if (data.devices_status == STATUS_CRACKED) break;
2858 if (data.devices_status == STATUS_ABORTED) break;
2859 if (data.devices_status == STATUS_QUIT) break;
2860 if (data.devices_status == STATUS_BYPASS) break;
2861
2862 uint innerloop_left = innerloop_cnt - innerloop_pos;
2863
2864 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2865
2866 device_param->innerloop_pos = innerloop_pos;
2867 device_param->innerloop_left = innerloop_left;
2868
2869 device_param->kernel_params_buf32[27] = innerloop_left;
2870
2871 if (innerloop_left == 0) continue;
2872
2873 // initialize amplifiers
2874
2875 if (data.attack_mode == ATTACK_MODE_COMBI)
2876 {
2877 char line_buf[BUFSIZ] = { 0 };
2878
2879 uint i = 0;
2880
2881 while (i < innerloop_left)
2882 {
2883 if (feof (combs_fp)) break;
2884
2885 int line_len = fgetl (combs_fp, line_buf);
2886
2887 if (line_len >= PW_MAX1) continue;
2888
2889 line_len = convert_from_hex (line_buf, line_len);
2890
2891 char *line_buf_new = line_buf;
2892
2893 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2894 {
2895 char rule_buf_out[BLOCK_SIZE] = { 0 };
2896
2897 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2898
2899 if (rule_len_out < 0)
2900 {
2901 data.words_progress_rejected[salt_pos] += pw_cnt;
2902
2903 continue;
2904 }
2905
2906 line_len = rule_len_out;
2907
2908 line_buf_new = rule_buf_out;
2909 }
2910
2911 line_len = MIN (line_len, PW_DICTMAX);
2912
2913 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2914
2915 memcpy (ptr, line_buf_new, line_len);
2916
2917 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2918
2919 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2920 {
2921 uppercase (ptr, line_len);
2922 }
2923
2924 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2925 {
2926 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2927 {
2928 ptr[line_len] = 0x80;
2929 }
2930
2931 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2932 {
2933 ptr[line_len] = 0x01;
2934 }
2935 }
2936
2937 device_param->combs_buf[i].pw_len = line_len;
2938
2939 i++;
2940 }
2941
2942 for (uint j = i; j < innerloop_left; j++)
2943 {
2944 device_param->combs_buf[j].i[0] = 0;
2945 device_param->combs_buf[j].i[1] = 0;
2946 device_param->combs_buf[j].i[2] = 0;
2947 device_param->combs_buf[j].i[3] = 0;
2948 device_param->combs_buf[j].i[4] = 0;
2949 device_param->combs_buf[j].i[5] = 0;
2950 device_param->combs_buf[j].i[6] = 0;
2951 device_param->combs_buf[j].i[7] = 0;
2952
2953 device_param->combs_buf[j].pw_len = 0;
2954 }
2955
2956 innerloop_left = i;
2957 }
2958 else if (data.attack_mode == ATTACK_MODE_BF)
2959 {
2960 u64 off = innerloop_pos;
2961
2962 device_param->kernel_params_mp_r_buf64[3] = off;
2963
2964 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2965 }
2966 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2967 {
2968 u64 off = innerloop_pos;
2969
2970 device_param->kernel_params_mp_buf64[3] = off;
2971
2972 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2973 }
2974 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2975 {
2976 u64 off = innerloop_pos;
2977
2978 device_param->kernel_params_mp_buf64[3] = off;
2979
2980 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2981 }
2982
2983 // copy amplifiers
2984
2985 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2986 {
2987 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2988 }
2989 else if (data.attack_mode == ATTACK_MODE_COMBI)
2990 {
2991 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2992 }
2993 else if (data.attack_mode == ATTACK_MODE_BF)
2994 {
2995 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2996 }
2997 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2998 {
2999 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3000 }
3001 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3002 {
3003 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3004 }
3005
3006 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3007 {
3008 if (data.attack_mode == ATTACK_MODE_BF)
3009 {
3010 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3011 {
3012 const uint size_tm = 32 * sizeof (bs_word_t);
3013
3014 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3015
3016 run_kernel_tm (device_param);
3017
3018 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
3019 }
3020 }
3021
3022 if (highest_pw_len < 16)
3023 {
3024 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3025 }
3026 else if (highest_pw_len < 32)
3027 {
3028 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3029 }
3030 else
3031 {
3032 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3033 }
3034 }
3035 else
3036 {
3037 run_kernel_amp (device_param, pws_cnt);
3038
3039 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3040
3041 if (data.opts_type & OPTS_TYPE_HOOK12)
3042 {
3043 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3044 }
3045
3046 uint iter = salt_buf->salt_iter;
3047
3048 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
3049 {
3050 uint loop_left = iter - loop_pos;
3051
3052 loop_left = MIN (loop_left, kernel_loops);
3053
3054 device_param->kernel_params_buf32[25] = loop_pos;
3055 device_param->kernel_params_buf32[26] = loop_left;
3056
3057 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3058
3059 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3060
3061 if (data.devices_status == STATUS_CRACKED) break;
3062 if (data.devices_status == STATUS_ABORTED) break;
3063 if (data.devices_status == STATUS_QUIT) break;
3064 }
3065
3066 if (data.opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3069
3070 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3071
3072 // do something with data
3073
3074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3078 }
3079
3080 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3081
3082 if (data.devices_status == STATUS_CRACKED) break;
3083 if (data.devices_status == STATUS_ABORTED) break;
3084 if (data.devices_status == STATUS_QUIT) break;
3085
3086 /**
3087 * result
3088 */
3089
3090 hc_thread_mutex_lock (mux_display);
3091
3092 check_cracked (device_param, salt_pos);
3093
3094 hc_thread_mutex_unlock (mux_display);
3095
3096 /**
3097 * progress
3098 */
3099
3100 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3101
3102 hc_thread_mutex_lock (mux_counter);
3103
3104 data.words_progress_done[salt_pos] += perf_sum_all;
3105
3106 hc_thread_mutex_unlock (mux_counter);
3107
3108 /**
3109 * speed
3110 */
3111
3112 float speed_ms;
3113
3114 hc_timer_get (device_param->timer_speed, speed_ms);
3115
3116 hc_timer_set (&device_param->timer_speed);
3117
3118 hc_thread_mutex_lock (mux_display);
3119
3120 device_param->speed_cnt[speed_pos] = perf_sum_all;
3121
3122 device_param->speed_ms[speed_pos] = speed_ms;
3123
3124 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3125
3126 hc_thread_mutex_unlock (mux_display);
3127
3128 speed_pos++;
3129
3130 if (speed_pos == SPEED_CACHE)
3131 {
3132 speed_pos = 0;
3133 }
3134 }
3135 }
3136
3137 device_param->speed_pos = speed_pos;
3138 }
3139
3140 static void load_segment (wl_data_t *wl_data, FILE *fd)
3141 {
3142 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3143
3144 wl_data->pos = 0;
3145
3146 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3147
3148 wl_data->buf[wl_data->cnt] = 0;
3149
3150 if (wl_data->cnt == 0) return;
3151
3152 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3153
3154 while (!feof (fd))
3155 {
3156 if (wl_data->cnt == wl_data->avail)
3157 {
3158 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3159
3160 wl_data->avail += wl_data->incr;
3161 }
3162
3163 const int c = fgetc (fd);
3164
3165 if (c == EOF) break;
3166
3167 wl_data->buf[wl_data->cnt] = (char) c;
3168
3169 wl_data->cnt++;
3170
3171 if (c == '\n') break;
3172 }
3173
3174 // ensure stream ends with a newline
3175
3176 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3177 {
3178 wl_data->cnt++;
3179
3180 wl_data->buf[wl_data->cnt - 1] = '\n';
3181 }
3182
3183 return;
3184 }
3185
3186 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3187 {
3188 char *ptr = buf;
3189
3190 for (u32 i = 0; i < sz; i++, ptr++)
3191 {
3192 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3193
3194 if (i == 7)
3195 {
3196 *off = i;
3197 *len = i;
3198
3199 return;
3200 }
3201
3202 if (*ptr != '\n') continue;
3203
3204 *off = i + 1;
3205
3206 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3207
3208 *len = i;
3209
3210 return;
3211 }
3212
3213 *off = sz;
3214 *len = sz;
3215 }
3216
3217 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3218 {
3219 char *ptr = buf;
3220
3221 for (u32 i = 0; i < sz; i++, ptr++)
3222 {
3223 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3224
3225 if (*ptr != '\n') continue;
3226
3227 *off = i + 1;
3228
3229 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3230
3231 *len = i;
3232
3233 return;
3234 }
3235
3236 *off = sz;
3237 *len = sz;
3238 }
3239
3240 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3241 {
3242 char *ptr = buf;
3243
3244 for (u32 i = 0; i < sz; i++, ptr++)
3245 {
3246 if (*ptr != '\n') continue;
3247
3248 *off = i + 1;
3249
3250 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3251
3252 *len = i;
3253
3254 return;
3255 }
3256
3257 *off = sz;
3258 *len = sz;
3259 }
3260
3261 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3262 {
3263 while (wl_data->pos < wl_data->cnt)
3264 {
3265 uint off;
3266 uint len;
3267
3268 char *ptr = wl_data->buf + wl_data->pos;
3269
3270 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3271
3272 wl_data->pos += off;
3273
3274 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3275 {
3276 char rule_buf_out[BLOCK_SIZE] = { 0 };
3277
3278 int rule_len_out = -1;
3279
3280 if (len < BLOCK_SIZE)
3281 {
3282 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3283 }
3284
3285 if (rule_len_out < 0)
3286 {
3287 continue;
3288 }
3289
3290 if (rule_len_out > PW_MAX)
3291 {
3292 continue;
3293 }
3294 }
3295 else
3296 {
3297 if (len > PW_MAX)
3298 {
3299 continue;
3300 }
3301 }
3302
3303 *out_buf = ptr;
3304 *out_len = len;
3305
3306 return;
3307 }
3308
3309 if (feof (fd))
3310 {
3311 fprintf (stderr, "bug!!\n");
3312
3313 return;
3314 }
3315
3316 load_segment (wl_data, fd);
3317
3318 get_next_word (wl_data, fd, out_buf, out_len);
3319 }
3320
3321 #ifdef _POSIX
3322 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3323 #endif
3324
3325 #ifdef _WIN
3326 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3327 #endif
3328 {
3329 hc_signal (NULL);
3330
3331 dictstat_t d;
3332
3333 d.cnt = 0;
3334
3335 #ifdef _POSIX
3336 fstat (fileno (fd), &d.stat);
3337 #endif
3338
3339 #ifdef _WIN
3340 _fstat64 (fileno (fd), &d.stat);
3341 #endif
3342
3343 d.stat.st_mode = 0;
3344 d.stat.st_nlink = 0;
3345 d.stat.st_uid = 0;
3346 d.stat.st_gid = 0;
3347 d.stat.st_rdev = 0;
3348 d.stat.st_atime = 0;
3349
3350 #ifdef _POSIX
3351 d.stat.st_blksize = 0;
3352 d.stat.st_blocks = 0;
3353 #endif
3354
3355 if (d.stat.st_size == 0) return 0;
3356
3357 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3358
3359 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3360 {
3361 if (d_cache)
3362 {
3363 u64 cnt = d_cache->cnt;
3364
3365 u64 keyspace = cnt;
3366
3367 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3368 {
3369 keyspace *= data.kernel_rules_cnt;
3370 }
3371 else if (data.attack_kern == ATTACK_KERN_COMBI)
3372 {
3373 keyspace *= data.combs_cnt;
3374 }
3375
3376 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);
3377 if (data.quiet == 0) log_info ("");
3378
3379 hc_signal (sigHandler_default);
3380
3381 return (keyspace);
3382 }
3383 }
3384
3385 time_t now = 0;
3386 time_t prev = 0;
3387
3388 u64 comp = 0;
3389 u64 cnt = 0;
3390 u64 cnt2 = 0;
3391
3392 while (!feof (fd))
3393 {
3394 load_segment (wl_data, fd);
3395
3396 comp += wl_data->cnt;
3397
3398 u32 i = 0;
3399
3400 while (i < wl_data->cnt)
3401 {
3402 u32 len;
3403 u32 off;
3404
3405 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3406
3407 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3408 {
3409 char rule_buf_out[BLOCK_SIZE] = { 0 };
3410
3411 int rule_len_out = -1;
3412
3413 if (len < BLOCK_SIZE)
3414 {
3415 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3416 }
3417
3418 if (rule_len_out < 0)
3419 {
3420 len = PW_MAX1;
3421 }
3422 else
3423 {
3424 len = rule_len_out;
3425 }
3426 }
3427
3428 if (len < PW_MAX1)
3429 {
3430 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3431 {
3432 cnt += data.kernel_rules_cnt;
3433 }
3434 else if (data.attack_kern == ATTACK_KERN_COMBI)
3435 {
3436 cnt += data.combs_cnt;
3437 }
3438
3439 d.cnt++;
3440 }
3441
3442 i += off;
3443
3444 cnt2++;
3445 }
3446
3447 time (&now);
3448
3449 if ((now - prev) == 0) continue;
3450
3451 float percent = (float) comp / (float) d.stat.st_size;
3452
3453 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);
3454
3455 time (&prev);
3456 }
3457
3458 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);
3459 if (data.quiet == 0) log_info ("");
3460
3461 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3462
3463 hc_signal (sigHandler_default);
3464
3465 return (cnt);
3466 }
3467
3468 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3469 {
3470 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3471 }
3472
3473 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3474 {
3475 if (data.devices_status == STATUS_BYPASS) return 0;
3476
3477 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3478
3479 uint cache_cnt = pw_cache->cnt;
3480
3481 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3482
3483 memcpy (pw_hc1, pw_buf, pw_len);
3484
3485 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3486
3487 uint pws_cnt = device_param->pws_cnt;
3488
3489 cache_cnt++;
3490
3491 pw_t *pw = device_param->pws_buf + pws_cnt;
3492
3493 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3494
3495 pw->pw_len = pw_len;
3496
3497 pws_cnt++;
3498
3499 device_param->pws_cnt = pws_cnt;
3500 device_param->pw_cnt = pws_cnt * 1;
3501
3502 cache_cnt = 0;
3503
3504 pw_cache->cnt = cache_cnt;
3505
3506 return pws_cnt;
3507 }
3508
3509 static void *thread_monitor (void *p)
3510 {
3511 uint runtime_check = 0;
3512 uint remove_check = 0;
3513 uint status_check = 0;
3514 uint restore_check = 0;
3515
3516 uint restore_left = data.restore_timer;
3517 uint remove_left = data.remove_timer;
3518 uint status_left = data.status_timer;
3519
3520 #ifdef HAVE_HWMON
3521 uint hwmon_check = 0;
3522
3523 // these variables are mainly used for fan control (AMD only)
3524
3525 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3526
3527 // temperature controller "loopback" values
3528
3529 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3530 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3531
3532 #ifdef HAVE_ADL
3533 int temp_threshold = 1; // degrees celcius
3534
3535 int fan_speed_min = 15; // in percentage
3536 int fan_speed_max = 100;
3537 #endif // HAVE_ADL
3538
3539 time_t last_temp_check_time;
3540 #endif // HAVE_HWMON
3541
3542 uint sleep_time = 1;
3543
3544 if (data.runtime)
3545 {
3546 runtime_check = 1;
3547 }
3548
3549 if (data.restore_timer)
3550 {
3551 restore_check = 1;
3552 }
3553
3554 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3555 {
3556 remove_check = 1;
3557 }
3558
3559 if (data.status == 1)
3560 {
3561 status_check = 1;
3562 }
3563
3564 #ifdef HAVE_HWMON
3565 if (data.gpu_temp_disable == 0)
3566 {
3567 time (&last_temp_check_time);
3568
3569 hwmon_check = 1;
3570 }
3571 #endif
3572
3573 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3574 {
3575 #ifdef HAVE_HWMON
3576 if (hwmon_check == 0)
3577 #endif
3578 return (p);
3579 }
3580
3581 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3582 {
3583 hc_sleep (sleep_time);
3584
3585 if (data.devices_status != STATUS_RUNNING) continue;
3586
3587 #ifdef HAVE_HWMON
3588 if (hwmon_check == 1)
3589 {
3590 hc_thread_mutex_lock (mux_adl);
3591
3592 time_t temp_check_time;
3593
3594 time (&temp_check_time);
3595
3596 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3597
3598 if (Ta == 0) Ta = 1;
3599
3600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3601 {
3602 hc_device_param_t *device_param = &data.devices_param[device_id];
3603
3604 if (device_param->skipped) continue;
3605
3606 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3607
3608 const int temperature = hm_get_temperature_with_device_id (device_id);
3609
3610 if (temperature > (int) data.gpu_temp_abort)
3611 {
3612 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3613
3614 if (data.devices_status != STATUS_QUIT) myabort ();
3615
3616 break;
3617 }
3618
3619 #ifdef HAVE_ADL
3620 const int gpu_temp_retain = data.gpu_temp_retain;
3621
3622 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3623 {
3624 if (data.hm_device[device_id].fan_supported == 1)
3625 {
3626 int temp_cur = temperature;
3627
3628 int temp_diff_new = gpu_temp_retain - temp_cur;
3629
3630 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3631
3632 // calculate Ta value (time difference in seconds between the last check and this check)
3633
3634 last_temp_check_time = temp_check_time;
3635
3636 float Kp = 1.8;
3637 float Ki = 0.005;
3638 float Kd = 6;
3639
3640 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3641
3642 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);
3643
3644 if (abs (fan_diff_required) >= temp_threshold)
3645 {
3646 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3647
3648 int fan_speed_level = fan_speed_cur;
3649
3650 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3651
3652 int fan_speed_new = fan_speed_level - fan_diff_required;
3653
3654 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3655 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3656
3657 if (fan_speed_new != fan_speed_cur)
3658 {
3659 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3660 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3661
3662 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3663 {
3664 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3665
3666 fan_speed_chgd[device_id] = 1;
3667 }
3668
3669 temp_diff_old[device_id] = temp_diff_new;
3670 }
3671 }
3672 }
3673 }
3674 #endif // HAVE_ADL
3675 }
3676
3677 hc_thread_mutex_unlock (mux_adl);
3678 }
3679 #endif // HAVE_HWMON
3680
3681 if (restore_check == 1)
3682 {
3683 restore_left--;
3684
3685 if (restore_left == 0)
3686 {
3687 if (data.restore_disable == 0) cycle_restore ();
3688
3689 restore_left = data.restore_timer;
3690 }
3691 }
3692
3693 if ((runtime_check == 1) && (data.runtime_start > 0))
3694 {
3695 time_t runtime_cur;
3696
3697 time (&runtime_cur);
3698
3699 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3700
3701 if (runtime_left <= 0)
3702 {
3703 if (data.benchmark == 0)
3704 {
3705 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3706 }
3707
3708 if (data.devices_status != STATUS_QUIT) myabort ();
3709 }
3710 }
3711
3712 if (remove_check == 1)
3713 {
3714 remove_left--;
3715
3716 if (remove_left == 0)
3717 {
3718 if (data.digests_saved != data.digests_done)
3719 {
3720 data.digests_saved = data.digests_done;
3721
3722 save_hash ();
3723 }
3724
3725 remove_left = data.remove_timer;
3726 }
3727 }
3728
3729 if (status_check == 1)
3730 {
3731 status_left--;
3732
3733 if (status_left == 0)
3734 {
3735 hc_thread_mutex_lock (mux_display);
3736
3737 if (data.quiet == 0) clear_prompt ();
3738
3739 if (data.quiet == 0) log_info ("");
3740
3741 status_display ();
3742
3743 if (data.quiet == 0) log_info ("");
3744
3745 hc_thread_mutex_unlock (mux_display);
3746
3747 status_left = data.status_timer;
3748 }
3749 }
3750 }
3751
3752 #ifdef HAVE_HWMON
3753 myfree (fan_speed_chgd);
3754
3755 myfree (temp_diff_old);
3756 myfree (temp_diff_sum);
3757 #endif
3758
3759 p = NULL;
3760
3761 return (p);
3762 }
3763
3764 static void *thread_outfile_remove (void *p)
3765 {
3766 // some hash-dependent constants
3767 char *outfile_dir = data.outfile_check_directory;
3768 uint dgst_size = data.dgst_size;
3769 uint isSalted = data.isSalted;
3770 uint esalt_size = data.esalt_size;
3771 uint hash_mode = data.hash_mode;
3772
3773 uint outfile_check_timer = data.outfile_check_timer;
3774
3775 char separator = data.separator;
3776
3777 // some hash-dependent functions
3778 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3779 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3780
3781 // buffers
3782 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3783
3784 hash_buf.digest = mymalloc (dgst_size);
3785
3786 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3787
3788 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3789
3790 uint digest_buf[64] = { 0 };
3791
3792 outfile_data_t *out_info = NULL;
3793
3794 char **out_files = NULL;
3795
3796 time_t folder_mtime = 0;
3797
3798 int out_cnt = 0;
3799
3800 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3801
3802 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3803 {
3804 hc_sleep (1);
3805
3806 if (data.devices_status != STATUS_RUNNING) continue;
3807
3808 check_left--;
3809
3810 if (check_left == 0)
3811 {
3812 struct stat outfile_check_stat;
3813
3814 if (stat (outfile_dir, &outfile_check_stat) == 0)
3815 {
3816 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3817
3818 if (is_dir == 1)
3819 {
3820 if (outfile_check_stat.st_mtime > folder_mtime)
3821 {
3822 char **out_files_new = scan_directory (outfile_dir);
3823
3824 int out_cnt_new = count_dictionaries (out_files_new);
3825
3826 outfile_data_t *out_info_new = NULL;
3827
3828 if (out_cnt_new > 0)
3829 {
3830 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3831
3832 for (int i = 0; i < out_cnt_new; i++)
3833 {
3834 out_info_new[i].file_name = out_files_new[i];
3835
3836 // check if there are files that we have seen/checked before (and not changed)
3837
3838 for (int j = 0; j < out_cnt; j++)
3839 {
3840 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3841 {
3842 struct stat outfile_stat;
3843
3844 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3845 {
3846 if (outfile_stat.st_ctime == out_info[j].ctime)
3847 {
3848 out_info_new[i].ctime = out_info[j].ctime;
3849 out_info_new[i].seek = out_info[j].seek;
3850 }
3851 }
3852 }
3853 }
3854 }
3855 }
3856
3857 local_free (out_info);
3858 local_free (out_files);
3859
3860 out_files = out_files_new;
3861 out_cnt = out_cnt_new;
3862 out_info = out_info_new;
3863
3864 folder_mtime = outfile_check_stat.st_mtime;
3865 }
3866
3867 for (int j = 0; j < out_cnt; j++)
3868 {
3869 FILE *fp = fopen (out_info[j].file_name, "rb");
3870
3871 if (fp != NULL)
3872 {
3873 //hc_thread_mutex_lock (mux_display);
3874
3875 #ifdef _POSIX
3876 struct stat outfile_stat;
3877
3878 fstat (fileno (fp), &outfile_stat);
3879 #endif
3880
3881 #ifdef _WIN
3882 struct stat64 outfile_stat;
3883
3884 _fstat64 (fileno (fp), &outfile_stat);
3885 #endif
3886
3887 if (outfile_stat.st_ctime > out_info[j].ctime)
3888 {
3889 out_info[j].ctime = outfile_stat.st_ctime;
3890 out_info[j].seek = 0;
3891 }
3892
3893 fseek (fp, out_info[j].seek, SEEK_SET);
3894
3895 while (!feof (fp))
3896 {
3897 char line_buf[BUFSIZ] = { 0 };
3898
3899 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3900
3901 if (ptr == NULL) break;
3902
3903 int line_len = strlen (line_buf);
3904
3905 if (line_len <= 0) continue;
3906
3907 int iter = MAX_CUT_TRIES;
3908
3909 for (uint i = line_len - 1; i && iter; i--, line_len--)
3910 {
3911 if (line_buf[i] != separator) continue;
3912
3913 int parser_status = PARSER_OK;
3914
3915 if ((hash_mode != 2500) && (hash_mode != 6800))
3916 {
3917 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3918 }
3919
3920 uint found = 0;
3921
3922 if (parser_status == PARSER_OK)
3923 {
3924 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3925 {
3926 if (data.salts_shown[salt_pos] == 1) continue;
3927
3928 salt_t *salt_buf = &data.salts_buf[salt_pos];
3929
3930 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3931 {
3932 uint idx = salt_buf->digests_offset + digest_pos;
3933
3934 if (data.digests_shown[idx] == 1) continue;
3935
3936 uint cracked = 0;
3937
3938 if (hash_mode == 6800)
3939 {
3940 if (i == salt_buf->salt_len)
3941 {
3942 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3943 }
3944 }
3945 else if (hash_mode == 2500)
3946 {
3947 // BSSID : MAC1 : MAC2 (:plain)
3948 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3949 {
3950 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3951
3952 if (!cracked) continue;
3953
3954 // now compare MAC1 and MAC2 too, since we have this additional info
3955 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3956 char *mac2_pos = mac1_pos + 12 + 1;
3957
3958 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3959 wpa_t *wpa = &wpas[salt_pos];
3960
3961 uint pke[25] = { 0 };
3962
3963 char *pke_ptr = (char *) pke;
3964
3965 for (uint i = 0; i < 25; i++)
3966 {
3967 pke[i] = byte_swap_32 (wpa->pke[i]);
3968 }
3969
3970 u8 mac1[6] = { 0 };
3971 u8 mac2[6] = { 0 };
3972
3973 memcpy (mac1, pke_ptr + 23, 6);
3974 memcpy (mac2, pke_ptr + 29, 6);
3975
3976 // compare hex string(s) vs binary MAC address(es)
3977
3978 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3979 {
3980 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3981 {
3982 cracked = 0;
3983 break;
3984 }
3985 }
3986
3987 // early skip ;)
3988 if (!cracked) continue;
3989
3990 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3991 {
3992 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3993 {
3994 cracked = 0;
3995 break;
3996 }
3997 }
3998 }
3999 }
4000 else
4001 {
4002 char *digests_buf_ptr = (char *) data.digests_buf;
4003
4004 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4005
4006 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4007 }
4008
4009 if (cracked == 1)
4010 {
4011 found = 1;
4012
4013 data.digests_shown[idx] = 1;
4014
4015 data.digests_done++;
4016
4017 salt_buf->digests_done++;
4018
4019 if (salt_buf->digests_done == salt_buf->digests_cnt)
4020 {
4021 data.salts_shown[salt_pos] = 1;
4022
4023 data.salts_done++;
4024
4025 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4026 }
4027 }
4028 }
4029
4030 if (data.devices_status == STATUS_CRACKED) break;
4031 }
4032 }
4033
4034 if (found) break;
4035
4036 if (data.devices_status == STATUS_CRACKED) break;
4037
4038 iter--;
4039 }
4040
4041 if (data.devices_status == STATUS_CRACKED) break;
4042 }
4043
4044 out_info[j].seek = ftell (fp);
4045
4046 //hc_thread_mutex_unlock (mux_display);
4047
4048 fclose (fp);
4049 }
4050 }
4051 }
4052 }
4053
4054 check_left = outfile_check_timer;
4055 }
4056 }
4057
4058 if (esalt_size) local_free (hash_buf.esalt);
4059
4060 if (isSalted) local_free (hash_buf.salt);
4061
4062 local_free (hash_buf.digest);
4063
4064 local_free (out_info);
4065
4066 local_free (out_files);
4067
4068 p = NULL;
4069
4070 return (p);
4071 }
4072
4073 static uint get_work (hc_device_param_t *device_param, const u64 max)
4074 {
4075 hc_thread_mutex_lock (mux_dispatcher);
4076
4077 const u64 words_cur = data.words_cur;
4078 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4079
4080 device_param->words_off = words_cur;
4081
4082 const u64 words_left = words_base - words_cur;
4083
4084 if (data.kernel_blocks_all > words_left)
4085 {
4086 if (data.kernel_blocks_div == 0)
4087 {
4088 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4089 }
4090 }
4091
4092 if (data.kernel_blocks_div)
4093 {
4094 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4095 {
4096 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4097 const u32 kernel_power_new = kernel_blocks_new;
4098
4099 if (kernel_blocks_new < device_param->kernel_blocks)
4100 {
4101 device_param->kernel_blocks = kernel_blocks_new;
4102 device_param->kernel_power = kernel_power_new;
4103 }
4104 }
4105 }
4106
4107 const uint kernel_blocks = device_param->kernel_blocks;
4108
4109 uint work = MIN (words_left, kernel_blocks);
4110
4111 work = MIN (work, max);
4112
4113 data.words_cur += work;
4114
4115 hc_thread_mutex_unlock (mux_dispatcher);
4116
4117 return work;
4118 }
4119
4120 static void *thread_calc_stdin (void *p)
4121 {
4122 hc_device_param_t *device_param = (hc_device_param_t *) p;
4123
4124 if (device_param->skipped) return NULL;
4125
4126 const uint attack_kern = data.attack_kern;
4127
4128 const uint kernel_blocks = device_param->kernel_blocks;
4129
4130 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4131 {
4132 hc_thread_mutex_lock (mux_dispatcher);
4133
4134 if (feof (stdin) != 0)
4135 {
4136 hc_thread_mutex_unlock (mux_dispatcher);
4137
4138 break;
4139 }
4140
4141 uint words_cur = 0;
4142
4143 while (words_cur < kernel_blocks)
4144 {
4145 char buf[BUFSIZ] = { 0 };
4146
4147 char *line_buf = fgets (buf, sizeof (buf), stdin);
4148
4149 if (line_buf == NULL) break;
4150
4151 uint line_len = in_superchop (line_buf);
4152
4153 line_len = convert_from_hex (line_buf, line_len);
4154
4155 // post-process rule engine
4156
4157 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4158 {
4159 char rule_buf_out[BLOCK_SIZE] = { 0 };
4160
4161 int rule_len_out = -1;
4162
4163 if (line_len < BLOCK_SIZE)
4164 {
4165 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4166 }
4167
4168 if (rule_len_out < 0) continue;
4169
4170 line_buf = rule_buf_out;
4171 line_len = rule_len_out;
4172 }
4173
4174 if (line_len > PW_MAX)
4175 {
4176 continue;
4177 }
4178
4179 if (attack_kern == ATTACK_KERN_STRAIGHT)
4180 {
4181 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4182 {
4183 hc_thread_mutex_lock (mux_counter);
4184
4185 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4186 {
4187 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4188 }
4189
4190 hc_thread_mutex_unlock (mux_counter);
4191
4192 continue;
4193 }
4194 }
4195 else if (attack_kern == ATTACK_KERN_COMBI)
4196 {
4197 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4198 // since we still need to combine the plains
4199
4200 if (line_len > data.pw_max)
4201 {
4202 hc_thread_mutex_lock (mux_counter);
4203
4204 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4205 {
4206 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4207 }
4208
4209 hc_thread_mutex_unlock (mux_counter);
4210
4211 continue;
4212 }
4213 }
4214
4215 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4216
4217 words_cur++;
4218
4219 if (data.devices_status == STATUS_CRACKED) break;
4220 if (data.devices_status == STATUS_ABORTED) break;
4221 if (data.devices_status == STATUS_QUIT) break;
4222 if (data.devices_status == STATUS_BYPASS) break;
4223 }
4224
4225 hc_thread_mutex_unlock (mux_dispatcher);
4226
4227 if (data.devices_status == STATUS_CRACKED) break;
4228 if (data.devices_status == STATUS_ABORTED) break;
4229 if (data.devices_status == STATUS_QUIT) break;
4230 if (data.devices_status == STATUS_BYPASS) break;
4231
4232 // we need 2 flushing because we have two independant caches and it can occur
4233 // that one buffer is already at threshold plus for that length also exists
4234 // more data in the 2nd buffer so it would overflow
4235
4236 // flush session 1
4237
4238 {
4239 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4240 {
4241 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4242
4243 const uint pw_cache_cnt = pw_cache->cnt;
4244
4245 if (pw_cache_cnt == 0) continue;
4246
4247 pw_cache->cnt = 0;
4248
4249 uint pws_cnt = device_param->pws_cnt;
4250
4251 pw_t *pw = device_param->pws_buf + pws_cnt;
4252
4253 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4254
4255 pw->pw_len = pw_len;
4256
4257 uint pw_cnt = device_param->pw_cnt;
4258
4259 pw_cnt += pw_cache_cnt;
4260
4261 device_param->pw_cnt = pw_cnt;
4262
4263 pws_cnt++;
4264
4265 device_param->pws_cnt = pws_cnt;
4266
4267 if (pws_cnt == device_param->kernel_power_user) break;
4268 }
4269
4270 const uint pw_cnt = device_param->pw_cnt;
4271 const uint pws_cnt = device_param->pws_cnt;
4272
4273 if (pws_cnt)
4274 {
4275 run_copy (device_param, pws_cnt);
4276
4277 run_cracker (device_param, pw_cnt, pws_cnt);
4278
4279 device_param->pw_cnt = 0;
4280 device_param->pws_cnt = 0;
4281 }
4282 }
4283
4284 // flush session 2
4285
4286 {
4287 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4288 {
4289 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4290
4291 const uint pw_cache_cnt = pw_cache->cnt;
4292
4293 if (pw_cache_cnt == 0) continue;
4294
4295 pw_cache->cnt = 0;
4296
4297 uint pws_cnt = device_param->pws_cnt;
4298
4299 pw_t *pw = device_param->pws_buf + pws_cnt;
4300
4301 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4302
4303 pw->pw_len = pw_len;
4304
4305 uint pw_cnt = device_param->pw_cnt;
4306
4307 pw_cnt += pw_cache_cnt;
4308
4309 device_param->pw_cnt = pw_cnt;
4310
4311 pws_cnt++;
4312
4313 device_param->pws_cnt = pws_cnt;
4314 }
4315
4316 const uint pw_cnt = device_param->pw_cnt;
4317 const uint pws_cnt = device_param->pws_cnt;
4318
4319 if (pws_cnt)
4320 {
4321 run_copy (device_param, pws_cnt);
4322
4323 run_cracker (device_param, pw_cnt, pws_cnt);
4324
4325 device_param->pw_cnt = 0;
4326 device_param->pws_cnt = 0;
4327 }
4328 }
4329 }
4330
4331 return NULL;
4332 }
4333
4334 static void *thread_calc (void *p)
4335 {
4336 hc_device_param_t *device_param = (hc_device_param_t *) p;
4337
4338 if (device_param->skipped) return NULL;
4339
4340 const uint attack_mode = data.attack_mode;
4341 const uint attack_kern = data.attack_kern;
4342
4343 if (attack_mode == ATTACK_MODE_BF)
4344 {
4345 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4346 {
4347 const uint work = get_work (device_param, -1);
4348
4349 if (work == 0) break;
4350
4351 const u64 words_off = device_param->words_off;
4352 const u64 words_fin = words_off + work;
4353
4354 const uint pw_cnt = work;
4355 const uint pws_cnt = work;
4356
4357 device_param->pw_cnt = pw_cnt;
4358 device_param->pws_cnt = pws_cnt;
4359
4360 if (pws_cnt)
4361 {
4362 run_copy (device_param, pws_cnt);
4363
4364 run_cracker (device_param, pw_cnt, pws_cnt);
4365
4366 device_param->pw_cnt = 0;
4367 device_param->pws_cnt = 0;
4368 }
4369
4370 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4371
4372 if (data.devices_status == STATUS_CRACKED) break;
4373 if (data.devices_status == STATUS_ABORTED) break;
4374 if (data.devices_status == STATUS_QUIT) break;
4375 if (data.devices_status == STATUS_BYPASS) break;
4376
4377 device_param->words_done = words_fin;
4378 }
4379 }
4380 else
4381 {
4382 const uint segment_size = data.segment_size;
4383
4384 char *dictfile = data.dictfile;
4385
4386 if (attack_mode == ATTACK_MODE_COMBI)
4387 {
4388 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4389 {
4390 dictfile = data.dictfile2;
4391 }
4392 }
4393
4394 FILE *fd = fopen (dictfile, "rb");
4395
4396 if (fd == NULL)
4397 {
4398 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4399
4400 return NULL;
4401 }
4402
4403 if (attack_mode == ATTACK_MODE_COMBI)
4404 {
4405 const uint combs_mode = data.combs_mode;
4406
4407 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4408 {
4409 const char *dictfilec = data.dictfile2;
4410
4411 FILE *combs_fp = fopen (dictfilec, "rb");
4412
4413 if (combs_fp == NULL)
4414 {
4415 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4416
4417 fclose (fd);
4418
4419 return NULL;
4420 }
4421
4422 device_param->combs_fp = combs_fp;
4423 }
4424 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4425 {
4426 const char *dictfilec = data.dictfile;
4427
4428 FILE *combs_fp = fopen (dictfilec, "rb");
4429
4430 if (combs_fp == NULL)
4431 {
4432 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4433
4434 fclose (fd);
4435
4436 return NULL;
4437 }
4438
4439 device_param->combs_fp = combs_fp;
4440 }
4441 }
4442
4443 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4444
4445 wl_data->buf = (char *) mymalloc (segment_size);
4446 wl_data->avail = segment_size;
4447 wl_data->incr = segment_size;
4448 wl_data->cnt = 0;
4449 wl_data->pos = 0;
4450
4451 u64 words_cur = 0;
4452
4453 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4454 {
4455 u64 words_off = 0;
4456 u64 words_fin = 0;
4457
4458 u64 max = -1;
4459
4460 while (max)
4461 {
4462 const uint work = get_work (device_param, max);
4463
4464 if (work == 0) break;
4465
4466 words_off = device_param->words_off;
4467 words_fin = words_off + work;
4468
4469 char *line_buf;
4470 uint line_len;
4471
4472 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4473
4474 max = 0;
4475
4476 for ( ; words_cur < words_fin; words_cur++)
4477 {
4478 get_next_word (wl_data, fd, &line_buf, &line_len);
4479
4480 line_len = convert_from_hex (line_buf, line_len);
4481
4482 // post-process rule engine
4483
4484 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4485 {
4486 char rule_buf_out[BLOCK_SIZE] = { 0 };
4487
4488 int rule_len_out = -1;
4489
4490 if (line_len < BLOCK_SIZE)
4491 {
4492 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4493 }
4494
4495 if (rule_len_out < 0) continue;
4496
4497 line_buf = rule_buf_out;
4498 line_len = rule_len_out;
4499 }
4500
4501 if (attack_kern == ATTACK_KERN_STRAIGHT)
4502 {
4503 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4504 {
4505 max++;
4506
4507 hc_thread_mutex_lock (mux_counter);
4508
4509 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4510 {
4511 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4512 }
4513
4514 hc_thread_mutex_unlock (mux_counter);
4515
4516 continue;
4517 }
4518 }
4519 else if (attack_kern == ATTACK_KERN_COMBI)
4520 {
4521 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4522 // since we still need to combine the plains
4523
4524 if (line_len > data.pw_max)
4525 {
4526 max++;
4527
4528 hc_thread_mutex_lock (mux_counter);
4529
4530 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4531 {
4532 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4533 }
4534
4535 hc_thread_mutex_unlock (mux_counter);
4536
4537 continue;
4538 }
4539 }
4540
4541 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4542
4543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4544
4545 if (data.devices_status == STATUS_CRACKED) break;
4546 if (data.devices_status == STATUS_ABORTED) break;
4547 if (data.devices_status == STATUS_QUIT) break;
4548 if (data.devices_status == STATUS_BYPASS) break;
4549 }
4550
4551 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4552
4553 if (data.devices_status == STATUS_CRACKED) break;
4554 if (data.devices_status == STATUS_ABORTED) break;
4555 if (data.devices_status == STATUS_QUIT) break;
4556 if (data.devices_status == STATUS_BYPASS) break;
4557 }
4558
4559 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4560
4561 if (data.devices_status == STATUS_CRACKED) break;
4562 if (data.devices_status == STATUS_ABORTED) break;
4563 if (data.devices_status == STATUS_QUIT) break;
4564 if (data.devices_status == STATUS_BYPASS) break;
4565
4566 // we need 2 flushing because we have two independant caches and it can occur
4567 // that one buffer is already at threshold plus for that length also exists
4568 // more data in the 2nd buffer so it would overflow
4569
4570 //
4571 // flush session 1
4572 //
4573
4574 {
4575 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4576 {
4577 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4578
4579 const uint pw_cache_cnt = pw_cache->cnt;
4580
4581 if (pw_cache_cnt == 0) continue;
4582
4583 pw_cache->cnt = 0;
4584
4585 uint pws_cnt = device_param->pws_cnt;
4586
4587 pw_t *pw = device_param->pws_buf + pws_cnt;
4588
4589 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4590
4591 pw->pw_len = pw_len;
4592
4593 uint pw_cnt = device_param->pw_cnt;
4594
4595 pw_cnt += pw_cache_cnt;
4596
4597 device_param->pw_cnt = pw_cnt;
4598
4599 pws_cnt++;
4600
4601 device_param->pws_cnt = pws_cnt;
4602
4603 if (pws_cnt == device_param->kernel_power_user) break;
4604 }
4605
4606 const uint pw_cnt = device_param->pw_cnt;
4607 const uint pws_cnt = device_param->pws_cnt;
4608
4609 if (pws_cnt)
4610 {
4611 run_copy (device_param, pws_cnt);
4612
4613 run_cracker (device_param, pw_cnt, pws_cnt);
4614
4615 device_param->pw_cnt = 0;
4616 device_param->pws_cnt = 0;
4617 }
4618
4619 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4620
4621 if (data.devices_status == STATUS_CRACKED) break;
4622 if (data.devices_status == STATUS_ABORTED) break;
4623 if (data.devices_status == STATUS_QUIT) break;
4624 if (data.devices_status == STATUS_BYPASS) break;
4625 }
4626
4627 //
4628 // flush session 2
4629 //
4630
4631 {
4632 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4633 {
4634 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4635
4636 const uint pw_cache_cnt = pw_cache->cnt;
4637
4638 if (pw_cache_cnt == 0) continue;
4639
4640 pw_cache->cnt = 0;
4641
4642 uint pws_cnt = device_param->pws_cnt;
4643
4644 pw_t *pw = device_param->pws_buf + pws_cnt;
4645
4646 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4647
4648 pw->pw_len = pw_len;
4649
4650 uint pw_cnt = device_param->pw_cnt;
4651
4652 pw_cnt += pw_cache_cnt;
4653
4654 device_param->pw_cnt = pw_cnt;
4655
4656 pws_cnt++;
4657
4658 device_param->pws_cnt = pws_cnt;
4659 }
4660
4661 const uint pw_cnt = device_param->pw_cnt;
4662 const uint pws_cnt = device_param->pws_cnt;
4663
4664 if (pws_cnt)
4665 {
4666 run_copy (device_param, pws_cnt);
4667
4668 run_cracker (device_param, pw_cnt, pws_cnt);
4669
4670 device_param->pw_cnt = 0;
4671 device_param->pws_cnt = 0;
4672 }
4673
4674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677 if (data.devices_status == STATUS_ABORTED) break;
4678 if (data.devices_status == STATUS_QUIT) break;
4679 if (data.devices_status == STATUS_BYPASS) break;
4680 }
4681
4682 if (words_fin == 0) break;
4683
4684 device_param->words_done = words_fin;
4685 }
4686
4687 if (attack_mode == ATTACK_MODE_COMBI)
4688 {
4689 fclose (device_param->combs_fp);
4690 }
4691
4692 free (wl_data->buf);
4693 free (wl_data);
4694
4695 fclose (fd);
4696 }
4697
4698 return NULL;
4699 }
4700
4701 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4702 {
4703 if (!device_param)
4704 {
4705 log_error ("ERROR: %s : Invalid argument", __func__);
4706
4707 exit (-1);
4708 }
4709
4710 salt_t *salt_buf = &data.salts_buf[salt_pos];
4711
4712 device_param->kernel_params_buf32[24] = salt_pos;
4713 device_param->kernel_params_buf32[27] = 1;
4714 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4715 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4716 device_param->kernel_params_buf32[30] = 0;
4717 device_param->kernel_params_buf32[31] = 1;
4718
4719 char *dictfile_old = data.dictfile;
4720
4721 const char *weak_hash_check = "weak-hash-check";
4722
4723 data.dictfile = (char *) weak_hash_check;
4724
4725 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4726
4727 data.kernel_rules_buf[0].cmds[0] = 0;
4728
4729 /**
4730 * run the kernel
4731 */
4732
4733 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4734 {
4735 run_kernel (KERN_RUN_1, device_param, 1, false);
4736 }
4737 else
4738 {
4739 run_kernel (KERN_RUN_1, device_param, 1, false);
4740
4741 const uint iter = salt_buf->salt_iter;
4742
4743 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4744 {
4745 uint loop_left = iter - loop_pos;
4746
4747 loop_left = MIN (loop_left, kernel_loops);
4748
4749 device_param->kernel_params_buf32[25] = loop_pos;
4750 device_param->kernel_params_buf32[26] = loop_left;
4751
4752 run_kernel (KERN_RUN_2, device_param, 1, false);
4753 }
4754
4755 run_kernel (KERN_RUN_3, device_param, 1, false);
4756 }
4757
4758 /**
4759 * result
4760 */
4761
4762 check_cracked (device_param, salt_pos);
4763
4764 /**
4765 * cleanup
4766 */
4767
4768 device_param->kernel_params_buf32[24] = 0;
4769 device_param->kernel_params_buf32[25] = 0;
4770 device_param->kernel_params_buf32[26] = 0;
4771 device_param->kernel_params_buf32[27] = 0;
4772 device_param->kernel_params_buf32[28] = 0;
4773 device_param->kernel_params_buf32[29] = 0;
4774 device_param->kernel_params_buf32[30] = 0;
4775 device_param->kernel_params_buf32[31] = 0;
4776
4777 data.dictfile = dictfile_old;
4778
4779 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4780 }
4781
4782 // hlfmt hashcat
4783
4784 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4785 {
4786 if (data.username == 0)
4787 {
4788 *hashbuf_pos = line_buf;
4789 *hashbuf_len = line_len;
4790 }
4791 else
4792 {
4793 char *pos = line_buf;
4794 int len = line_len;
4795
4796 for (int i = 0; i < line_len; i++, pos++, len--)
4797 {
4798 if (line_buf[i] == data.separator)
4799 {
4800 pos++;
4801
4802 len--;
4803
4804 break;
4805 }
4806 }
4807
4808 *hashbuf_pos = pos;
4809 *hashbuf_len = len;
4810 }
4811 }
4812
4813 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4814 {
4815 char *pos = NULL;
4816 int len = 0;
4817
4818 int sep_cnt = 0;
4819
4820 for (int i = 0; i < line_len; i++)
4821 {
4822 if (line_buf[i] == data.separator)
4823 {
4824 sep_cnt++;
4825
4826 continue;
4827 }
4828
4829 if (sep_cnt == 0)
4830 {
4831 if (pos == NULL) pos = line_buf + i;
4832
4833 len++;
4834 }
4835 }
4836
4837 *userbuf_pos = pos;
4838 *userbuf_len = len;
4839 }
4840
4841 // hlfmt pwdump
4842
4843 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4844 {
4845 int sep_cnt = 0;
4846
4847 int sep2_len = 0;
4848 int sep3_len = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':')
4853 {
4854 sep_cnt++;
4855
4856 continue;
4857 }
4858
4859 if (sep_cnt == 2) sep2_len++;
4860 if (sep_cnt == 3) sep3_len++;
4861 }
4862
4863 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4864
4865 return 0;
4866 }
4867
4868 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4869 {
4870 char *pos = NULL;
4871 int len = 0;
4872
4873 int sep_cnt = 0;
4874
4875 for (int i = 0; i < line_len; i++)
4876 {
4877 if (line_buf[i] == ':')
4878 {
4879 sep_cnt++;
4880
4881 continue;
4882 }
4883
4884 if (data.hash_mode == 1000)
4885 {
4886 if (sep_cnt == 3)
4887 {
4888 if (pos == NULL) pos = line_buf + i;
4889
4890 len++;
4891 }
4892 }
4893 else if (data.hash_mode == 3000)
4894 {
4895 if (sep_cnt == 2)
4896 {
4897 if (pos == NULL) pos = line_buf + i;
4898
4899 len++;
4900 }
4901 }
4902 }
4903
4904 *hashbuf_pos = pos;
4905 *hashbuf_len = len;
4906 }
4907
4908 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4909 {
4910 char *pos = NULL;
4911 int len = 0;
4912
4913 int sep_cnt = 0;
4914
4915 for (int i = 0; i < line_len; i++)
4916 {
4917 if (line_buf[i] == ':')
4918 {
4919 sep_cnt++;
4920
4921 continue;
4922 }
4923
4924 if (sep_cnt == 0)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931
4932 *userbuf_pos = pos;
4933 *userbuf_len = len;
4934 }
4935
4936 // hlfmt passwd
4937
4938 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4939 {
4940 int sep_cnt = 0;
4941
4942 char sep5_first = 0;
4943 char sep6_first = 0;
4944
4945 for (int i = 0; i < line_len; i++)
4946 {
4947 if (line_buf[i] == ':')
4948 {
4949 sep_cnt++;
4950
4951 continue;
4952 }
4953
4954 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4955 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4956 }
4957
4958 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4959
4960 return 0;
4961 }
4962
4963 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4964 {
4965 char *pos = NULL;
4966 int len = 0;
4967
4968 int sep_cnt = 0;
4969
4970 for (int i = 0; i < line_len; i++)
4971 {
4972 if (line_buf[i] == ':')
4973 {
4974 sep_cnt++;
4975
4976 continue;
4977 }
4978
4979 if (sep_cnt == 1)
4980 {
4981 if (pos == NULL) pos = line_buf + i;
4982
4983 len++;
4984 }
4985 }
4986
4987 *hashbuf_pos = pos;
4988 *hashbuf_len = len;
4989 }
4990
4991 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4992 {
4993 char *pos = NULL;
4994 int len = 0;
4995
4996 int sep_cnt = 0;
4997
4998 for (int i = 0; i < line_len; i++)
4999 {
5000 if (line_buf[i] == ':')
5001 {
5002 sep_cnt++;
5003
5004 continue;
5005 }
5006
5007 if (sep_cnt == 0)
5008 {
5009 if (pos == NULL) pos = line_buf + i;
5010
5011 len++;
5012 }
5013 }
5014
5015 *userbuf_pos = pos;
5016 *userbuf_len = len;
5017 }
5018
5019 // hlfmt shadow
5020
5021 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5022 {
5023 int sep_cnt = 0;
5024
5025 for (int i = 0; i < line_len; i++)
5026 {
5027 if (line_buf[i] == ':') sep_cnt++;
5028 }
5029
5030 if (sep_cnt == 8) return 1;
5031
5032 return 0;
5033 }
5034
5035 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5036 {
5037 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5038 }
5039
5040 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5041 {
5042 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5043 }
5044
5045 // hlfmt main
5046
5047 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5048 {
5049 switch (hashfile_format)
5050 {
5051 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5052 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5053 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5054 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5055 }
5056 }
5057
5058 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5059 {
5060 switch (hashfile_format)
5061 {
5062 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5063 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5064 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5065 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5066 }
5067 }
5068
5069 static uint hlfmt_detect (FILE *fp, uint max_check)
5070 {
5071 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5072
5073 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5074 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5075
5076 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5077
5078 uint num_check = 0;
5079
5080 while (!feof (fp))
5081 {
5082 char line_buf[BUFSIZ] = { 0 };
5083
5084 int line_len = fgetl (fp, line_buf);
5085
5086 if (line_len == 0) continue;
5087
5088 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5089 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5090 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5091
5092 if (num_check == max_check) break;
5093
5094 num_check++;
5095 }
5096
5097 uint hashlist_format = HLFMT_HASHCAT;
5098
5099 for (int i = 1; i < HLFMTS_CNT; i++)
5100 {
5101 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5102
5103 hashlist_format = i;
5104 }
5105
5106 free (formats_cnt);
5107
5108 return hashlist_format;
5109 }
5110
5111 /**
5112 * some further helper function
5113 */
5114
5115 // wrapper around mymalloc for ADL
5116
5117 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5118 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5119 {
5120 return mymalloc (iSize);
5121 }
5122 #endif
5123
5124 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)
5125 {
5126 u64 collisions = 0;
5127
5128 const uint dgst_pos0 = data.dgst_pos0;
5129 const uint dgst_pos1 = data.dgst_pos1;
5130 const uint dgst_pos2 = data.dgst_pos2;
5131 const uint dgst_pos3 = data.dgst_pos3;
5132
5133 memset (bitmap_a, 0, bitmap_size);
5134 memset (bitmap_b, 0, bitmap_size);
5135 memset (bitmap_c, 0, bitmap_size);
5136 memset (bitmap_d, 0, bitmap_size);
5137
5138 for (uint i = 0; i < digests_cnt; i++)
5139 {
5140 uint *digest_ptr = (uint *) digests_buf_ptr;
5141
5142 digests_buf_ptr += dgst_size;
5143
5144 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5145 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5146 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5147 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5148
5149 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5150 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5151 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5152 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5153
5154 if (bitmap_a[idx0] & val0) collisions++;
5155 if (bitmap_b[idx1] & val1) collisions++;
5156 if (bitmap_c[idx2] & val2) collisions++;
5157 if (bitmap_d[idx3] & val3) collisions++;
5158
5159 bitmap_a[idx0] |= val0;
5160 bitmap_b[idx1] |= val1;
5161 bitmap_c[idx2] |= val2;
5162 bitmap_d[idx3] |= val3;
5163
5164 if (collisions >= collisions_max) return 0x7fffffff;
5165 }
5166
5167 return collisions;
5168 }
5169
5170 /**
5171 * main
5172 */
5173
5174 int main (int argc, char **argv)
5175 {
5176 /**
5177 * To help users a bit
5178 */
5179
5180 char *compute = getenv ("COMPUTE");
5181
5182 if (compute)
5183 {
5184 static char display[100];
5185
5186 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5187
5188 putenv (display);
5189 }
5190 else
5191 {
5192 if (getenv ("DISPLAY") == NULL)
5193 putenv ((char *) "DISPLAY=:0");
5194 }
5195
5196 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5197 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5198
5199 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5200 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5201
5202 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5203 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5204
5205 /**
5206 * Real init
5207 */
5208
5209 memset (&data, 0, sizeof (hc_global_data_t));
5210
5211 time_t proc_start;
5212
5213 time (&proc_start);
5214
5215 data.proc_start = proc_start;
5216
5217 int myargc = argc;
5218 char **myargv = argv;
5219
5220 hc_thread_mutex_init (mux_dispatcher);
5221 hc_thread_mutex_init (mux_counter);
5222 hc_thread_mutex_init (mux_display);
5223 hc_thread_mutex_init (mux_adl);
5224
5225 /**
5226 * commandline parameters
5227 */
5228
5229 uint usage = USAGE;
5230 uint version = VERSION;
5231 uint quiet = QUIET;
5232 uint benchmark = BENCHMARK;
5233 uint benchmark_mode = BENCHMARK_MODE;
5234 uint show = SHOW;
5235 uint left = LEFT;
5236 uint username = USERNAME;
5237 uint remove = REMOVE;
5238 uint remove_timer = REMOVE_TIMER;
5239 u64 skip = SKIP;
5240 u64 limit = LIMIT;
5241 uint keyspace = KEYSPACE;
5242 uint potfile_disable = POTFILE_DISABLE;
5243 uint debug_mode = DEBUG_MODE;
5244 char *debug_file = NULL;
5245 char *induction_dir = NULL;
5246 char *outfile_check_dir = NULL;
5247 uint force = FORCE;
5248 uint runtime = RUNTIME;
5249 uint hash_mode = HASH_MODE;
5250 uint attack_mode = ATTACK_MODE;
5251 uint markov_disable = MARKOV_DISABLE;
5252 uint markov_classic = MARKOV_CLASSIC;
5253 uint markov_threshold = MARKOV_THRESHOLD;
5254 char *markov_hcstat = NULL;
5255 char *outfile = NULL;
5256 uint outfile_format = OUTFILE_FORMAT;
5257 uint outfile_autohex = OUTFILE_AUTOHEX;
5258 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5259 uint restore = RESTORE;
5260 uint restore_timer = RESTORE_TIMER;
5261 uint restore_disable = RESTORE_DISABLE;
5262 uint status = STATUS;
5263 uint status_timer = STATUS_TIMER;
5264 uint status_automat = STATUS_AUTOMAT;
5265 uint loopback = LOOPBACK;
5266 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5267 char *session = NULL;
5268 uint hex_charset = HEX_CHARSET;
5269 uint hex_salt = HEX_SALT;
5270 uint hex_wordlist = HEX_WORDLIST;
5271 uint rp_gen = RP_GEN;
5272 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5273 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5274 uint rp_gen_seed = RP_GEN_SEED;
5275 char *rule_buf_l = (char *) RULE_BUF_L;
5276 char *rule_buf_r = (char *) RULE_BUF_R;
5277 uint increment = INCREMENT;
5278 uint increment_min = INCREMENT_MIN;
5279 uint increment_max = INCREMENT_MAX;
5280 char *cpu_affinity = NULL;
5281 OCL_PTR *ocl = NULL;
5282 char *opencl_devices = NULL;
5283 char *opencl_platforms = NULL;
5284 char *opencl_device_types = NULL;
5285 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5286 char *truecrypt_keyfiles = NULL;
5287 uint workload_profile = WORKLOAD_PROFILE;
5288 uint kernel_accel = KERNEL_ACCEL;
5289 uint kernel_loops = KERNEL_LOOPS;
5290 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5291 #ifdef HAVE_HWMON
5292 uint gpu_temp_abort = GPU_TEMP_ABORT;
5293 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5294 #ifdef HAVE_ADL
5295 uint powertune_enable = POWERTUNE_ENABLE;
5296 #endif
5297 #endif
5298 uint logfile_disable = LOGFILE_DISABLE;
5299 uint segment_size = SEGMENT_SIZE;
5300 uint scrypt_tmto = SCRYPT_TMTO;
5301 char separator = SEPARATOR;
5302 uint bitmap_min = BITMAP_MIN;
5303 uint bitmap_max = BITMAP_MAX;
5304 char *custom_charset_1 = NULL;
5305 char *custom_charset_2 = NULL;
5306 char *custom_charset_3 = NULL;
5307 char *custom_charset_4 = NULL;
5308
5309 #define IDX_HELP 'h'
5310 #define IDX_VERSION 'V'
5311 #define IDX_VERSION_LOWER 'v'
5312 #define IDX_QUIET 0xff02
5313 #define IDX_SHOW 0xff03
5314 #define IDX_LEFT 0xff04
5315 #define IDX_REMOVE 0xff05
5316 #define IDX_REMOVE_TIMER 0xff37
5317 #define IDX_SKIP 's'
5318 #define IDX_LIMIT 'l'
5319 #define IDX_KEYSPACE 0xff35
5320 #define IDX_POTFILE_DISABLE 0xff06
5321 #define IDX_DEBUG_MODE 0xff43
5322 #define IDX_DEBUG_FILE 0xff44
5323 #define IDX_INDUCTION_DIR 0xff46
5324 #define IDX_OUTFILE_CHECK_DIR 0xff47
5325 #define IDX_USERNAME 0xff07
5326 #define IDX_FORCE 0xff08
5327 #define IDX_RUNTIME 0xff09
5328 #define IDX_BENCHMARK 'b'
5329 #define IDX_BENCHMARK_MODE 0xff32
5330 #define IDX_HASH_MODE 'm'
5331 #define IDX_ATTACK_MODE 'a'
5332 #define IDX_RP_FILE 'r'
5333 #define IDX_RP_GEN 'g'
5334 #define IDX_RP_GEN_FUNC_MIN 0xff10
5335 #define IDX_RP_GEN_FUNC_MAX 0xff11
5336 #define IDX_RP_GEN_SEED 0xff34
5337 #define IDX_RULE_BUF_L 'j'
5338 #define IDX_RULE_BUF_R 'k'
5339 #define IDX_INCREMENT 'i'
5340 #define IDX_INCREMENT_MIN 0xff12
5341 #define IDX_INCREMENT_MAX 0xff13
5342 #define IDX_OUTFILE 'o'
5343 #define IDX_OUTFILE_FORMAT 0xff14
5344 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5345 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5346 #define IDX_RESTORE 0xff15
5347 #define IDX_RESTORE_DISABLE 0xff27
5348 #define IDX_STATUS 0xff17
5349 #define IDX_STATUS_TIMER 0xff18
5350 #define IDX_STATUS_AUTOMAT 0xff50
5351 #define IDX_LOOPBACK 0xff38
5352 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5353 #define IDX_SESSION 0xff19
5354 #define IDX_HEX_CHARSET 0xff20
5355 #define IDX_HEX_SALT 0xff21
5356 #define IDX_HEX_WORDLIST 0xff40
5357 #define IDX_MARKOV_DISABLE 0xff22
5358 #define IDX_MARKOV_CLASSIC 0xff23
5359 #define IDX_MARKOV_THRESHOLD 't'
5360 #define IDX_MARKOV_HCSTAT 0xff24
5361 #define IDX_CPU_AFFINITY 0xff25
5362 #define IDX_OPENCL_DEVICES 'd'
5363 #define IDX_OPENCL_PLATFORMS 0xff72
5364 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5365 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5366 #define IDX_WORKLOAD_PROFILE 'w'
5367 #define IDX_KERNEL_ACCEL 'n'
5368 #define IDX_KERNEL_LOOPS 'u'
5369 #define IDX_GPU_TEMP_DISABLE 0xff29
5370 #define IDX_GPU_TEMP_ABORT 0xff30
5371 #define IDX_GPU_TEMP_RETAIN 0xff31
5372 #define IDX_POWERTUNE_ENABLE 0xff41
5373 #define IDX_LOGFILE_DISABLE 0xff51
5374 #define IDX_TRUECRYPT_KEYFILES 0xff52
5375 #define IDX_SCRYPT_TMTO 0xff61
5376 #define IDX_SEGMENT_SIZE 'c'
5377 #define IDX_SEPARATOR 'p'
5378 #define IDX_BITMAP_MIN 0xff70
5379 #define IDX_BITMAP_MAX 0xff71
5380 #define IDX_CUSTOM_CHARSET_1 '1'
5381 #define IDX_CUSTOM_CHARSET_2 '2'
5382 #define IDX_CUSTOM_CHARSET_3 '3'
5383 #define IDX_CUSTOM_CHARSET_4 '4'
5384
5385 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5386
5387 struct option long_options[] =
5388 {
5389 {"help", no_argument, 0, IDX_HELP},
5390 {"version", no_argument, 0, IDX_VERSION},
5391 {"quiet", no_argument, 0, IDX_QUIET},
5392 {"show", no_argument, 0, IDX_SHOW},
5393 {"left", no_argument, 0, IDX_LEFT},
5394 {"username", no_argument, 0, IDX_USERNAME},
5395 {"remove", no_argument, 0, IDX_REMOVE},
5396 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5397 {"skip", required_argument, 0, IDX_SKIP},
5398 {"limit", required_argument, 0, IDX_LIMIT},
5399 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5400 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5401 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5402 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5403 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5404 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5405 {"force", no_argument, 0, IDX_FORCE},
5406 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5407 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5408 {"restore", no_argument, 0, IDX_RESTORE},
5409 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5410 {"status", no_argument, 0, IDX_STATUS},
5411 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5412 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5413 {"loopback", no_argument, 0, IDX_LOOPBACK},
5414 {"weak-hash-threshold",
5415 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5416 {"session", required_argument, 0, IDX_SESSION},
5417 {"runtime", required_argument, 0, IDX_RUNTIME},
5418 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5419 {"generate-rules-func-min",
5420 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5421 {"generate-rules-func-max",
5422 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5423 {"generate-rules-seed",
5424 required_argument, 0, IDX_RP_GEN_SEED},
5425 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5426 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5427 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5428 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5429 {"rules-file", required_argument, 0, IDX_RP_FILE},
5430 {"outfile", required_argument, 0, IDX_OUTFILE},
5431 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5432 {"outfile-autohex-disable",
5433 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5434 {"outfile-check-timer",
5435 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5436 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5437 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5438 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5439 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5440 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5441 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5442 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5443 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5444 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5445 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5446 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5447 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5448 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5449 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5450 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5451 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5452 #ifdef HAVE_HWMON
5453 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5454 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5455 #ifdef HAVE_ADL
5456 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5457 #endif
5458 #endif // HAVE_HWMON
5459 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5460 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5461 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5462 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5463 // deprecated
5464 {"seperator", required_argument, 0, IDX_SEPARATOR},
5465 {"separator", required_argument, 0, IDX_SEPARATOR},
5466 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5467 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5468 {"increment", no_argument, 0, IDX_INCREMENT},
5469 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5470 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5471 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5472 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5473 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5474 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5475
5476 {0, 0, 0, 0}
5477 };
5478
5479 uint rp_files_cnt = 0;
5480
5481 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5482
5483 int option_index = 0;
5484 int c = -1;
5485
5486 optind = 1;
5487 optopt = 0;
5488
5489 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5490 {
5491 switch (c)
5492 {
5493 case IDX_HELP: usage = 1; break;
5494 case IDX_VERSION:
5495 case IDX_VERSION_LOWER: version = 1; break;
5496 case IDX_RESTORE: restore = 1; break;
5497 case IDX_SESSION: session = optarg; break;
5498 case IDX_SHOW: show = 1; break;
5499 case IDX_LEFT: left = 1; break;
5500 case '?': return (-1);
5501 }
5502 }
5503
5504 if (optopt != 0)
5505 {
5506 log_error ("ERROR: Invalid argument specified");
5507
5508 return (-1);
5509 }
5510
5511 /**
5512 * exit functions
5513 */
5514
5515 if (version)
5516 {
5517 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5518
5519 return (0);
5520 }
5521
5522 if (usage)
5523 {
5524 usage_big_print (PROGNAME);
5525
5526 return (0);
5527 }
5528
5529 /**
5530 * session needs to be set, always!
5531 */
5532
5533 if (session == NULL) session = (char *) PROGNAME;
5534
5535 /**
5536 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5537 */
5538
5539 char *exec_path = get_exec_path ();
5540
5541 #ifdef LINUX
5542
5543 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5544 char *resolved_exec_path = realpath (exec_path, NULL);
5545
5546 char *install_dir = get_install_dir (resolved_exec_path);
5547 char *profile_dir = NULL;
5548 char *session_dir = NULL;
5549 char *shared_dir = NULL;
5550
5551 if (strcmp (install_dir, resolved_install_folder) == 0)
5552 {
5553 struct passwd *pw = getpwuid (getuid ());
5554
5555 const char *homedir = pw->pw_dir;
5556
5557 profile_dir = get_profile_dir (homedir);
5558 session_dir = get_session_dir (profile_dir);
5559 shared_dir = strdup (SHARED_FOLDER);
5560
5561 mkdir (profile_dir, 0700);
5562 mkdir (session_dir, 0700);
5563 }
5564 else
5565 {
5566 profile_dir = install_dir;
5567 session_dir = install_dir;
5568 shared_dir = install_dir;
5569 }
5570
5571 myfree (resolved_install_folder);
5572 myfree (resolved_exec_path);
5573
5574 #else
5575
5576 char *install_dir = get_install_dir (exec_path);
5577 char *profile_dir = install_dir;
5578 char *session_dir = install_dir;
5579 char *shared_dir = install_dir;
5580
5581 #endif
5582
5583 data.install_dir = install_dir;
5584 data.profile_dir = profile_dir;
5585 data.session_dir = session_dir;
5586 data.shared_dir = shared_dir;
5587
5588 myfree (exec_path);
5589
5590 /**
5591 * kernel cache, we need to make sure folder exist
5592 */
5593
5594 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5595
5596 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5597
5598 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5599
5600 mkdir (kernels_folder, 0700);
5601
5602 myfree (kernels_folder);
5603
5604 /**
5605 * session
5606 */
5607
5608 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5609
5610 data.session = session;
5611
5612 char *eff_restore_file = (char *) mymalloc (session_size);
5613 char *new_restore_file = (char *) mymalloc (session_size);
5614
5615 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5616 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5617
5618 data.eff_restore_file = eff_restore_file;
5619 data.new_restore_file = new_restore_file;
5620
5621 if (((show == 1) || (left == 1)) && (restore == 1))
5622 {
5623 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5624 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5625
5626 return (-1);
5627 }
5628
5629 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5630 if ((show == 1) || (left == 1))
5631 {
5632 restore_disable = 1;
5633
5634 restore = 0;
5635 }
5636
5637 data.restore_disable = restore_disable;
5638
5639 restore_data_t *rd = init_restore (argc, argv);
5640
5641 data.rd = rd;
5642
5643 /**
5644 * restore file
5645 */
5646
5647 if (restore == 1)
5648 {
5649 read_restore (eff_restore_file, rd);
5650
5651 if (rd->version_bin < RESTORE_MIN)
5652 {
5653 log_error ("ERROR: Incompatible restore-file version");
5654
5655 return (-1);
5656 }
5657
5658 myargc = rd->argc;
5659 myargv = rd->argv;
5660
5661 #ifdef _POSIX
5662 rd->pid = getpid ();
5663 #elif _WIN
5664 rd->pid = GetCurrentProcessId ();
5665 #endif
5666 }
5667
5668 uint hash_mode_chgd = 0;
5669 uint runtime_chgd = 0;
5670 uint kernel_loops_chgd = 0;
5671 uint kernel_accel_chgd = 0;
5672 uint attack_mode_chgd = 0;
5673 uint outfile_format_chgd = 0;
5674 uint rp_gen_seed_chgd = 0;
5675 uint remove_timer_chgd = 0;
5676 uint increment_min_chgd = 0;
5677 uint increment_max_chgd = 0;
5678 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5679 uint gpu_temp_retain_chgd = 0;
5680 uint gpu_temp_abort_chgd = 0;
5681 #endif
5682
5683 optind = 1;
5684 optopt = 0;
5685 option_index = 0;
5686
5687 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5688 {
5689 switch (c)
5690 {
5691 //case IDX_HELP: usage = 1; break;
5692 //case IDX_VERSION: version = 1; break;
5693 //case IDX_RESTORE: restore = 1; break;
5694 case IDX_QUIET: quiet = 1; break;
5695 //case IDX_SHOW: show = 1; break;
5696 case IDX_SHOW: break;
5697 //case IDX_LEFT: left = 1; break;
5698 case IDX_LEFT: break;
5699 case IDX_USERNAME: username = 1; break;
5700 case IDX_REMOVE: remove = 1; break;
5701 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5702 remove_timer_chgd = 1; break;
5703 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5704 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5705 case IDX_DEBUG_FILE: debug_file = optarg; break;
5706 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5707 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5708 case IDX_FORCE: force = 1; break;
5709 case IDX_SKIP: skip = atoll (optarg); break;
5710 case IDX_LIMIT: limit = atoll (optarg); break;
5711 case IDX_KEYSPACE: keyspace = 1; break;
5712 case IDX_BENCHMARK: benchmark = 1; break;
5713 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5714 case IDX_RESTORE: break;
5715 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5716 case IDX_STATUS: status = 1; break;
5717 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5718 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5719 case IDX_LOOPBACK: loopback = 1; break;
5720 case IDX_WEAK_HASH_THRESHOLD:
5721 weak_hash_threshold = atoi (optarg); break;
5722 //case IDX_SESSION: session = optarg; break;
5723 case IDX_SESSION: break;
5724 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5725 hash_mode_chgd = 1; break;
5726 case IDX_RUNTIME: runtime = atoi (optarg);
5727 runtime_chgd = 1; break;
5728 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5729 attack_mode_chgd = 1; break;
5730 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5731 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5732 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5733 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5734 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5735 rp_gen_seed_chgd = 1; break;
5736 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5737 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5738 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5739 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5740 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5741 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5742 case IDX_OUTFILE: outfile = optarg; break;
5743 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5744 outfile_format_chgd = 1; break;
5745 case IDX_OUTFILE_AUTOHEX_DISABLE:
5746 outfile_autohex = 0; break;
5747 case IDX_OUTFILE_CHECK_TIMER:
5748 outfile_check_timer = atoi (optarg); break;
5749 case IDX_HEX_CHARSET: hex_charset = 1; break;
5750 case IDX_HEX_SALT: hex_salt = 1; break;
5751 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5752 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5753 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5754 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5755 case IDX_OPENCL_DEVICE_TYPES:
5756 opencl_device_types = optarg; break;
5757 case IDX_OPENCL_VECTOR_WIDTH:
5758 opencl_vector_width = atoi (optarg); break;
5759 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5760 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5761 kernel_accel_chgd = 1; break;
5762 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5763 kernel_loops_chgd = 1; break;
5764 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5765 #ifdef HAVE_HWMON
5766 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5767 #ifdef HAVE_ADL
5768 gpu_temp_abort_chgd = 1;
5769 #endif
5770 break;
5771 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5772 #ifdef HAVE_ADL
5773 gpu_temp_retain_chgd = 1;
5774 #endif
5775 break;
5776 #ifdef HAVE_ADL
5777 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5778 #endif
5779 #endif // HAVE_HWMON
5780 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5781 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5782 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5783 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5784 case IDX_SEPARATOR: separator = optarg[0]; break;
5785 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5786 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5787 case IDX_INCREMENT: increment = 1; break;
5788 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5789 increment_min_chgd = 1; break;
5790 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5791 increment_max_chgd = 1; break;
5792 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5793 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5794 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5795 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5796
5797 default:
5798 log_error ("ERROR: Invalid argument specified");
5799 return (-1);
5800 }
5801 }
5802
5803 if (optopt != 0)
5804 {
5805 log_error ("ERROR: Invalid argument specified");
5806
5807 return (-1);
5808 }
5809
5810 /**
5811 * Inform user things getting started,
5812 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5813 * - we do not need to check algorithm_pos
5814 */
5815
5816 if (quiet == 0)
5817 {
5818 if (benchmark == 1)
5819 {
5820 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5821
5822 log_info ("");
5823 }
5824 else if (restore == 1)
5825 {
5826 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5827
5828 log_info ("");
5829 }
5830 else
5831 {
5832 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5833
5834 log_info ("");
5835 }
5836 }
5837
5838 /**
5839 * sanity check
5840 */
5841
5842 if (attack_mode > 7)
5843 {
5844 log_error ("ERROR: Invalid attack-mode specified");
5845
5846 return (-1);
5847 }
5848
5849 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5850 {
5851 log_error ("ERROR: Invalid runtime specified");
5852
5853 return (-1);
5854 }
5855
5856 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5857 {
5858 log_error ("ERROR: Invalid hash-type specified");
5859
5860 return (-1);
5861 }
5862
5863 // renamed hash modes
5864
5865 if (hash_mode_chgd)
5866 {
5867 int n = -1;
5868
5869 switch (hash_mode)
5870 {
5871 case 123: n = 124;
5872 break;
5873 }
5874
5875 if (n >= 0)
5876 {
5877 log_error ("Old -m specified, use -m %d instead", n);
5878
5879 return (-1);
5880 }
5881 }
5882
5883 if (username == 1)
5884 {
5885 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5886 {
5887 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5888
5889 return (-1);
5890 }
5891 }
5892
5893 if (outfile_format > 16)
5894 {
5895 log_error ("ERROR: Invalid outfile-format specified");
5896
5897 return (-1);
5898 }
5899
5900 if (left == 1)
5901 {
5902 if (outfile_format_chgd == 1)
5903 {
5904 if (outfile_format > 1)
5905 {
5906 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5907
5908 return (-1);
5909 }
5910 }
5911 else
5912 {
5913 outfile_format = OUTFILE_FMT_HASH;
5914 }
5915 }
5916
5917 if (show == 1)
5918 {
5919 if (outfile_format_chgd == 1)
5920 {
5921 if ((outfile_format > 7) && (outfile_format < 16))
5922 {
5923 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5924
5925 return (-1);
5926 }
5927 }
5928 }
5929
5930 if (increment_min < INCREMENT_MIN)
5931 {
5932 log_error ("ERROR: Invalid increment-min specified");
5933
5934 return (-1);
5935 }
5936
5937 if (increment_max > INCREMENT_MAX)
5938 {
5939 log_error ("ERROR: Invalid increment-max specified");
5940
5941 return (-1);
5942 }
5943
5944 if (increment_min > increment_max)
5945 {
5946 log_error ("ERROR: Invalid increment-min specified");
5947
5948 return (-1);
5949 }
5950
5951 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5952 {
5953 log_error ("ERROR: increment is not allowed in attack-mode 0");
5954
5955 return (-1);
5956 }
5957
5958 if ((increment == 0) && (increment_min_chgd == 1))
5959 {
5960 log_error ("ERROR: increment-min is only supported together with increment switch");
5961
5962 return (-1);
5963 }
5964
5965 if ((increment == 0) && (increment_max_chgd == 1))
5966 {
5967 log_error ("ERROR: increment-max is only supported together with increment switch");
5968
5969 return (-1);
5970 }
5971
5972 if (rp_files_cnt && rp_gen)
5973 {
5974 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5975
5976 return (-1);
5977 }
5978
5979 if (rp_files_cnt || rp_gen)
5980 {
5981 if (attack_mode != ATTACK_MODE_STRAIGHT)
5982 {
5983 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5984
5985 return (-1);
5986 }
5987 }
5988
5989 if (rp_gen_func_min > rp_gen_func_max)
5990 {
5991 log_error ("ERROR: Invalid rp-gen-func-min specified");
5992
5993 return (-1);
5994 }
5995
5996 if (kernel_accel_chgd == 1)
5997 {
5998 if (workload_profile != WORKLOAD_PROFILE)
5999 {
6000 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6001
6002 return (-1);
6003 }
6004
6005 if (kernel_accel < 1)
6006 {
6007 log_error ("ERROR: Invalid kernel-accel specified");
6008
6009 return (-1);
6010 }
6011
6012 if (kernel_accel > 1024)
6013 {
6014 log_error ("ERROR: Invalid kernel-accel specified");
6015
6016 return (-1);
6017 }
6018 }
6019
6020 if (kernel_loops_chgd == 1)
6021 {
6022 if (workload_profile != WORKLOAD_PROFILE)
6023 {
6024 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6025
6026 return (-1);
6027 }
6028
6029 if (kernel_loops < 1)
6030 {
6031 log_error ("ERROR: Invalid kernel-loops specified");
6032
6033 return (-1);
6034 }
6035
6036 if (kernel_loops > 1024)
6037 {
6038 log_error ("ERROR: Invalid kernel-loops specified");
6039
6040 return (-1);
6041 }
6042 }
6043
6044 if (benchmark == 1)
6045 {
6046 if (workload_profile != WORKLOAD_PROFILE)
6047 {
6048 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6049
6050 return (-1);
6051 }
6052 }
6053
6054 if ((workload_profile < 1) || (workload_profile > 3))
6055 {
6056 log_error ("ERROR: workload-profile %i not available", workload_profile);
6057
6058 return (-1);
6059 }
6060
6061 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6062 {
6063 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6064
6065 return (-1);
6066 }
6067
6068 if (show == 1 || left == 1)
6069 {
6070 attack_mode = ATTACK_MODE_NONE;
6071
6072 if (remove == 1)
6073 {
6074 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6075
6076 return (-1);
6077 }
6078
6079 if (potfile_disable == 1)
6080 {
6081 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6082
6083 return (-1);
6084 }
6085 }
6086
6087 uint attack_kern = ATTACK_KERN_NONE;
6088
6089 switch (attack_mode)
6090 {
6091 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6092 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6093 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6094 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6095 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6096 }
6097
6098 if (benchmark == 0)
6099 {
6100 if (keyspace == 1)
6101 {
6102 int num_additional_params = 1;
6103
6104 if (attack_kern == ATTACK_KERN_COMBI)
6105 {
6106 num_additional_params = 2;
6107 }
6108
6109 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6110
6111 if (keyspace_wordlist_specified == 0) optind--;
6112 }
6113
6114 if (attack_kern == ATTACK_KERN_NONE)
6115 {
6116 if ((optind + 1) != myargc)
6117 {
6118 usage_mini_print (myargv[0]);
6119
6120 return (-1);
6121 }
6122 }
6123 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6124 {
6125 if ((optind + 1) > myargc)
6126 {
6127 usage_mini_print (myargv[0]);
6128
6129 return (-1);
6130 }
6131 }
6132 else if (attack_kern == ATTACK_KERN_COMBI)
6133 {
6134 if ((optind + 3) != myargc)
6135 {
6136 usage_mini_print (myargv[0]);
6137
6138 return (-1);
6139 }
6140 }
6141 else if (attack_kern == ATTACK_KERN_BF)
6142 {
6143 if ((optind + 1) > myargc)
6144 {
6145 usage_mini_print (myargv[0]);
6146
6147 return (-1);
6148 }
6149 }
6150 else
6151 {
6152 usage_mini_print (myargv[0]);
6153
6154 return (-1);
6155 }
6156 }
6157 else
6158 {
6159 if (myargv[optind] != 0)
6160 {
6161 log_error ("ERROR: Invalid argument for benchmark mode specified");
6162
6163 return (-1);
6164 }
6165
6166 if (attack_mode_chgd == 1)
6167 {
6168 if (attack_mode != ATTACK_MODE_BF)
6169 {
6170 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6171
6172 return (-1);
6173 }
6174 }
6175
6176 if (benchmark_mode == 0)
6177 {
6178 // nothing to do
6179 }
6180 else if (benchmark_mode == 1)
6181 {
6182 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6183 {
6184 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6185
6186 return (-1);
6187 }
6188 }
6189 else
6190 {
6191 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6192
6193 return (-1);
6194 }
6195 }
6196
6197 if (skip != 0 && limit != 0)
6198 {
6199 limit += skip;
6200 }
6201
6202 if (keyspace == 1)
6203 {
6204 if (show == 1)
6205 {
6206 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6207
6208 return (-1);
6209 }
6210 else if (left == 1)
6211 {
6212 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6213
6214 return (-1);
6215 }
6216
6217 potfile_disable = 1;
6218
6219 restore_disable = 1;
6220
6221 restore = 0;
6222
6223 weak_hash_threshold = 0;
6224
6225 quiet = 1;
6226 }
6227
6228 if (remove_timer_chgd == 1)
6229 {
6230 if (remove == 0)
6231 {
6232 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6233
6234 return (-1);
6235 }
6236
6237 if (remove_timer < 1)
6238 {
6239 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6240
6241 return (-1);
6242 }
6243 }
6244
6245 if (loopback == 1)
6246 {
6247 if (attack_mode == ATTACK_MODE_BF)
6248 {
6249 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6250
6251 return (-1);
6252 }
6253 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6254 {
6255 if ((rp_files_cnt == 0) && (rp_gen == 0))
6256 {
6257 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6258
6259 return (-1);
6260 }
6261 }
6262 }
6263
6264 if (debug_mode > 0)
6265 {
6266 if (attack_mode != ATTACK_MODE_STRAIGHT)
6267 {
6268 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6269
6270 return (-1);
6271 }
6272
6273 if ((rp_files_cnt == 0) && (rp_gen == 0))
6274 {
6275 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6276
6277 return (-1);
6278 }
6279 }
6280
6281 if (debug_mode > 4)
6282 {
6283 log_error ("ERROR: Invalid debug-mode specified");
6284
6285 return (-1);
6286 }
6287
6288 if (debug_file != NULL)
6289 {
6290 if (debug_mode < 1)
6291 {
6292 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6293
6294 return (-1);
6295 }
6296 }
6297
6298 if (induction_dir != NULL)
6299 {
6300 if (attack_mode == ATTACK_MODE_BF)
6301 {
6302 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6303
6304 return (-1);
6305 }
6306 }
6307
6308 if (attack_mode != ATTACK_MODE_STRAIGHT)
6309 {
6310 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6311 {
6312 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6313
6314 return (-1);
6315 }
6316
6317 weak_hash_threshold = 0;
6318 }
6319
6320 /**
6321 * induction directory
6322 */
6323
6324 char *induction_directory = NULL;
6325
6326 if (attack_mode != ATTACK_MODE_BF)
6327 {
6328 if (induction_dir == NULL)
6329 {
6330 induction_directory = (char *) mymalloc (session_size);
6331
6332 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6333
6334 // create induction folder if it does not already exist
6335
6336 if (keyspace == 0)
6337 {
6338 if (rmdir (induction_directory) == -1)
6339 {
6340 if (errno == ENOENT)
6341 {
6342 // good, we can ignore
6343 }
6344 else if (errno == ENOTEMPTY)
6345 {
6346 char *induction_directory_mv = (char *) mymalloc (session_size);
6347
6348 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6349
6350 if (rename (induction_directory, induction_directory_mv) != 0)
6351 {
6352 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6353
6354 return (-1);
6355 }
6356 }
6357 else
6358 {
6359 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6360
6361 return (-1);
6362 }
6363 }
6364
6365 if (mkdir (induction_directory, 0700) == -1)
6366 {
6367 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6368
6369 return (-1);
6370 }
6371 }
6372 }
6373 else
6374 {
6375 induction_directory = induction_dir;
6376 }
6377 }
6378
6379 data.induction_directory = induction_directory;
6380
6381 /**
6382 * loopback
6383 */
6384
6385 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6386
6387 char *loopback_file = (char *) mymalloc (loopback_size);
6388
6389 /**
6390 * tuning db
6391 */
6392
6393 char tuning_db_file[256] = { 0 };
6394
6395 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6396
6397 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6398
6399 /**
6400 * outfile-check directory
6401 */
6402
6403 char *outfile_check_directory = NULL;
6404
6405 if (outfile_check_dir == NULL)
6406 {
6407 outfile_check_directory = (char *) mymalloc (session_size);
6408
6409 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6410 }
6411 else
6412 {
6413 outfile_check_directory = outfile_check_dir;
6414 }
6415
6416 data.outfile_check_directory = outfile_check_directory;
6417
6418 if (keyspace == 0)
6419 {
6420 struct stat outfile_check_stat;
6421
6422 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6423 {
6424 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6425
6426 if (is_dir == 0)
6427 {
6428 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6429
6430 return (-1);
6431 }
6432 }
6433 else if (outfile_check_dir == NULL)
6434 {
6435 if (mkdir (outfile_check_directory, 0700) == -1)
6436 {
6437 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6438
6439 return (-1);
6440 }
6441 }
6442 }
6443
6444 /**
6445 * special other stuff
6446 */
6447
6448 if (hash_mode == 9710)
6449 {
6450 outfile_format = 5;
6451 outfile_format_chgd = 1;
6452 }
6453
6454 if (hash_mode == 9810)
6455 {
6456 outfile_format = 5;
6457 outfile_format_chgd = 1;
6458 }
6459
6460 if (hash_mode == 10410)
6461 {
6462 outfile_format = 5;
6463 outfile_format_chgd = 1;
6464 }
6465
6466 /**
6467 * store stuff
6468 */
6469
6470 data.hash_mode = hash_mode;
6471 data.restore = restore;
6472 data.restore_timer = restore_timer;
6473 data.restore_disable = restore_disable;
6474 data.status = status;
6475 data.status_timer = status_timer;
6476 data.status_automat = status_automat;
6477 data.loopback = loopback;
6478 data.runtime = runtime;
6479 data.remove = remove;
6480 data.remove_timer = remove_timer;
6481 data.debug_mode = debug_mode;
6482 data.debug_file = debug_file;
6483 data.username = username;
6484 data.quiet = quiet;
6485 data.outfile = outfile;
6486 data.outfile_format = outfile_format;
6487 data.outfile_autohex = outfile_autohex;
6488 data.hex_charset = hex_charset;
6489 data.hex_salt = hex_salt;
6490 data.hex_wordlist = hex_wordlist;
6491 data.separator = separator;
6492 data.rp_files = rp_files;
6493 data.rp_files_cnt = rp_files_cnt;
6494 data.rp_gen = rp_gen;
6495 data.rp_gen_seed = rp_gen_seed;
6496 data.force = force;
6497 data.benchmark = benchmark;
6498 data.skip = skip;
6499 data.limit = limit;
6500 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6501 data.powertune_enable = powertune_enable;
6502 #endif
6503 data.logfile_disable = logfile_disable;
6504 data.truecrypt_keyfiles = truecrypt_keyfiles;
6505 data.scrypt_tmto = scrypt_tmto;
6506
6507 /**
6508 * cpu affinity
6509 */
6510
6511 if (cpu_affinity)
6512 {
6513 set_cpu_affinity (cpu_affinity);
6514 }
6515
6516 if (rp_gen_seed_chgd == 0)
6517 {
6518 srand (proc_start);
6519 }
6520 else
6521 {
6522 srand (rp_gen_seed);
6523 }
6524
6525 /**
6526 * logfile init
6527 */
6528
6529 if (logfile_disable == 0)
6530 {
6531 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6532
6533 char *logfile = (char *) mymalloc (logfile_size);
6534
6535 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6536
6537 data.logfile = logfile;
6538
6539 char *topid = logfile_generate_topid ();
6540
6541 data.topid = topid;
6542 }
6543
6544 // logfile_append() checks for logfile_disable internally to make it easier from here
6545
6546 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6547 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6548 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6549 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6550 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6551 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6552 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6553 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6554 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6555 #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));
6556
6557 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6558 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6559 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6560 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6561 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6562 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6563 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6564 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6565
6566 logfile_top_msg ("START");
6567
6568 logfile_top_uint (attack_mode);
6569 logfile_top_uint (attack_kern);
6570 logfile_top_uint (benchmark);
6571 logfile_top_uint (benchmark_mode);
6572 logfile_top_uint (bitmap_min);
6573 logfile_top_uint (bitmap_max);
6574 logfile_top_uint (debug_mode);
6575 logfile_top_uint (force);
6576 logfile_top_uint (kernel_accel);
6577 logfile_top_uint (kernel_loops);
6578 logfile_top_uint (gpu_temp_disable);
6579 #ifdef HAVE_HWMON
6580 logfile_top_uint (gpu_temp_abort);
6581 logfile_top_uint (gpu_temp_retain);
6582 #endif
6583 logfile_top_uint (hash_mode);
6584 logfile_top_uint (hex_charset);
6585 logfile_top_uint (hex_salt);
6586 logfile_top_uint (hex_wordlist);
6587 logfile_top_uint (increment);
6588 logfile_top_uint (increment_max);
6589 logfile_top_uint (increment_min);
6590 logfile_top_uint (keyspace);
6591 logfile_top_uint (left);
6592 logfile_top_uint (logfile_disable);
6593 logfile_top_uint (loopback);
6594 logfile_top_uint (markov_classic);
6595 logfile_top_uint (markov_disable);
6596 logfile_top_uint (markov_threshold);
6597 logfile_top_uint (outfile_autohex);
6598 logfile_top_uint (outfile_check_timer);
6599 logfile_top_uint (outfile_format);
6600 logfile_top_uint (potfile_disable);
6601 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6602 logfile_top_uint (powertune_enable);
6603 #endif
6604 logfile_top_uint (scrypt_tmto);
6605 logfile_top_uint (quiet);
6606 logfile_top_uint (remove);
6607 logfile_top_uint (remove_timer);
6608 logfile_top_uint (restore);
6609 logfile_top_uint (restore_disable);
6610 logfile_top_uint (restore_timer);
6611 logfile_top_uint (rp_gen);
6612 logfile_top_uint (rp_gen_func_max);
6613 logfile_top_uint (rp_gen_func_min);
6614 logfile_top_uint (rp_gen_seed);
6615 logfile_top_uint (runtime);
6616 logfile_top_uint (segment_size);
6617 logfile_top_uint (show);
6618 logfile_top_uint (status);
6619 logfile_top_uint (status_automat);
6620 logfile_top_uint (status_timer);
6621 logfile_top_uint (usage);
6622 logfile_top_uint (username);
6623 logfile_top_uint (version);
6624 logfile_top_uint (weak_hash_threshold);
6625 logfile_top_uint (workload_profile);
6626 logfile_top_uint64 (limit);
6627 logfile_top_uint64 (skip);
6628 logfile_top_char (separator);
6629 logfile_top_string (cpu_affinity);
6630 logfile_top_string (custom_charset_1);
6631 logfile_top_string (custom_charset_2);
6632 logfile_top_string (custom_charset_3);
6633 logfile_top_string (custom_charset_4);
6634 logfile_top_string (debug_file);
6635 logfile_top_string (opencl_devices);
6636 logfile_top_string (opencl_platforms);
6637 logfile_top_string (opencl_device_types);
6638 logfile_top_uint (opencl_vector_width);
6639 logfile_top_string (induction_dir);
6640 logfile_top_string (markov_hcstat);
6641 logfile_top_string (outfile);
6642 logfile_top_string (outfile_check_dir);
6643 logfile_top_string (rule_buf_l);
6644 logfile_top_string (rule_buf_r);
6645 logfile_top_string (session);
6646 logfile_top_string (truecrypt_keyfiles);
6647
6648 /**
6649 * Init OpenCL library loader
6650 */
6651
6652 if (keyspace == 0)
6653 {
6654 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6655
6656 ocl_init (ocl);
6657
6658 data.ocl = ocl;
6659 }
6660
6661 /**
6662 * OpenCL platform selection
6663 */
6664
6665 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6666
6667 /**
6668 * OpenCL device selection
6669 */
6670
6671 u32 devices_filter = setup_devices_filter (opencl_devices);
6672
6673 /**
6674 * OpenCL device type selection
6675 */
6676
6677 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6678
6679 /**
6680 * benchmark
6681 */
6682
6683 if (benchmark == 1)
6684 {
6685 /**
6686 * disable useless stuff for benchmark
6687 */
6688
6689 restore_timer = 0;
6690 status_timer = 0;
6691 restore_disable = 1;
6692 potfile_disable = 1;
6693 weak_hash_threshold = 0;
6694
6695 data.restore_timer = restore_timer;
6696 data.status_timer = status_timer;
6697 data.restore_disable = restore_disable;
6698
6699 if (benchmark_mode == 1)
6700 {
6701 markov_disable = 1;
6702
6703 workload_profile = 3;
6704 }
6705
6706 /**
6707 * force attack mode to be bruteforce
6708 */
6709
6710 attack_mode = ATTACK_MODE_BF;
6711 attack_kern = ATTACK_KERN_BF;
6712
6713 if (runtime_chgd == 0)
6714 {
6715 runtime = 8;
6716
6717 if (benchmark_mode == 1) runtime = 17;
6718
6719 data.runtime = runtime;
6720 }
6721 }
6722
6723 /**
6724 * config
6725 */
6726
6727 uint hash_type = 0;
6728 uint salt_type = 0;
6729 uint attack_exec = 0;
6730 uint opts_type = 0;
6731 uint kern_type = 0;
6732 uint dgst_size = 0;
6733 uint esalt_size = 0;
6734 uint opti_type = 0;
6735 uint dgst_pos0 = -1;
6736 uint dgst_pos1 = -1;
6737 uint dgst_pos2 = -1;
6738 uint dgst_pos3 = -1;
6739
6740 int (*parse_func) (char *, uint, hash_t *);
6741 int (*sort_by_digest) (const void *, const void *);
6742
6743 uint algorithm_pos = 0;
6744 uint algorithm_max = 1;
6745
6746 uint *algorithms = default_benchmark_algorithms;
6747
6748 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6749
6750 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6751 {
6752 /*
6753 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6754 * the following algos are skipped entirely
6755 */
6756
6757 if (algorithm_pos > 0)
6758 {
6759 local_free (rd);
6760
6761 rd = init_restore (argc, argv);
6762
6763 data.rd = rd;
6764 }
6765
6766 /**
6767 * update hash_mode in case of multihash benchmark
6768 */
6769
6770 if (benchmark == 1)
6771 {
6772 if (hash_mode_chgd == 0)
6773 {
6774 hash_mode = algorithms[algorithm_pos];
6775
6776 data.hash_mode = hash_mode;
6777 }
6778
6779 quiet = 1;
6780
6781 data.quiet = quiet;
6782 }
6783
6784 switch (hash_mode)
6785 {
6786 case 0: hash_type = HASH_TYPE_MD5;
6787 salt_type = SALT_TYPE_NONE;
6788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6789 opts_type = OPTS_TYPE_PT_GENERATE_LE
6790 | OPTS_TYPE_PT_ADD80
6791 | OPTS_TYPE_PT_ADDBITS14;
6792 kern_type = KERN_TYPE_MD5;
6793 dgst_size = DGST_SIZE_4_4;
6794 parse_func = md5_parse_hash;
6795 sort_by_digest = sort_by_digest_4_4;
6796 opti_type = OPTI_TYPE_ZERO_BYTE
6797 | OPTI_TYPE_PRECOMPUTE_INIT
6798 | OPTI_TYPE_PRECOMPUTE_MERKLE
6799 | OPTI_TYPE_MEET_IN_MIDDLE
6800 | OPTI_TYPE_EARLY_SKIP
6801 | OPTI_TYPE_NOT_ITERATED
6802 | OPTI_TYPE_NOT_SALTED
6803 | OPTI_TYPE_RAW_HASH;
6804 dgst_pos0 = 0;
6805 dgst_pos1 = 3;
6806 dgst_pos2 = 2;
6807 dgst_pos3 = 1;
6808 break;
6809
6810 case 10: hash_type = HASH_TYPE_MD5;
6811 salt_type = SALT_TYPE_INTERN;
6812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6813 opts_type = OPTS_TYPE_PT_GENERATE_LE
6814 | OPTS_TYPE_ST_ADD80
6815 | OPTS_TYPE_ST_ADDBITS14;
6816 kern_type = KERN_TYPE_MD5_PWSLT;
6817 dgst_size = DGST_SIZE_4_4;
6818 parse_func = md5s_parse_hash;
6819 sort_by_digest = sort_by_digest_4_4;
6820 opti_type = OPTI_TYPE_ZERO_BYTE
6821 | OPTI_TYPE_PRECOMPUTE_INIT
6822 | OPTI_TYPE_PRECOMPUTE_MERKLE
6823 | OPTI_TYPE_MEET_IN_MIDDLE
6824 | OPTI_TYPE_EARLY_SKIP
6825 | OPTI_TYPE_NOT_ITERATED
6826 | OPTI_TYPE_APPENDED_SALT
6827 | OPTI_TYPE_RAW_HASH;
6828 dgst_pos0 = 0;
6829 dgst_pos1 = 3;
6830 dgst_pos2 = 2;
6831 dgst_pos3 = 1;
6832 break;
6833
6834 case 11: hash_type = HASH_TYPE_MD5;
6835 salt_type = SALT_TYPE_INTERN;
6836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6837 opts_type = OPTS_TYPE_PT_GENERATE_LE
6838 | OPTS_TYPE_ST_ADD80
6839 | OPTS_TYPE_ST_ADDBITS14;
6840 kern_type = KERN_TYPE_MD5_PWSLT;
6841 dgst_size = DGST_SIZE_4_4;
6842 parse_func = joomla_parse_hash;
6843 sort_by_digest = sort_by_digest_4_4;
6844 opti_type = OPTI_TYPE_ZERO_BYTE
6845 | OPTI_TYPE_PRECOMPUTE_INIT
6846 | OPTI_TYPE_PRECOMPUTE_MERKLE
6847 | OPTI_TYPE_MEET_IN_MIDDLE
6848 | OPTI_TYPE_EARLY_SKIP
6849 | OPTI_TYPE_NOT_ITERATED
6850 | OPTI_TYPE_APPENDED_SALT
6851 | OPTI_TYPE_RAW_HASH;
6852 dgst_pos0 = 0;
6853 dgst_pos1 = 3;
6854 dgst_pos2 = 2;
6855 dgst_pos3 = 1;
6856 break;
6857
6858 case 12: hash_type = HASH_TYPE_MD5;
6859 salt_type = SALT_TYPE_INTERN;
6860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6861 opts_type = OPTS_TYPE_PT_GENERATE_LE
6862 | OPTS_TYPE_ST_ADD80
6863 | OPTS_TYPE_ST_ADDBITS14;
6864 kern_type = KERN_TYPE_MD5_PWSLT;
6865 dgst_size = DGST_SIZE_4_4;
6866 parse_func = postgresql_parse_hash;
6867 sort_by_digest = sort_by_digest_4_4;
6868 opti_type = OPTI_TYPE_ZERO_BYTE
6869 | OPTI_TYPE_PRECOMPUTE_INIT
6870 | OPTI_TYPE_PRECOMPUTE_MERKLE
6871 | OPTI_TYPE_MEET_IN_MIDDLE
6872 | OPTI_TYPE_EARLY_SKIP
6873 | OPTI_TYPE_NOT_ITERATED
6874 | OPTI_TYPE_APPENDED_SALT
6875 | OPTI_TYPE_RAW_HASH;
6876 dgst_pos0 = 0;
6877 dgst_pos1 = 3;
6878 dgst_pos2 = 2;
6879 dgst_pos3 = 1;
6880 break;
6881
6882 case 20: hash_type = HASH_TYPE_MD5;
6883 salt_type = SALT_TYPE_INTERN;
6884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6885 opts_type = OPTS_TYPE_PT_GENERATE_LE
6886 | OPTS_TYPE_PT_ADD80
6887 | OPTS_TYPE_PT_ADDBITS14;
6888 kern_type = KERN_TYPE_MD5_SLTPW;
6889 dgst_size = DGST_SIZE_4_4;
6890 parse_func = md5s_parse_hash;
6891 sort_by_digest = sort_by_digest_4_4;
6892 opti_type = OPTI_TYPE_ZERO_BYTE
6893 | OPTI_TYPE_PRECOMPUTE_INIT
6894 | OPTI_TYPE_PRECOMPUTE_MERKLE
6895 | OPTI_TYPE_EARLY_SKIP
6896 | OPTI_TYPE_NOT_ITERATED
6897 | OPTI_TYPE_PREPENDED_SALT
6898 | OPTI_TYPE_RAW_HASH;
6899 dgst_pos0 = 0;
6900 dgst_pos1 = 3;
6901 dgst_pos2 = 2;
6902 dgst_pos3 = 1;
6903 break;
6904
6905 case 21: hash_type = HASH_TYPE_MD5;
6906 salt_type = SALT_TYPE_INTERN;
6907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6908 opts_type = OPTS_TYPE_PT_GENERATE_LE
6909 | OPTS_TYPE_PT_ADD80
6910 | OPTS_TYPE_PT_ADDBITS14;
6911 kern_type = KERN_TYPE_MD5_SLTPW;
6912 dgst_size = DGST_SIZE_4_4;
6913 parse_func = osc_parse_hash;
6914 sort_by_digest = sort_by_digest_4_4;
6915 opti_type = OPTI_TYPE_ZERO_BYTE
6916 | OPTI_TYPE_PRECOMPUTE_INIT
6917 | OPTI_TYPE_PRECOMPUTE_MERKLE
6918 | OPTI_TYPE_EARLY_SKIP
6919 | OPTI_TYPE_NOT_ITERATED
6920 | OPTI_TYPE_PREPENDED_SALT
6921 | OPTI_TYPE_RAW_HASH;
6922 dgst_pos0 = 0;
6923 dgst_pos1 = 3;
6924 dgst_pos2 = 2;
6925 dgst_pos3 = 1;
6926 break;
6927
6928 case 22: hash_type = HASH_TYPE_MD5;
6929 salt_type = SALT_TYPE_EMBEDDED;
6930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6931 opts_type = OPTS_TYPE_PT_GENERATE_LE
6932 | OPTS_TYPE_PT_ADD80
6933 | OPTS_TYPE_PT_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5_SLTPW;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = netscreen_parse_hash;
6937 sort_by_digest = sort_by_digest_4_4;
6938 opti_type = OPTI_TYPE_ZERO_BYTE
6939 | OPTI_TYPE_PRECOMPUTE_INIT
6940 | OPTI_TYPE_PRECOMPUTE_MERKLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_PREPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 23: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_EMBEDDED;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14;
6957 kern_type = KERN_TYPE_MD5_SLTPW;
6958 dgst_size = DGST_SIZE_4_4;
6959 parse_func = skype_parse_hash;
6960 sort_by_digest = sort_by_digest_4_4;
6961 opti_type = OPTI_TYPE_ZERO_BYTE
6962 | OPTI_TYPE_PRECOMPUTE_INIT
6963 | OPTI_TYPE_PRECOMPUTE_MERKLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_PREPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 30: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_UNICODE
6979 | OPTS_TYPE_ST_ADD80
6980 | OPTS_TYPE_ST_ADDBITS14;
6981 kern_type = KERN_TYPE_MD5_PWUSLT;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = md5s_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_PRECOMPUTE_INIT
6987 | OPTI_TYPE_PRECOMPUTE_MERKLE
6988 | OPTI_TYPE_MEET_IN_MIDDLE
6989 | OPTI_TYPE_EARLY_SKIP
6990 | OPTI_TYPE_NOT_ITERATED
6991 | OPTI_TYPE_APPENDED_SALT
6992 | OPTI_TYPE_RAW_HASH;
6993 dgst_pos0 = 0;
6994 dgst_pos1 = 3;
6995 dgst_pos2 = 2;
6996 dgst_pos3 = 1;
6997 break;
6998
6999 case 40: hash_type = HASH_TYPE_MD5;
7000 salt_type = SALT_TYPE_INTERN;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_LE
7003 | OPTS_TYPE_PT_ADD80
7004 | OPTS_TYPE_PT_ADDBITS14
7005 | OPTS_TYPE_PT_UNICODE;
7006 kern_type = KERN_TYPE_MD5_SLTPWU;
7007 dgst_size = DGST_SIZE_4_4;
7008 parse_func = md5s_parse_hash;
7009 sort_by_digest = sort_by_digest_4_4;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_PRECOMPUTE_INIT
7012 | OPTI_TYPE_PRECOMPUTE_MERKLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_PREPENDED_SALT
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 0;
7018 dgst_pos1 = 3;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 50: hash_type = HASH_TYPE_MD5;
7024 salt_type = SALT_TYPE_INTERN;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_LE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS14;
7029 kern_type = KERN_TYPE_HMACMD5_PW;
7030 dgst_size = DGST_SIZE_4_4;
7031 parse_func = hmacmd5_parse_hash;
7032 sort_by_digest = sort_by_digest_4_4;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_NOT_ITERATED;
7035 dgst_pos0 = 0;
7036 dgst_pos1 = 3;
7037 dgst_pos2 = 2;
7038 dgst_pos3 = 1;
7039 break;
7040
7041 case 60: hash_type = HASH_TYPE_MD5;
7042 salt_type = SALT_TYPE_INTERN;
7043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7044 opts_type = OPTS_TYPE_PT_GENERATE_LE
7045 | OPTS_TYPE_PT_ADD80
7046 | OPTS_TYPE_PT_ADDBITS14;
7047 kern_type = KERN_TYPE_HMACMD5_SLT;
7048 dgst_size = DGST_SIZE_4_4;
7049 parse_func = hmacmd5_parse_hash;
7050 sort_by_digest = sort_by_digest_4_4;
7051 opti_type = OPTI_TYPE_ZERO_BYTE
7052 | OPTI_TYPE_NOT_ITERATED;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 100: hash_type = HASH_TYPE_SHA1;
7060 salt_type = SALT_TYPE_NONE;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_BE
7063 | OPTS_TYPE_PT_ADD80
7064 | OPTS_TYPE_PT_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = sha1_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 101: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_NONE;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_PT_ADD80
7087 | OPTS_TYPE_PT_ADDBITS15;
7088 kern_type = KERN_TYPE_SHA1;
7089 dgst_size = DGST_SIZE_4_5;
7090 parse_func = sha1b64_parse_hash;
7091 sort_by_digest = sort_by_digest_4_5;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_NOT_SALTED
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 3;
7100 dgst_pos1 = 4;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 110: hash_type = HASH_TYPE_SHA1;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_BE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS15;
7111 kern_type = KERN_TYPE_SHA1_PWSLT;
7112 dgst_size = DGST_SIZE_4_5;
7113 parse_func = sha1s_parse_hash;
7114 sort_by_digest = sort_by_digest_4_5;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_PRECOMPUTE_INIT
7117 | OPTI_TYPE_PRECOMPUTE_MERKLE
7118 | OPTI_TYPE_EARLY_SKIP
7119 | OPTI_TYPE_NOT_ITERATED
7120 | OPTI_TYPE_APPENDED_SALT
7121 | OPTI_TYPE_RAW_HASH;
7122 dgst_pos0 = 3;
7123 dgst_pos1 = 4;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 111: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_EMBEDDED;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_ST_ADD80
7133 | OPTS_TYPE_ST_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1_PWSLT;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1b64s_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_APPENDED_SALT
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 112: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_INTERN;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_ST_ADD80
7156 | OPTS_TYPE_ST_ADDBITS15
7157 | OPTS_TYPE_ST_HEX;
7158 kern_type = KERN_TYPE_SHA1_PWSLT;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = oracles_parse_hash;
7161 sort_by_digest = sort_by_digest_4_5;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_APPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 3;
7170 dgst_pos1 = 4;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 120: hash_type = HASH_TYPE_SHA1;
7176 salt_type = SALT_TYPE_INTERN;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_BE
7179 | OPTS_TYPE_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS15;
7181 kern_type = KERN_TYPE_SHA1_SLTPW;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = sha1s_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 121: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS15
7204 | OPTS_TYPE_ST_LOWER;
7205 kern_type = KERN_TYPE_SHA1_SLTPW;
7206 dgst_size = DGST_SIZE_4_5;
7207 parse_func = smf_parse_hash;
7208 sort_by_digest = sort_by_digest_4_5;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_EARLY_SKIP
7213 | OPTI_TYPE_NOT_ITERATED
7214 | OPTI_TYPE_PREPENDED_SALT
7215 | OPTI_TYPE_RAW_HASH;
7216 dgst_pos0 = 3;
7217 dgst_pos1 = 4;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 122: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_EMBEDDED;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_ADD80
7227 | OPTS_TYPE_PT_ADDBITS15
7228 | OPTS_TYPE_ST_HEX;
7229 kern_type = KERN_TYPE_SHA1_SLTPW;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = osx1_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 3;
7241 dgst_pos1 = 4;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 124: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_EMBEDDED;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS15;
7252 kern_type = KERN_TYPE_SHA1_SLTPW;
7253 dgst_size = DGST_SIZE_4_5;
7254 parse_func = djangosha1_parse_hash;
7255 sort_by_digest = sort_by_digest_4_5;
7256 opti_type = OPTI_TYPE_ZERO_BYTE
7257 | OPTI_TYPE_PRECOMPUTE_INIT
7258 | OPTI_TYPE_PRECOMPUTE_MERKLE
7259 | OPTI_TYPE_EARLY_SKIP
7260 | OPTI_TYPE_NOT_ITERATED
7261 | OPTI_TYPE_PREPENDED_SALT
7262 | OPTI_TYPE_RAW_HASH;
7263 dgst_pos0 = 3;
7264 dgst_pos1 = 4;
7265 dgst_pos2 = 2;
7266 dgst_pos3 = 1;
7267 break;
7268
7269 case 130: hash_type = HASH_TYPE_SHA1;
7270 salt_type = SALT_TYPE_INTERN;
7271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7272 opts_type = OPTS_TYPE_PT_GENERATE_BE
7273 | OPTS_TYPE_PT_UNICODE
7274 | OPTS_TYPE_ST_ADD80
7275 | OPTS_TYPE_ST_ADDBITS15;
7276 kern_type = KERN_TYPE_SHA1_PWUSLT;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = sha1s_parse_hash;
7279 sort_by_digest = sort_by_digest_4_5;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_PRECOMPUTE_INIT
7282 | OPTI_TYPE_PRECOMPUTE_MERKLE
7283 | OPTI_TYPE_EARLY_SKIP
7284 | OPTI_TYPE_NOT_ITERATED
7285 | OPTI_TYPE_APPENDED_SALT
7286 | OPTI_TYPE_RAW_HASH;
7287 dgst_pos0 = 3;
7288 dgst_pos1 = 4;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 131: hash_type = HASH_TYPE_SHA1;
7294 salt_type = SALT_TYPE_EMBEDDED;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_BE
7297 | OPTS_TYPE_PT_UNICODE
7298 | OPTS_TYPE_PT_UPPER
7299 | OPTS_TYPE_ST_ADD80
7300 | OPTS_TYPE_ST_ADDBITS15
7301 | OPTS_TYPE_ST_HEX;
7302 kern_type = KERN_TYPE_SHA1_PWUSLT;
7303 dgst_size = DGST_SIZE_4_5;
7304 parse_func = mssql2000_parse_hash;
7305 sort_by_digest = sort_by_digest_4_5;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_EARLY_SKIP
7310 | OPTI_TYPE_NOT_ITERATED
7311 | OPTI_TYPE_APPENDED_SALT
7312 | OPTI_TYPE_RAW_HASH;
7313 dgst_pos0 = 3;
7314 dgst_pos1 = 4;
7315 dgst_pos2 = 2;
7316 dgst_pos3 = 1;
7317 break;
7318
7319 case 132: hash_type = HASH_TYPE_SHA1;
7320 salt_type = SALT_TYPE_EMBEDDED;
7321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7322 opts_type = OPTS_TYPE_PT_GENERATE_BE
7323 | OPTS_TYPE_PT_UNICODE
7324 | OPTS_TYPE_ST_ADD80
7325 | OPTS_TYPE_ST_ADDBITS15
7326 | OPTS_TYPE_ST_HEX;
7327 kern_type = KERN_TYPE_SHA1_PWUSLT;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = mssql2005_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_PRECOMPUTE_INIT
7333 | OPTI_TYPE_PRECOMPUTE_MERKLE
7334 | OPTI_TYPE_EARLY_SKIP
7335 | OPTI_TYPE_NOT_ITERATED
7336 | OPTI_TYPE_APPENDED_SALT
7337 | OPTI_TYPE_RAW_HASH;
7338 dgst_pos0 = 3;
7339 dgst_pos1 = 4;
7340 dgst_pos2 = 2;
7341 dgst_pos3 = 1;
7342 break;
7343
7344 case 133: hash_type = HASH_TYPE_SHA1;
7345 salt_type = SALT_TYPE_EMBEDDED;
7346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7347 opts_type = OPTS_TYPE_PT_GENERATE_BE
7348 | OPTS_TYPE_PT_UNICODE
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA1_PWUSLT;
7352 dgst_size = DGST_SIZE_4_5;
7353 parse_func = peoplesoft_parse_hash;
7354 sort_by_digest = sort_by_digest_4_5;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_APPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 4;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 1;
7366 break;
7367
7368 case 140: hash_type = HASH_TYPE_SHA1;
7369 salt_type = SALT_TYPE_INTERN;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_PT_ADD80
7373 | OPTS_TYPE_PT_ADDBITS15
7374 | OPTS_TYPE_PT_UNICODE;
7375 kern_type = KERN_TYPE_SHA1_SLTPWU;
7376 dgst_size = DGST_SIZE_4_5;
7377 parse_func = sha1s_parse_hash;
7378 sort_by_digest = sort_by_digest_4_5;
7379 opti_type = OPTI_TYPE_ZERO_BYTE
7380 | OPTI_TYPE_PRECOMPUTE_INIT
7381 | OPTI_TYPE_PRECOMPUTE_MERKLE
7382 | OPTI_TYPE_EARLY_SKIP
7383 | OPTI_TYPE_NOT_ITERATED
7384 | OPTI_TYPE_PREPENDED_SALT
7385 | OPTI_TYPE_RAW_HASH;
7386 dgst_pos0 = 3;
7387 dgst_pos1 = 4;
7388 dgst_pos2 = 2;
7389 dgst_pos3 = 1;
7390 break;
7391
7392 case 141: hash_type = HASH_TYPE_SHA1;
7393 salt_type = SALT_TYPE_EMBEDDED;
7394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7395 opts_type = OPTS_TYPE_PT_GENERATE_BE
7396 | OPTS_TYPE_PT_ADD80
7397 | OPTS_TYPE_PT_ADDBITS15
7398 | OPTS_TYPE_PT_UNICODE
7399 | OPTS_TYPE_ST_BASE64;
7400 kern_type = KERN_TYPE_SHA1_SLTPWU;
7401 dgst_size = DGST_SIZE_4_5;
7402 parse_func = episerver_parse_hash;
7403 sort_by_digest = sort_by_digest_4_5;
7404 opti_type = OPTI_TYPE_ZERO_BYTE
7405 | OPTI_TYPE_PRECOMPUTE_INIT
7406 | OPTI_TYPE_PRECOMPUTE_MERKLE
7407 | OPTI_TYPE_EARLY_SKIP
7408 | OPTI_TYPE_NOT_ITERATED
7409 | OPTI_TYPE_PREPENDED_SALT
7410 | OPTI_TYPE_RAW_HASH;
7411 dgst_pos0 = 3;
7412 dgst_pos1 = 4;
7413 dgst_pos2 = 2;
7414 dgst_pos3 = 1;
7415 break;
7416
7417 case 150: hash_type = HASH_TYPE_SHA1;
7418 salt_type = SALT_TYPE_INTERN;
7419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7420 opts_type = OPTS_TYPE_PT_GENERATE_BE
7421 | OPTS_TYPE_ST_ADD80
7422 | OPTS_TYPE_ST_ADDBITS15;
7423 kern_type = KERN_TYPE_HMACSHA1_PW;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = hmacsha1_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_NOT_ITERATED;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 160: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_INTERN;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_ADD80
7440 | OPTS_TYPE_PT_ADDBITS15;
7441 kern_type = KERN_TYPE_HMACSHA1_SLT;
7442 dgst_size = DGST_SIZE_4_5;
7443 parse_func = hmacsha1_parse_hash;
7444 sort_by_digest = sort_by_digest_4_5;
7445 opti_type = OPTI_TYPE_ZERO_BYTE
7446 | OPTI_TYPE_NOT_ITERATED;
7447 dgst_pos0 = 3;
7448 dgst_pos1 = 4;
7449 dgst_pos2 = 2;
7450 dgst_pos3 = 1;
7451 break;
7452
7453 case 190: hash_type = HASH_TYPE_SHA1;
7454 salt_type = SALT_TYPE_NONE;
7455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7456 opts_type = OPTS_TYPE_PT_GENERATE_BE
7457 | OPTS_TYPE_PT_ADD80
7458 | OPTS_TYPE_PT_ADDBITS15;
7459 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7460 dgst_size = DGST_SIZE_4_5;
7461 parse_func = sha1linkedin_parse_hash;
7462 sort_by_digest = sort_by_digest_4_5;
7463 opti_type = OPTI_TYPE_ZERO_BYTE
7464 | OPTI_TYPE_PRECOMPUTE_INIT
7465 | OPTI_TYPE_EARLY_SKIP
7466 | OPTI_TYPE_NOT_ITERATED
7467 | OPTI_TYPE_NOT_SALTED;
7468 dgst_pos0 = 0;
7469 dgst_pos1 = 4;
7470 dgst_pos2 = 3;
7471 dgst_pos3 = 2;
7472 break;
7473
7474 case 200: hash_type = HASH_TYPE_MYSQL;
7475 salt_type = SALT_TYPE_NONE;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = 0;
7478 kern_type = KERN_TYPE_MYSQL;
7479 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7480 parse_func = mysql323_parse_hash;
7481 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7482 opti_type = OPTI_TYPE_ZERO_BYTE;
7483 dgst_pos0 = 0;
7484 dgst_pos1 = 1;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 3;
7487 break;
7488
7489 case 300: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_NONE;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS15;
7495 kern_type = KERN_TYPE_MYSQL41;
7496 dgst_size = DGST_SIZE_4_5;
7497 parse_func = sha1_parse_hash;
7498 sort_by_digest = sort_by_digest_4_5;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_PRECOMPUTE_MERKLE
7502 | OPTI_TYPE_EARLY_SKIP
7503 | OPTI_TYPE_NOT_ITERATED
7504 | OPTI_TYPE_NOT_SALTED;
7505 dgst_pos0 = 3;
7506 dgst_pos1 = 4;
7507 dgst_pos2 = 2;
7508 dgst_pos3 = 1;
7509 break;
7510
7511 case 400: hash_type = HASH_TYPE_MD5;
7512 salt_type = SALT_TYPE_EMBEDDED;
7513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7515 kern_type = KERN_TYPE_PHPASS;
7516 dgst_size = DGST_SIZE_4_4;
7517 parse_func = phpass_parse_hash;
7518 sort_by_digest = sort_by_digest_4_4;
7519 opti_type = OPTI_TYPE_ZERO_BYTE;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 1;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 3;
7524 break;
7525
7526 case 500: hash_type = HASH_TYPE_MD5;
7527 salt_type = SALT_TYPE_EMBEDDED;
7528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7530 kern_type = KERN_TYPE_MD5CRYPT;
7531 dgst_size = DGST_SIZE_4_4;
7532 parse_func = md5crypt_parse_hash;
7533 sort_by_digest = sort_by_digest_4_4;
7534 opti_type = OPTI_TYPE_ZERO_BYTE;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 1;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 3;
7539 break;
7540
7541 case 501: hash_type = HASH_TYPE_MD5;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_LE
7545 | OPTS_TYPE_HASH_COPY;
7546 kern_type = KERN_TYPE_MD5CRYPT;
7547 dgst_size = DGST_SIZE_4_4;
7548 parse_func = juniper_parse_hash;
7549 sort_by_digest = sort_by_digest_4_4;
7550 opti_type = OPTI_TYPE_ZERO_BYTE;
7551 dgst_pos0 = 0;
7552 dgst_pos1 = 1;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 3;
7555 break;
7556
7557 case 900: hash_type = HASH_TYPE_MD4;
7558 salt_type = SALT_TYPE_NONE;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_LE
7561 | OPTS_TYPE_PT_ADD80
7562 | OPTS_TYPE_PT_ADDBITS14;
7563 kern_type = KERN_TYPE_MD4;
7564 dgst_size = DGST_SIZE_4_4;
7565 parse_func = md4_parse_hash;
7566 sort_by_digest = sort_by_digest_4_4;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_MEET_IN_MIDDLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 0;
7576 dgst_pos1 = 3;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 1000: hash_type = HASH_TYPE_MD4;
7582 salt_type = SALT_TYPE_NONE;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS14
7587 | OPTS_TYPE_PT_UNICODE;
7588 kern_type = KERN_TYPE_MD4_PWU;
7589 dgst_size = DGST_SIZE_4_4;
7590 parse_func = md4_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_MEET_IN_MIDDLE
7596 | OPTI_TYPE_EARLY_SKIP
7597 | OPTI_TYPE_NOT_ITERATED
7598 | OPTI_TYPE_NOT_SALTED
7599 | OPTI_TYPE_RAW_HASH;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 3;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 1;
7604 break;
7605
7606 case 1100: hash_type = HASH_TYPE_MD4;
7607 salt_type = SALT_TYPE_INTERN;
7608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_LE
7610 | OPTS_TYPE_PT_ADD80
7611 | OPTS_TYPE_PT_ADDBITS14
7612 | OPTS_TYPE_PT_UNICODE
7613 | OPTS_TYPE_ST_ADD80
7614 | OPTS_TYPE_ST_UNICODE
7615 | OPTS_TYPE_ST_LOWER;
7616 kern_type = KERN_TYPE_MD44_PWUSLT;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = dcc_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED;
7625 dgst_pos0 = 0;
7626 dgst_pos1 = 3;
7627 dgst_pos2 = 2;
7628 dgst_pos3 = 1;
7629 break;
7630
7631 case 1400: hash_type = HASH_TYPE_SHA256;
7632 salt_type = SALT_TYPE_NONE;
7633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7634 opts_type = OPTS_TYPE_PT_GENERATE_BE
7635 | OPTS_TYPE_PT_ADD80
7636 | OPTS_TYPE_PT_ADDBITS15;
7637 kern_type = KERN_TYPE_SHA256;
7638 dgst_size = DGST_SIZE_4_8;
7639 parse_func = sha256_parse_hash;
7640 sort_by_digest = sort_by_digest_4_8;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_PRECOMPUTE_INIT
7643 | OPTI_TYPE_PRECOMPUTE_MERKLE
7644 | OPTI_TYPE_EARLY_SKIP
7645 | OPTI_TYPE_NOT_ITERATED
7646 | OPTI_TYPE_NOT_SALTED
7647 | OPTI_TYPE_RAW_HASH;
7648 dgst_pos0 = 3;
7649 dgst_pos1 = 7;
7650 dgst_pos2 = 2;
7651 dgst_pos3 = 6;
7652 break;
7653
7654 case 1410: hash_type = HASH_TYPE_SHA256;
7655 salt_type = SALT_TYPE_INTERN;
7656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7657 opts_type = OPTS_TYPE_PT_GENERATE_BE
7658 | OPTS_TYPE_ST_ADD80
7659 | OPTS_TYPE_ST_ADDBITS15;
7660 kern_type = KERN_TYPE_SHA256_PWSLT;
7661 dgst_size = DGST_SIZE_4_8;
7662 parse_func = sha256s_parse_hash;
7663 sort_by_digest = sort_by_digest_4_8;
7664 opti_type = OPTI_TYPE_ZERO_BYTE
7665 | OPTI_TYPE_PRECOMPUTE_INIT
7666 | OPTI_TYPE_PRECOMPUTE_MERKLE
7667 | OPTI_TYPE_EARLY_SKIP
7668 | OPTI_TYPE_NOT_ITERATED
7669 | OPTI_TYPE_APPENDED_SALT
7670 | OPTI_TYPE_RAW_HASH;
7671 dgst_pos0 = 3;
7672 dgst_pos1 = 7;
7673 dgst_pos2 = 2;
7674 dgst_pos3 = 6;
7675 break;
7676
7677 case 1420: hash_type = HASH_TYPE_SHA256;
7678 salt_type = SALT_TYPE_INTERN;
7679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680 opts_type = OPTS_TYPE_PT_GENERATE_BE
7681 | OPTS_TYPE_PT_ADD80
7682 | OPTS_TYPE_PT_ADDBITS15;
7683 kern_type = KERN_TYPE_SHA256_SLTPW;
7684 dgst_size = DGST_SIZE_4_8;
7685 parse_func = sha256s_parse_hash;
7686 sort_by_digest = sort_by_digest_4_8;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_PRECOMPUTE_MERKLE
7690 | OPTI_TYPE_EARLY_SKIP
7691 | OPTI_TYPE_NOT_ITERATED
7692 | OPTI_TYPE_PREPENDED_SALT
7693 | OPTI_TYPE_RAW_HASH;
7694 dgst_pos0 = 3;
7695 dgst_pos1 = 7;
7696 dgst_pos2 = 2;
7697 dgst_pos3 = 6;
7698 break;
7699
7700 case 1421: hash_type = HASH_TYPE_SHA256;
7701 salt_type = SALT_TYPE_EMBEDDED;
7702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7703 opts_type = OPTS_TYPE_PT_GENERATE_BE
7704 | OPTS_TYPE_PT_ADD80
7705 | OPTS_TYPE_PT_ADDBITS15;
7706 kern_type = KERN_TYPE_SHA256_SLTPW;
7707 dgst_size = DGST_SIZE_4_8;
7708 parse_func = hmailserver_parse_hash;
7709 sort_by_digest = sort_by_digest_4_8;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_PREPENDED_SALT
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 3;
7718 dgst_pos1 = 7;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 6;
7721 break;
7722
7723 case 1430: hash_type = HASH_TYPE_SHA256;
7724 salt_type = SALT_TYPE_INTERN;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_PT_UNICODE
7728 | OPTS_TYPE_ST_ADD80
7729 | OPTS_TYPE_ST_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256_PWUSLT;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = sha256s_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_APPENDED_SALT
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1440: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_PT_ADD80
7752 | OPTS_TYPE_PT_ADDBITS15
7753 | OPTS_TYPE_PT_UNICODE;
7754 kern_type = KERN_TYPE_SHA256_SLTPWU;
7755 dgst_size = DGST_SIZE_4_8;
7756 parse_func = sha256s_parse_hash;
7757 sort_by_digest = sort_by_digest_4_8;
7758 opti_type = OPTI_TYPE_ZERO_BYTE
7759 | OPTI_TYPE_PRECOMPUTE_INIT
7760 | OPTI_TYPE_PRECOMPUTE_MERKLE
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_PREPENDED_SALT
7764 | OPTI_TYPE_RAW_HASH;
7765 dgst_pos0 = 3;
7766 dgst_pos1 = 7;
7767 dgst_pos2 = 2;
7768 dgst_pos3 = 6;
7769 break;
7770
7771 case 1441: hash_type = HASH_TYPE_SHA256;
7772 salt_type = SALT_TYPE_EMBEDDED;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_BE
7775 | OPTS_TYPE_PT_ADD80
7776 | OPTS_TYPE_PT_ADDBITS15
7777 | OPTS_TYPE_PT_UNICODE
7778 | OPTS_TYPE_ST_BASE64;
7779 kern_type = KERN_TYPE_SHA256_SLTPWU;
7780 dgst_size = DGST_SIZE_4_8;
7781 parse_func = episerver4_parse_hash;
7782 sort_by_digest = sort_by_digest_4_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_PREPENDED_SALT
7789 | OPTI_TYPE_RAW_HASH;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 7;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 6;
7794 break;
7795
7796 case 1450: hash_type = HASH_TYPE_SHA256;
7797 salt_type = SALT_TYPE_INTERN;
7798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_BE
7800 | OPTS_TYPE_ST_ADD80;
7801 kern_type = KERN_TYPE_HMACSHA256_PW;
7802 dgst_size = DGST_SIZE_4_8;
7803 parse_func = hmacsha256_parse_hash;
7804 sort_by_digest = sort_by_digest_4_8;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_NOT_ITERATED;
7807 dgst_pos0 = 3;
7808 dgst_pos1 = 7;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 6;
7811 break;
7812
7813 case 1460: hash_type = HASH_TYPE_SHA256;
7814 salt_type = SALT_TYPE_INTERN;
7815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_BE
7817 | OPTS_TYPE_PT_ADD80
7818 | OPTS_TYPE_PT_ADDBITS15;
7819 kern_type = KERN_TYPE_HMACSHA256_SLT;
7820 dgst_size = DGST_SIZE_4_8;
7821 parse_func = hmacsha256_parse_hash;
7822 sort_by_digest = sort_by_digest_4_8;
7823 opti_type = OPTI_TYPE_ZERO_BYTE
7824 | OPTI_TYPE_NOT_ITERATED;
7825 dgst_pos0 = 3;
7826 dgst_pos1 = 7;
7827 dgst_pos2 = 2;
7828 dgst_pos3 = 6;
7829 break;
7830
7831 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7832 salt_type = SALT_TYPE_EMBEDDED;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_LE
7835 | OPTS_TYPE_PT_BITSLICE;
7836 kern_type = KERN_TYPE_DESCRYPT;
7837 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7838 parse_func = descrypt_parse_hash;
7839 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7842 dgst_pos0 = 0;
7843 dgst_pos1 = 1;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 3;
7846 break;
7847
7848 case 1600: hash_type = HASH_TYPE_MD5;
7849 salt_type = SALT_TYPE_EMBEDDED;
7850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7852 kern_type = KERN_TYPE_APR1CRYPT;
7853 dgst_size = DGST_SIZE_4_4;
7854 parse_func = md5apr1_parse_hash;
7855 sort_by_digest = sort_by_digest_4_4;
7856 opti_type = OPTI_TYPE_ZERO_BYTE;
7857 dgst_pos0 = 0;
7858 dgst_pos1 = 1;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 3;
7861 break;
7862
7863 case 1700: hash_type = HASH_TYPE_SHA512;
7864 salt_type = SALT_TYPE_NONE;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_BE
7867 | OPTS_TYPE_PT_ADD80
7868 | OPTS_TYPE_PT_ADDBITS15;
7869 kern_type = KERN_TYPE_SHA512;
7870 dgst_size = DGST_SIZE_8_8;
7871 parse_func = sha512_parse_hash;
7872 sort_by_digest = sort_by_digest_8_8;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_NOT_SALTED
7879 | OPTI_TYPE_USES_BITS_64
7880 | OPTI_TYPE_RAW_HASH;
7881 dgst_pos0 = 14;
7882 dgst_pos1 = 15;
7883 dgst_pos2 = 6;
7884 dgst_pos3 = 7;
7885 break;
7886
7887 case 1710: hash_type = HASH_TYPE_SHA512;
7888 salt_type = SALT_TYPE_INTERN;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_BE
7891 | OPTS_TYPE_ST_ADD80
7892 | OPTS_TYPE_ST_ADDBITS15;
7893 kern_type = KERN_TYPE_SHA512_PWSLT;
7894 dgst_size = DGST_SIZE_8_8;
7895 parse_func = sha512s_parse_hash;
7896 sort_by_digest = sort_by_digest_8_8;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_APPENDED_SALT
7903 | OPTI_TYPE_USES_BITS_64
7904 | OPTI_TYPE_RAW_HASH;
7905 dgst_pos0 = 14;
7906 dgst_pos1 = 15;
7907 dgst_pos2 = 6;
7908 dgst_pos3 = 7;
7909 break;
7910
7911 case 1711: hash_type = HASH_TYPE_SHA512;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_BE
7915 | OPTS_TYPE_ST_ADD80
7916 | OPTS_TYPE_ST_ADDBITS15;
7917 kern_type = KERN_TYPE_SHA512_PWSLT;
7918 dgst_size = DGST_SIZE_8_8;
7919 parse_func = sha512b64s_parse_hash;
7920 sort_by_digest = sort_by_digest_8_8;
7921 opti_type = OPTI_TYPE_ZERO_BYTE
7922 | OPTI_TYPE_PRECOMPUTE_INIT
7923 | OPTI_TYPE_PRECOMPUTE_MERKLE
7924 | OPTI_TYPE_EARLY_SKIP
7925 | OPTI_TYPE_NOT_ITERATED
7926 | OPTI_TYPE_APPENDED_SALT
7927 | OPTI_TYPE_USES_BITS_64
7928 | OPTI_TYPE_RAW_HASH;
7929 dgst_pos0 = 14;
7930 dgst_pos1 = 15;
7931 dgst_pos2 = 6;
7932 dgst_pos3 = 7;
7933 break;
7934
7935 case 1720: hash_type = HASH_TYPE_SHA512;
7936 salt_type = SALT_TYPE_INTERN;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_ADD80
7940 | OPTS_TYPE_PT_ADDBITS15;
7941 kern_type = KERN_TYPE_SHA512_SLTPW;
7942 dgst_size = DGST_SIZE_8_8;
7943 parse_func = sha512s_parse_hash;
7944 sort_by_digest = sort_by_digest_8_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_PRECOMPUTE_INIT
7947 | OPTI_TYPE_PRECOMPUTE_MERKLE
7948 | OPTI_TYPE_EARLY_SKIP
7949 | OPTI_TYPE_NOT_ITERATED
7950 | OPTI_TYPE_PREPENDED_SALT
7951 | OPTI_TYPE_USES_BITS_64
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 14;
7954 dgst_pos1 = 15;
7955 dgst_pos2 = 6;
7956 dgst_pos3 = 7;
7957 break;
7958
7959 case 1722: hash_type = HASH_TYPE_SHA512;
7960 salt_type = SALT_TYPE_EMBEDDED;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS15
7965 | OPTS_TYPE_ST_HEX;
7966 kern_type = KERN_TYPE_SHA512_SLTPW;
7967 dgst_size = DGST_SIZE_8_8;
7968 parse_func = osx512_parse_hash;
7969 sort_by_digest = sort_by_digest_8_8;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP
7974 | OPTI_TYPE_NOT_ITERATED
7975 | OPTI_TYPE_PREPENDED_SALT
7976 | OPTI_TYPE_USES_BITS_64
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 14;
7979 dgst_pos1 = 15;
7980 dgst_pos2 = 6;
7981 dgst_pos3 = 7;
7982 break;
7983
7984 case 1730: hash_type = HASH_TYPE_SHA512;
7985 salt_type = SALT_TYPE_INTERN;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_PT_UNICODE
7989 | OPTS_TYPE_ST_ADD80
7990 | OPTS_TYPE_ST_ADDBITS15;
7991 kern_type = KERN_TYPE_SHA512_PWSLTU;
7992 dgst_size = DGST_SIZE_8_8;
7993 parse_func = sha512s_parse_hash;
7994 sort_by_digest = sort_by_digest_8_8;
7995 opti_type = OPTI_TYPE_ZERO_BYTE
7996 | OPTI_TYPE_PRECOMPUTE_INIT
7997 | OPTI_TYPE_PRECOMPUTE_MERKLE
7998 | OPTI_TYPE_EARLY_SKIP
7999 | OPTI_TYPE_NOT_ITERATED
8000 | OPTI_TYPE_APPENDED_SALT
8001 | OPTI_TYPE_USES_BITS_64
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 14;
8004 dgst_pos1 = 15;
8005 dgst_pos2 = 6;
8006 dgst_pos3 = 7;
8007 break;
8008
8009 case 1731: hash_type = HASH_TYPE_SHA512;
8010 salt_type = SALT_TYPE_EMBEDDED;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_PT_UNICODE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15
8016 | OPTS_TYPE_ST_HEX;
8017 kern_type = KERN_TYPE_SHA512_PWSLTU;
8018 dgst_size = DGST_SIZE_8_8;
8019 parse_func = mssql2012_parse_hash;
8020 sort_by_digest = sort_by_digest_8_8;
8021 opti_type = OPTI_TYPE_ZERO_BYTE
8022 | OPTI_TYPE_PRECOMPUTE_INIT
8023 | OPTI_TYPE_PRECOMPUTE_MERKLE
8024 | OPTI_TYPE_EARLY_SKIP
8025 | OPTI_TYPE_NOT_ITERATED
8026 | OPTI_TYPE_APPENDED_SALT
8027 | OPTI_TYPE_USES_BITS_64
8028 | OPTI_TYPE_RAW_HASH;
8029 dgst_pos0 = 14;
8030 dgst_pos1 = 15;
8031 dgst_pos2 = 6;
8032 dgst_pos3 = 7;
8033 break;
8034
8035 case 1740: hash_type = HASH_TYPE_SHA512;
8036 salt_type = SALT_TYPE_INTERN;
8037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8038 opts_type = OPTS_TYPE_PT_GENERATE_BE
8039 | OPTS_TYPE_PT_ADD80
8040 | OPTS_TYPE_PT_ADDBITS15
8041 | OPTS_TYPE_PT_UNICODE;
8042 kern_type = KERN_TYPE_SHA512_SLTPWU;
8043 dgst_size = DGST_SIZE_8_8;
8044 parse_func = sha512s_parse_hash;
8045 sort_by_digest = sort_by_digest_8_8;
8046 opti_type = OPTI_TYPE_ZERO_BYTE
8047 | OPTI_TYPE_PRECOMPUTE_INIT
8048 | OPTI_TYPE_PRECOMPUTE_MERKLE
8049 | OPTI_TYPE_EARLY_SKIP
8050 | OPTI_TYPE_NOT_ITERATED
8051 | OPTI_TYPE_PREPENDED_SALT
8052 | OPTI_TYPE_USES_BITS_64
8053 | OPTI_TYPE_RAW_HASH;
8054 dgst_pos0 = 14;
8055 dgst_pos1 = 15;
8056 dgst_pos2 = 6;
8057 dgst_pos3 = 7;
8058 break;
8059
8060 case 1750: hash_type = HASH_TYPE_SHA512;
8061 salt_type = SALT_TYPE_INTERN;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_BE
8064 | OPTS_TYPE_ST_ADD80;
8065 kern_type = KERN_TYPE_HMACSHA512_PW;
8066 dgst_size = DGST_SIZE_8_8;
8067 parse_func = hmacsha512_parse_hash;
8068 sort_by_digest = sort_by_digest_8_8;
8069 opti_type = OPTI_TYPE_ZERO_BYTE
8070 | OPTI_TYPE_USES_BITS_64
8071 | OPTI_TYPE_NOT_ITERATED;
8072 dgst_pos0 = 14;
8073 dgst_pos1 = 15;
8074 dgst_pos2 = 6;
8075 dgst_pos3 = 7;
8076 break;
8077
8078 case 1760: hash_type = HASH_TYPE_SHA512;
8079 salt_type = SALT_TYPE_INTERN;
8080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8081 opts_type = OPTS_TYPE_PT_GENERATE_BE
8082 | OPTS_TYPE_PT_ADD80
8083 | OPTS_TYPE_PT_ADDBITS15;
8084 kern_type = KERN_TYPE_HMACSHA512_SLT;
8085 dgst_size = DGST_SIZE_8_8;
8086 parse_func = hmacsha512_parse_hash;
8087 sort_by_digest = sort_by_digest_8_8;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_USES_BITS_64
8090 | OPTI_TYPE_NOT_ITERATED;
8091 dgst_pos0 = 14;
8092 dgst_pos1 = 15;
8093 dgst_pos2 = 6;
8094 dgst_pos3 = 7;
8095 break;
8096
8097 case 1800: hash_type = HASH_TYPE_SHA512;
8098 salt_type = SALT_TYPE_EMBEDDED;
8099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8101 kern_type = KERN_TYPE_SHA512CRYPT;
8102 dgst_size = DGST_SIZE_8_8;
8103 parse_func = sha512crypt_parse_hash;
8104 sort_by_digest = sort_by_digest_8_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_USES_BITS_64;
8107 dgst_pos0 = 0;
8108 dgst_pos1 = 1;
8109 dgst_pos2 = 2;
8110 dgst_pos3 = 3;
8111 break;
8112
8113 case 2100: hash_type = HASH_TYPE_DCC2;
8114 salt_type = SALT_TYPE_EMBEDDED;
8115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_ST_LOWER
8118 | OPTS_TYPE_ST_UNICODE;
8119 kern_type = KERN_TYPE_DCC2;
8120 dgst_size = DGST_SIZE_4_4;
8121 parse_func = dcc2_parse_hash;
8122 sort_by_digest = sort_by_digest_4_4;
8123 opti_type = OPTI_TYPE_ZERO_BYTE;
8124 dgst_pos0 = 0;
8125 dgst_pos1 = 1;
8126 dgst_pos2 = 2;
8127 dgst_pos3 = 3;
8128 break;
8129
8130 case 2400: hash_type = HASH_TYPE_MD5;
8131 salt_type = SALT_TYPE_NONE;
8132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8133 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8134 kern_type = KERN_TYPE_MD5PIX;
8135 dgst_size = DGST_SIZE_4_4;
8136 parse_func = md5pix_parse_hash;
8137 sort_by_digest = sort_by_digest_4_4;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_ITERATED
8143 | OPTI_TYPE_NOT_SALTED;
8144 dgst_pos0 = 0;
8145 dgst_pos1 = 3;
8146 dgst_pos2 = 2;
8147 dgst_pos3 = 1;
8148 break;
8149
8150 case 2410: hash_type = HASH_TYPE_MD5;
8151 salt_type = SALT_TYPE_INTERN;
8152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8154 kern_type = KERN_TYPE_MD5ASA;
8155 dgst_size = DGST_SIZE_4_4;
8156 parse_func = md5asa_parse_hash;
8157 sort_by_digest = sort_by_digest_4_4;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_PRECOMPUTE_INIT
8160 | OPTI_TYPE_PRECOMPUTE_MERKLE
8161 | OPTI_TYPE_EARLY_SKIP
8162 | OPTI_TYPE_NOT_ITERATED;
8163 dgst_pos0 = 0;
8164 dgst_pos1 = 3;
8165 dgst_pos2 = 2;
8166 dgst_pos3 = 1;
8167 break;
8168
8169 case 2500: hash_type = HASH_TYPE_WPA;
8170 salt_type = SALT_TYPE_EMBEDDED;
8171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8172 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8173 kern_type = KERN_TYPE_WPA;
8174 dgst_size = DGST_SIZE_4_4;
8175 parse_func = wpa_parse_hash;
8176 sort_by_digest = sort_by_digest_4_4;
8177 opti_type = OPTI_TYPE_ZERO_BYTE;
8178 dgst_pos0 = 0;
8179 dgst_pos1 = 1;
8180 dgst_pos2 = 2;
8181 dgst_pos3 = 3;
8182 break;
8183
8184 case 2600: hash_type = HASH_TYPE_MD5;
8185 salt_type = SALT_TYPE_VIRTUAL;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_LE
8188 | OPTS_TYPE_PT_ADD80
8189 | OPTS_TYPE_PT_ADDBITS14
8190 | OPTS_TYPE_ST_ADD80;
8191 kern_type = KERN_TYPE_MD55_PWSLT1;
8192 dgst_size = DGST_SIZE_4_4;
8193 parse_func = md5md5_parse_hash;
8194 sort_by_digest = sort_by_digest_4_4;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_PRECOMPUTE_MERKLE
8198 | OPTI_TYPE_EARLY_SKIP;
8199 dgst_pos0 = 0;
8200 dgst_pos1 = 3;
8201 dgst_pos2 = 2;
8202 dgst_pos3 = 1;
8203 break;
8204
8205 case 2611: hash_type = HASH_TYPE_MD5;
8206 salt_type = SALT_TYPE_INTERN;
8207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8208 opts_type = OPTS_TYPE_PT_GENERATE_LE
8209 | OPTS_TYPE_PT_ADD80
8210 | OPTS_TYPE_PT_ADDBITS14
8211 | OPTS_TYPE_ST_ADD80;
8212 kern_type = KERN_TYPE_MD55_PWSLT1;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = vb3_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_PRECOMPUTE_INIT
8218 | OPTI_TYPE_PRECOMPUTE_MERKLE
8219 | OPTI_TYPE_EARLY_SKIP;
8220 dgst_pos0 = 0;
8221 dgst_pos1 = 3;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 1;
8224 break;
8225
8226 case 2612: hash_type = HASH_TYPE_MD5;
8227 salt_type = SALT_TYPE_EMBEDDED;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_LE
8230 | OPTS_TYPE_PT_ADD80
8231 | OPTS_TYPE_PT_ADDBITS14
8232 | OPTS_TYPE_ST_ADD80
8233 | OPTS_TYPE_ST_HEX;
8234 kern_type = KERN_TYPE_MD55_PWSLT1;
8235 dgst_size = DGST_SIZE_4_4;
8236 parse_func = phps_parse_hash;
8237 sort_by_digest = sort_by_digest_4_4;
8238 opti_type = OPTI_TYPE_ZERO_BYTE
8239 | OPTI_TYPE_PRECOMPUTE_INIT
8240 | OPTI_TYPE_PRECOMPUTE_MERKLE
8241 | OPTI_TYPE_EARLY_SKIP;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 1;
8246 break;
8247
8248 case 2711: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_INTERN;
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_MD55_PWSLT2;
8256 dgst_size = DGST_SIZE_4_4;
8257 parse_func = vb30_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_EARLY_SKIP;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 3;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 1;
8266 break;
8267
8268 case 2811: hash_type = HASH_TYPE_MD5;
8269 salt_type = SALT_TYPE_INTERN;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS14;
8274 kern_type = KERN_TYPE_MD55_SLTPW;
8275 dgst_size = DGST_SIZE_4_4;
8276 parse_func = ipb2_parse_hash;
8277 sort_by_digest = sort_by_digest_4_4;
8278 opti_type = OPTI_TYPE_ZERO_BYTE
8279 | OPTI_TYPE_PRECOMPUTE_INIT
8280 | OPTI_TYPE_EARLY_SKIP;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 3;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 1;
8285 break;
8286
8287 case 3000: hash_type = HASH_TYPE_LM;
8288 salt_type = SALT_TYPE_NONE;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_LE
8291 | OPTS_TYPE_PT_UPPER
8292 | OPTS_TYPE_PT_BITSLICE;
8293 kern_type = KERN_TYPE_LM;
8294 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8295 parse_func = lm_parse_hash;
8296 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8297 opti_type = OPTI_TYPE_ZERO_BYTE
8298 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8299 dgst_pos0 = 0;
8300 dgst_pos1 = 1;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 3;
8303 break;
8304
8305 case 3100: hash_type = HASH_TYPE_ORACLEH;
8306 salt_type = SALT_TYPE_INTERN;
8307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8308 opts_type = OPTS_TYPE_PT_GENERATE_LE
8309 | OPTS_TYPE_PT_UPPER
8310 | OPTS_TYPE_ST_UPPER;
8311 kern_type = KERN_TYPE_ORACLEH;
8312 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8313 parse_func = oracleh_parse_hash;
8314 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8315 opti_type = OPTI_TYPE_ZERO_BYTE;
8316 dgst_pos0 = 0;
8317 dgst_pos1 = 1;
8318 dgst_pos2 = 2;
8319 dgst_pos3 = 3;
8320 break;
8321
8322 case 3200: hash_type = HASH_TYPE_BCRYPT;
8323 salt_type = SALT_TYPE_EMBEDDED;
8324 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8325 opts_type = OPTS_TYPE_PT_GENERATE_LE
8326 | OPTS_TYPE_ST_GENERATE_LE;
8327 kern_type = KERN_TYPE_BCRYPT;
8328 dgst_size = DGST_SIZE_4_6;
8329 parse_func = bcrypt_parse_hash;
8330 sort_by_digest = sort_by_digest_4_6;
8331 opti_type = OPTI_TYPE_ZERO_BYTE;
8332 dgst_pos0 = 0;
8333 dgst_pos1 = 1;
8334 dgst_pos2 = 2;
8335 dgst_pos3 = 3;
8336 break;
8337
8338 case 3710: hash_type = HASH_TYPE_MD5;
8339 salt_type = SALT_TYPE_INTERN;
8340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8341 opts_type = OPTS_TYPE_PT_GENERATE_LE
8342 | OPTS_TYPE_PT_ADD80
8343 | OPTS_TYPE_PT_ADDBITS14;
8344 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8345 dgst_size = DGST_SIZE_4_4;
8346 parse_func = md5s_parse_hash;
8347 sort_by_digest = sort_by_digest_4_4;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 3;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 1;
8356 break;
8357
8358 case 3711: hash_type = HASH_TYPE_MD5;
8359 salt_type = SALT_TYPE_EMBEDDED;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_PT_ADD80
8363 | OPTS_TYPE_PT_ADDBITS14;
8364 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8365 dgst_size = DGST_SIZE_4_4;
8366 parse_func = mediawiki_b_parse_hash;
8367 sort_by_digest = sort_by_digest_4_4;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_PRECOMPUTE_INIT
8370 | OPTI_TYPE_PRECOMPUTE_MERKLE
8371 | OPTI_TYPE_EARLY_SKIP;
8372 dgst_pos0 = 0;
8373 dgst_pos1 = 3;
8374 dgst_pos2 = 2;
8375 dgst_pos3 = 1;
8376 break;
8377
8378 case 3800: hash_type = HASH_TYPE_MD5;
8379 salt_type = SALT_TYPE_INTERN;
8380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8381 opts_type = OPTS_TYPE_PT_GENERATE_LE
8382 | OPTS_TYPE_ST_ADDBITS14;
8383 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8384 dgst_size = DGST_SIZE_4_4;
8385 parse_func = md5s_parse_hash;
8386 sort_by_digest = sort_by_digest_4_4;
8387 opti_type = OPTI_TYPE_ZERO_BYTE
8388 | OPTI_TYPE_PRECOMPUTE_INIT
8389 | OPTI_TYPE_PRECOMPUTE_MERKLE
8390 | OPTI_TYPE_EARLY_SKIP
8391 | OPTI_TYPE_NOT_ITERATED
8392 | OPTI_TYPE_RAW_HASH;
8393 dgst_pos0 = 0;
8394 dgst_pos1 = 3;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 1;
8397 break;
8398
8399 case 4300: hash_type = HASH_TYPE_MD5;
8400 salt_type = SALT_TYPE_VIRTUAL;
8401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_LE
8403 | OPTS_TYPE_PT_ADD80
8404 | OPTS_TYPE_PT_ADDBITS14
8405 | OPTS_TYPE_ST_ADD80;
8406 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8407 dgst_size = DGST_SIZE_4_4;
8408 parse_func = md5md5_parse_hash;
8409 sort_by_digest = sort_by_digest_4_4;
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_INIT
8412 | OPTI_TYPE_PRECOMPUTE_MERKLE
8413 | OPTI_TYPE_EARLY_SKIP;
8414 dgst_pos0 = 0;
8415 dgst_pos1 = 3;
8416 dgst_pos2 = 2;
8417 dgst_pos3 = 1;
8418 break;
8419
8420
8421 case 4400: hash_type = HASH_TYPE_MD5;
8422 salt_type = SALT_TYPE_NONE;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_BE
8425 | OPTS_TYPE_PT_ADD80
8426 | OPTS_TYPE_PT_ADDBITS15;
8427 kern_type = KERN_TYPE_MD5_SHA1;
8428 dgst_size = DGST_SIZE_4_4;
8429 parse_func = md5_parse_hash;
8430 sort_by_digest = sort_by_digest_4_4;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_ITERATED
8436 | OPTI_TYPE_NOT_SALTED
8437 | OPTI_TYPE_RAW_HASH;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 4500: hash_type = HASH_TYPE_SHA1;
8445 salt_type = SALT_TYPE_NONE;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_BE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS15;
8450 kern_type = KERN_TYPE_SHA11;
8451 dgst_size = DGST_SIZE_4_5;
8452 parse_func = sha1_parse_hash;
8453 sort_by_digest = sort_by_digest_4_5;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP
8458 | OPTI_TYPE_NOT_SALTED;
8459 dgst_pos0 = 3;
8460 dgst_pos1 = 4;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 1;
8463 break;
8464
8465 case 4700: hash_type = HASH_TYPE_SHA1;
8466 salt_type = SALT_TYPE_NONE;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_PT_ADD80
8470 | OPTS_TYPE_PT_ADDBITS14;
8471 kern_type = KERN_TYPE_SHA1_MD5;
8472 dgst_size = DGST_SIZE_4_5;
8473 parse_func = sha1_parse_hash;
8474 sort_by_digest = sort_by_digest_4_5;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_PRECOMPUTE_INIT
8477 | OPTI_TYPE_PRECOMPUTE_MERKLE
8478 | OPTI_TYPE_EARLY_SKIP
8479 | OPTI_TYPE_NOT_ITERATED
8480 | OPTI_TYPE_NOT_SALTED
8481 | OPTI_TYPE_RAW_HASH;
8482 dgst_pos0 = 3;
8483 dgst_pos1 = 4;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 1;
8486 break;
8487
8488 case 4800: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_EMBEDDED;
8490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE
8492 | OPTS_TYPE_PT_ADDBITS14;
8493 kern_type = KERN_TYPE_MD5_CHAP;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = chap_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_MEET_IN_MIDDLE
8501 | OPTI_TYPE_EARLY_SKIP
8502 | OPTI_TYPE_NOT_ITERATED
8503 | OPTI_TYPE_RAW_HASH;
8504 dgst_pos0 = 0;
8505 dgst_pos1 = 3;
8506 dgst_pos2 = 2;
8507 dgst_pos3 = 1;
8508 break;
8509
8510 case 4900: hash_type = HASH_TYPE_SHA1;
8511 salt_type = SALT_TYPE_INTERN;
8512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8514 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8515 dgst_size = DGST_SIZE_4_5;
8516 parse_func = sha1s_parse_hash;
8517 sort_by_digest = sort_by_digest_4_5;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP;
8522 dgst_pos0 = 3;
8523 dgst_pos1 = 4;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 5000: hash_type = HASH_TYPE_KECCAK;
8529 salt_type = SALT_TYPE_EMBEDDED;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD01;
8533 kern_type = KERN_TYPE_KECCAK;
8534 dgst_size = DGST_SIZE_8_25;
8535 parse_func = keccak_parse_hash;
8536 sort_by_digest = sort_by_digest_8_25;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_USES_BITS_64
8539 | OPTI_TYPE_RAW_HASH;
8540 dgst_pos0 = 2;
8541 dgst_pos1 = 3;
8542 dgst_pos2 = 4;
8543 dgst_pos3 = 5;
8544 break;
8545
8546 case 5100: hash_type = HASH_TYPE_MD5H;
8547 salt_type = SALT_TYPE_NONE;
8548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE
8550 | OPTS_TYPE_PT_ADD80
8551 | OPTS_TYPE_PT_ADDBITS14;
8552 kern_type = KERN_TYPE_MD5H;
8553 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8554 parse_func = md5half_parse_hash;
8555 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8556 opti_type = OPTI_TYPE_ZERO_BYTE
8557 | OPTI_TYPE_RAW_HASH;
8558 dgst_pos0 = 0;
8559 dgst_pos1 = 1;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 3;
8562 break;
8563
8564 case 5200: hash_type = HASH_TYPE_SHA256;
8565 salt_type = SALT_TYPE_EMBEDDED;
8566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8568 kern_type = KERN_TYPE_PSAFE3;
8569 dgst_size = DGST_SIZE_4_8;
8570 parse_func = psafe3_parse_hash;
8571 sort_by_digest = sort_by_digest_4_8;
8572 opti_type = OPTI_TYPE_ZERO_BYTE;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 1;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 3;
8577 break;
8578
8579 case 5300: hash_type = HASH_TYPE_MD5;
8580 salt_type = SALT_TYPE_EMBEDDED;
8581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_LE
8583 | OPTS_TYPE_ST_ADD80;
8584 kern_type = KERN_TYPE_IKEPSK_MD5;
8585 dgst_size = DGST_SIZE_4_4;
8586 parse_func = ikepsk_md5_parse_hash;
8587 sort_by_digest = sort_by_digest_4_4;
8588 opti_type = OPTI_TYPE_ZERO_BYTE;
8589 dgst_pos0 = 0;
8590 dgst_pos1 = 3;
8591 dgst_pos2 = 2;
8592 dgst_pos3 = 1;
8593 break;
8594
8595 case 5400: hash_type = HASH_TYPE_SHA1;
8596 salt_type = SALT_TYPE_EMBEDDED;
8597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8598 opts_type = OPTS_TYPE_PT_GENERATE_BE
8599 | OPTS_TYPE_ST_ADD80;
8600 kern_type = KERN_TYPE_IKEPSK_SHA1;
8601 dgst_size = DGST_SIZE_4_5;
8602 parse_func = ikepsk_sha1_parse_hash;
8603 sort_by_digest = sort_by_digest_4_5;
8604 opti_type = OPTI_TYPE_ZERO_BYTE;
8605 dgst_pos0 = 3;
8606 dgst_pos1 = 4;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 1;
8609 break;
8610
8611 case 5500: hash_type = HASH_TYPE_NETNTLM;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_PT_ADD80
8616 | OPTS_TYPE_PT_ADDBITS14
8617 | OPTS_TYPE_PT_UNICODE
8618 | OPTS_TYPE_ST_HEX;
8619 kern_type = KERN_TYPE_NETNTLMv1;
8620 dgst_size = DGST_SIZE_4_4;
8621 parse_func = netntlmv1_parse_hash;
8622 sort_by_digest = sort_by_digest_4_4;
8623 opti_type = OPTI_TYPE_ZERO_BYTE
8624 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 1;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 3;
8629 break;
8630
8631 case 5600: hash_type = HASH_TYPE_MD5;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE
8635 | OPTS_TYPE_PT_ADD80
8636 | OPTS_TYPE_PT_ADDBITS14
8637 | OPTS_TYPE_PT_UNICODE;
8638 kern_type = KERN_TYPE_NETNTLMv2;
8639 dgst_size = DGST_SIZE_4_4;
8640 parse_func = netntlmv2_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4;
8642 opti_type = OPTI_TYPE_ZERO_BYTE;
8643 dgst_pos0 = 0;
8644 dgst_pos1 = 3;
8645 dgst_pos2 = 2;
8646 dgst_pos3 = 1;
8647 break;
8648
8649 case 5700: hash_type = HASH_TYPE_SHA256;
8650 salt_type = SALT_TYPE_NONE;
8651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8652 opts_type = OPTS_TYPE_PT_GENERATE_BE
8653 | OPTS_TYPE_PT_ADD80
8654 | OPTS_TYPE_PT_ADDBITS15;
8655 kern_type = KERN_TYPE_SHA256;
8656 dgst_size = DGST_SIZE_4_8;
8657 parse_func = cisco4_parse_hash;
8658 sort_by_digest = sort_by_digest_4_8;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_PRECOMPUTE_INIT
8661 | OPTI_TYPE_PRECOMPUTE_MERKLE
8662 | OPTI_TYPE_EARLY_SKIP
8663 | OPTI_TYPE_NOT_ITERATED
8664 | OPTI_TYPE_NOT_SALTED
8665 | OPTI_TYPE_RAW_HASH;
8666 dgst_pos0 = 3;
8667 dgst_pos1 = 7;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 6;
8670 break;
8671
8672 case 5800: hash_type = HASH_TYPE_SHA1;
8673 salt_type = SALT_TYPE_INTERN;
8674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8676 | OPTS_TYPE_ST_ADD80;
8677 kern_type = KERN_TYPE_ANDROIDPIN;
8678 dgst_size = DGST_SIZE_4_5;
8679 parse_func = androidpin_parse_hash;
8680 sort_by_digest = sort_by_digest_4_5;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8689 salt_type = SALT_TYPE_NONE;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE
8692 | OPTS_TYPE_PT_ADD80;
8693 kern_type = KERN_TYPE_RIPEMD160;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = ripemd160_parse_hash;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 1;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 3;
8702 break;
8703
8704 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8705 salt_type = SALT_TYPE_NONE;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_BE
8708 | OPTS_TYPE_PT_ADD80;
8709 kern_type = KERN_TYPE_WHIRLPOOL;
8710 dgst_size = DGST_SIZE_4_16;
8711 parse_func = whirlpool_parse_hash;
8712 sort_by_digest = sort_by_digest_4_16;
8713 opti_type = OPTI_TYPE_ZERO_BYTE;
8714 dgst_pos0 = 0;
8715 dgst_pos1 = 1;
8716 dgst_pos2 = 2;
8717 dgst_pos3 = 3;
8718 break;
8719
8720 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8721 salt_type = SALT_TYPE_EMBEDDED;
8722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8724 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = truecrypt_parse_hash_2k;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 0;
8730 dgst_pos1 = 1;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 3;
8733 break;
8734
8735 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8736 salt_type = SALT_TYPE_EMBEDDED;
8737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8739 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8740 dgst_size = DGST_SIZE_4_5;
8741 parse_func = truecrypt_parse_hash_2k;
8742 sort_by_digest = sort_by_digest_4_5;
8743 opti_type = OPTI_TYPE_ZERO_BYTE;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8751 salt_type = SALT_TYPE_EMBEDDED;
8752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8754 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8755 dgst_size = DGST_SIZE_4_5;
8756 parse_func = truecrypt_parse_hash_2k;
8757 sort_by_digest = sort_by_digest_4_5;
8758 opti_type = OPTI_TYPE_ZERO_BYTE;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 1;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 3;
8763 break;
8764
8765 case 6221: hash_type = HASH_TYPE_SHA512;
8766 salt_type = SALT_TYPE_EMBEDDED;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8769 kern_type = KERN_TYPE_TCSHA512_XTS512;
8770 dgst_size = DGST_SIZE_8_8;
8771 parse_func = truecrypt_parse_hash_1k;
8772 sort_by_digest = sort_by_digest_8_8;
8773 opti_type = OPTI_TYPE_ZERO_BYTE
8774 | OPTI_TYPE_USES_BITS_64;
8775 dgst_pos0 = 0;
8776 dgst_pos1 = 1;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 3;
8779 break;
8780
8781 case 6222: hash_type = HASH_TYPE_SHA512;
8782 salt_type = SALT_TYPE_EMBEDDED;
8783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8785 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8786 dgst_size = DGST_SIZE_8_8;
8787 parse_func = truecrypt_parse_hash_1k;
8788 sort_by_digest = sort_by_digest_8_8;
8789 opti_type = OPTI_TYPE_ZERO_BYTE
8790 | OPTI_TYPE_USES_BITS_64;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6223: hash_type = HASH_TYPE_SHA512;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8801 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8802 dgst_size = DGST_SIZE_8_8;
8803 parse_func = truecrypt_parse_hash_1k;
8804 sort_by_digest = sort_by_digest_8_8;
8805 opti_type = OPTI_TYPE_ZERO_BYTE
8806 | OPTI_TYPE_USES_BITS_64;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8818 dgst_size = DGST_SIZE_4_8;
8819 parse_func = truecrypt_parse_hash_1k;
8820 sort_by_digest = sort_by_digest_4_8;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
8833 dgst_size = DGST_SIZE_4_8;
8834 parse_func = truecrypt_parse_hash_1k;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8848 dgst_size = DGST_SIZE_4_8;
8849 parse_func = truecrypt_parse_hash_1k;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8862 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8863 dgst_size = DGST_SIZE_4_5;
8864 parse_func = truecrypt_parse_hash_1k;
8865 sort_by_digest = sort_by_digest_4_5;
8866 opti_type = OPTI_TYPE_ZERO_BYTE;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 1;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 3;
8871 break;
8872
8873 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8874 salt_type = SALT_TYPE_EMBEDDED;
8875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8877 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8878 dgst_size = DGST_SIZE_4_5;
8879 parse_func = truecrypt_parse_hash_1k;
8880 sort_by_digest = sort_by_digest_4_5;
8881 opti_type = OPTI_TYPE_ZERO_BYTE;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8892 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8893 dgst_size = DGST_SIZE_4_5;
8894 parse_func = truecrypt_parse_hash_1k;
8895 sort_by_digest = sort_by_digest_4_5;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6300: hash_type = HASH_TYPE_MD5;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8907 kern_type = KERN_TYPE_MD5AIX;
8908 dgst_size = DGST_SIZE_4_4;
8909 parse_func = md5aix_parse_hash;
8910 sort_by_digest = sort_by_digest_4_4;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 6400: hash_type = HASH_TYPE_SHA256;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8922 kern_type = KERN_TYPE_SHA256AIX;
8923 dgst_size = DGST_SIZE_4_8;
8924 parse_func = sha256aix_parse_hash;
8925 sort_by_digest = sort_by_digest_4_8;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6500: hash_type = HASH_TYPE_SHA512;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8937 kern_type = KERN_TYPE_SHA512AIX;
8938 dgst_size = DGST_SIZE_8_8;
8939 parse_func = sha512aix_parse_hash;
8940 sort_by_digest = sort_by_digest_8_8;
8941 opti_type = OPTI_TYPE_ZERO_BYTE
8942 | OPTI_TYPE_USES_BITS_64;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 6600: hash_type = HASH_TYPE_AES;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_AGILEKEY;
8954 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8955 parse_func = agilekey_parse_hash;
8956 sort_by_digest = sort_by_digest_4_5;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6700: hash_type = HASH_TYPE_SHA1;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8968 kern_type = KERN_TYPE_SHA1AIX;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = sha1aix_parse_hash;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6800: hash_type = HASH_TYPE_AES;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_LASTPASS;
8984 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8985 parse_func = lastpass_parse_hash;
8986 sort_by_digest = sort_by_digest_4_8;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6900: hash_type = HASH_TYPE_GOST;
8995 salt_type = SALT_TYPE_NONE;
8996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_GOST;
8999 dgst_size = DGST_SIZE_4_8;
9000 parse_func = gost_parse_hash;
9001 sort_by_digest = sort_by_digest_4_8;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 7100: hash_type = HASH_TYPE_SHA512;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9013 kern_type = KERN_TYPE_PBKDF2_SHA512;
9014 dgst_size = DGST_SIZE_8_16;
9015 parse_func = sha512osx_parse_hash;
9016 sort_by_digest = sort_by_digest_8_16;
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_USES_BITS_64;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 7200: hash_type = HASH_TYPE_SHA512;
9026 salt_type = SALT_TYPE_EMBEDDED;
9027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9029 kern_type = KERN_TYPE_PBKDF2_SHA512;
9030 dgst_size = DGST_SIZE_8_16;
9031 parse_func = sha512grub_parse_hash;
9032 sort_by_digest = sort_by_digest_8_16;
9033 opti_type = OPTI_TYPE_ZERO_BYTE
9034 | OPTI_TYPE_USES_BITS_64;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 7300: hash_type = HASH_TYPE_SHA1;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_BE
9045 | OPTS_TYPE_ST_ADD80
9046 | OPTS_TYPE_ST_ADDBITS15;
9047 kern_type = KERN_TYPE_RAKP;
9048 dgst_size = DGST_SIZE_4_5;
9049 parse_func = rakp_parse_hash;
9050 sort_by_digest = sort_by_digest_4_5;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_NOT_ITERATED;
9053 dgst_pos0 = 3;
9054 dgst_pos1 = 4;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 1;
9057 break;
9058
9059 case 7400: hash_type = HASH_TYPE_SHA256;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9063 kern_type = KERN_TYPE_SHA256CRYPT;
9064 dgst_size = DGST_SIZE_4_8;
9065 parse_func = sha256crypt_parse_hash;
9066 sort_by_digest = sort_by_digest_4_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 7500: hash_type = HASH_TYPE_KRB5PA;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9078 kern_type = KERN_TYPE_KRB5PA;
9079 dgst_size = DGST_SIZE_4_4;
9080 parse_func = krb5pa_parse_hash;
9081 sort_by_digest = sort_by_digest_4_4;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_NOT_ITERATED;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 1;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 3;
9088 break;
9089
9090 case 7600: hash_type = HASH_TYPE_SHA1;
9091 salt_type = SALT_TYPE_INTERN;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_BE
9094 | OPTS_TYPE_PT_ADD80
9095 | OPTS_TYPE_PT_ADDBITS15;
9096 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9097 dgst_size = DGST_SIZE_4_5;
9098 parse_func = redmine_parse_hash;
9099 sort_by_digest = sort_by_digest_4_5;
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_PRECOMPUTE_INIT
9102 | OPTI_TYPE_EARLY_SKIP
9103 | OPTI_TYPE_NOT_ITERATED
9104 | OPTI_TYPE_PREPENDED_SALT;
9105 dgst_pos0 = 3;
9106 dgst_pos1 = 4;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 1;
9109 break;
9110
9111 case 7700: hash_type = HASH_TYPE_SAPB;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE
9115 | OPTS_TYPE_PT_UPPER
9116 | OPTS_TYPE_ST_UPPER;
9117 kern_type = KERN_TYPE_SAPB;
9118 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9119 parse_func = sapb_parse_hash;
9120 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9121 opti_type = OPTI_TYPE_ZERO_BYTE
9122 | OPTI_TYPE_PRECOMPUTE_INIT
9123 | OPTI_TYPE_NOT_ITERATED;
9124 dgst_pos0 = 0;
9125 dgst_pos1 = 1;
9126 dgst_pos2 = 2;
9127 dgst_pos3 = 3;
9128 break;
9129
9130 case 7800: hash_type = HASH_TYPE_SAPG;
9131 salt_type = SALT_TYPE_EMBEDDED;
9132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9133 opts_type = OPTS_TYPE_PT_GENERATE_BE
9134 | OPTS_TYPE_ST_ADD80
9135 | OPTS_TYPE_ST_UPPER;
9136 kern_type = KERN_TYPE_SAPG;
9137 dgst_size = DGST_SIZE_4_5;
9138 parse_func = sapg_parse_hash;
9139 sort_by_digest = sort_by_digest_4_5;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_PRECOMPUTE_INIT
9142 | OPTI_TYPE_NOT_ITERATED;
9143 dgst_pos0 = 3;
9144 dgst_pos1 = 4;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 1;
9147 break;
9148
9149 case 7900: hash_type = HASH_TYPE_SHA512;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9153 kern_type = KERN_TYPE_DRUPAL7;
9154 dgst_size = DGST_SIZE_8_8;
9155 parse_func = drupal7_parse_hash;
9156 sort_by_digest = sort_by_digest_8_8;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_USES_BITS_64;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 8000: hash_type = HASH_TYPE_SHA256;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_BE
9169 | OPTS_TYPE_PT_UNICODE
9170 | OPTS_TYPE_ST_ADD80
9171 | OPTS_TYPE_ST_HEX;
9172 kern_type = KERN_TYPE_SYBASEASE;
9173 dgst_size = DGST_SIZE_4_8;
9174 parse_func = sybasease_parse_hash;
9175 sort_by_digest = sort_by_digest_4_8;
9176 opti_type = OPTI_TYPE_ZERO_BYTE
9177 | OPTI_TYPE_PRECOMPUTE_INIT
9178 | OPTI_TYPE_EARLY_SKIP
9179 | OPTI_TYPE_NOT_ITERATED
9180 | OPTI_TYPE_RAW_HASH;
9181 dgst_pos0 = 3;
9182 dgst_pos1 = 7;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 6;
9185 break;
9186
9187 case 8100: hash_type = HASH_TYPE_SHA1;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9191 kern_type = KERN_TYPE_NETSCALER;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = netscaler_parse_hash;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_PRECOMPUTE_INIT
9197 | OPTI_TYPE_PRECOMPUTE_MERKLE
9198 | OPTI_TYPE_EARLY_SKIP
9199 | OPTI_TYPE_NOT_ITERATED
9200 | OPTI_TYPE_PREPENDED_SALT
9201 | OPTI_TYPE_RAW_HASH;
9202 dgst_pos0 = 3;
9203 dgst_pos1 = 4;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 1;
9206 break;
9207
9208 case 8200: hash_type = HASH_TYPE_SHA256;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9212 kern_type = KERN_TYPE_CLOUDKEY;
9213 dgst_size = DGST_SIZE_4_8;
9214 parse_func = cloudkey_parse_hash;
9215 sort_by_digest = sort_by_digest_4_8;
9216 opti_type = OPTI_TYPE_ZERO_BYTE;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 8300: hash_type = HASH_TYPE_SHA1;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE
9227 | OPTS_TYPE_ST_HEX
9228 | OPTS_TYPE_ST_ADD80;
9229 kern_type = KERN_TYPE_NSEC3;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = nsec3_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE;
9234 dgst_pos0 = 3;
9235 dgst_pos1 = 4;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 1;
9238 break;
9239
9240 case 8400: hash_type = HASH_TYPE_SHA1;
9241 salt_type = SALT_TYPE_INTERN;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_BE
9244 | OPTS_TYPE_PT_ADD80
9245 | OPTS_TYPE_PT_ADDBITS15;
9246 kern_type = KERN_TYPE_WBB3;
9247 dgst_size = DGST_SIZE_4_5;
9248 parse_func = wbb3_parse_hash;
9249 sort_by_digest = sort_by_digest_4_5;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_PRECOMPUTE_INIT
9252 | OPTI_TYPE_NOT_ITERATED;
9253 dgst_pos0 = 3;
9254 dgst_pos1 = 4;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 1;
9257 break;
9258
9259 case 8500: hash_type = HASH_TYPE_DESRACF;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE
9263 | OPTS_TYPE_ST_UPPER;
9264 kern_type = KERN_TYPE_RACF;
9265 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9266 parse_func = racf_parse_hash;
9267 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9268 opti_type = OPTI_TYPE_ZERO_BYTE
9269 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9270 dgst_pos0 = 0;
9271 dgst_pos1 = 1;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 3;
9274 break;
9275
9276 case 8600: hash_type = HASH_TYPE_LOTUS5;
9277 salt_type = SALT_TYPE_NONE;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9280 kern_type = KERN_TYPE_LOTUS5;
9281 dgst_size = DGST_SIZE_4_4;
9282 parse_func = lotus5_parse_hash;
9283 sort_by_digest = sort_by_digest_4_4;
9284 opti_type = OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_NOT_SALTED
9287 | OPTI_TYPE_RAW_HASH;
9288 dgst_pos0 = 0;
9289 dgst_pos1 = 1;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 3;
9292 break;
9293
9294 case 8700: hash_type = HASH_TYPE_LOTUS6;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9298 kern_type = KERN_TYPE_LOTUS6;
9299 dgst_size = DGST_SIZE_4_4;
9300 parse_func = lotus6_parse_hash;
9301 sort_by_digest = sort_by_digest_4_4;
9302 opti_type = OPTI_TYPE_EARLY_SKIP
9303 | OPTI_TYPE_NOT_ITERATED
9304 | OPTI_TYPE_RAW_HASH;
9305 dgst_pos0 = 0;
9306 dgst_pos1 = 1;
9307 dgst_pos2 = 2;
9308 dgst_pos3 = 3;
9309 break;
9310
9311 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9312 salt_type = SALT_TYPE_EMBEDDED;
9313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9314 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9315 kern_type = KERN_TYPE_ANDROIDFDE;
9316 dgst_size = DGST_SIZE_4_4;
9317 parse_func = androidfde_parse_hash;
9318 sort_by_digest = sort_by_digest_4_4;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 0;
9321 dgst_pos1 = 1;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 3;
9324 break;
9325
9326 case 8900: hash_type = HASH_TYPE_SCRYPT;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9330 kern_type = KERN_TYPE_SCRYPT;
9331 dgst_size = DGST_SIZE_4_8;
9332 parse_func = scrypt_parse_hash;
9333 sort_by_digest = sort_by_digest_4_8;
9334 opti_type = OPTI_TYPE_ZERO_BYTE;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 9000: hash_type = HASH_TYPE_SHA1;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE
9345 | OPTS_TYPE_ST_GENERATE_LE;
9346 kern_type = KERN_TYPE_PSAFE2;
9347 dgst_size = DGST_SIZE_4_5;
9348 parse_func = psafe2_parse_hash;
9349 sort_by_digest = sort_by_digest_4_5;
9350 opti_type = OPTI_TYPE_ZERO_BYTE;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 9100: hash_type = HASH_TYPE_LOTUS8;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9361 kern_type = KERN_TYPE_LOTUS8;
9362 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9363 parse_func = lotus8_parse_hash;
9364 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9365 opti_type = OPTI_TYPE_ZERO_BYTE;
9366 dgst_pos0 = 0;
9367 dgst_pos1 = 1;
9368 dgst_pos2 = 2;
9369 dgst_pos3 = 3;
9370 break;
9371
9372 case 9200: hash_type = HASH_TYPE_SHA256;
9373 salt_type = SALT_TYPE_EMBEDDED;
9374 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9375 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9376 kern_type = KERN_TYPE_PBKDF2_SHA256;
9377 dgst_size = DGST_SIZE_4_32;
9378 parse_func = cisco8_parse_hash;
9379 sort_by_digest = sort_by_digest_4_32;
9380 opti_type = OPTI_TYPE_ZERO_BYTE;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 9300: hash_type = HASH_TYPE_SCRYPT;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_SCRYPT;
9392 dgst_size = DGST_SIZE_4_8;
9393 parse_func = cisco9_parse_hash;
9394 sort_by_digest = sort_by_digest_4_8;
9395 opti_type = OPTI_TYPE_ZERO_BYTE;
9396 dgst_pos0 = 0;
9397 dgst_pos1 = 1;
9398 dgst_pos2 = 2;
9399 dgst_pos3 = 3;
9400 break;
9401
9402 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9403 salt_type = SALT_TYPE_EMBEDDED;
9404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9406 kern_type = KERN_TYPE_OFFICE2007;
9407 dgst_size = DGST_SIZE_4_4;
9408 parse_func = office2007_parse_hash;
9409 sort_by_digest = sort_by_digest_4_4;
9410 opti_type = OPTI_TYPE_ZERO_BYTE;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_OFFICE2010;
9422 dgst_size = DGST_SIZE_4_4;
9423 parse_func = office2010_parse_hash;
9424 sort_by_digest = sort_by_digest_4_4;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_OFFICE2013;
9437 dgst_size = DGST_SIZE_4_4;
9438 parse_func = office2013_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE
9451 | OPTS_TYPE_PT_ADD80
9452 | OPTS_TYPE_PT_UNICODE;
9453 kern_type = KERN_TYPE_OLDOFFICE01;
9454 dgst_size = DGST_SIZE_4_4;
9455 parse_func = oldoffice01_parse_hash;
9456 sort_by_digest = sort_by_digest_4_4;
9457 opti_type = OPTI_TYPE_ZERO_BYTE
9458 | OPTI_TYPE_PRECOMPUTE_INIT
9459 | OPTI_TYPE_NOT_ITERATED;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE
9470 | OPTS_TYPE_PT_ADD80;
9471 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9472 dgst_size = DGST_SIZE_4_4;
9473 parse_func = oldoffice01cm1_parse_hash;
9474 sort_by_digest = sort_by_digest_4_4;
9475 opti_type = OPTI_TYPE_ZERO_BYTE
9476 | OPTI_TYPE_PRECOMPUTE_INIT
9477 | OPTI_TYPE_NOT_ITERATED;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80
9489 | OPTS_TYPE_PT_UNICODE
9490 | OPTS_TYPE_PT_NEVERCRACK;
9491 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9492 dgst_size = DGST_SIZE_4_4;
9493 parse_func = oldoffice01cm2_parse_hash;
9494 sort_by_digest = sort_by_digest_4_4;
9495 opti_type = OPTI_TYPE_ZERO_BYTE
9496 | OPTI_TYPE_PRECOMPUTE_INIT
9497 | OPTI_TYPE_NOT_ITERATED;
9498 dgst_pos0 = 0;
9499 dgst_pos1 = 1;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 3;
9502 break;
9503
9504 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_BE
9508 | OPTS_TYPE_PT_ADD80
9509 | OPTS_TYPE_PT_UNICODE;
9510 kern_type = KERN_TYPE_OLDOFFICE34;
9511 dgst_size = DGST_SIZE_4_4;
9512 parse_func = oldoffice34_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4;
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_PRECOMPUTE_INIT
9516 | OPTI_TYPE_NOT_ITERATED;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9527 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = oldoffice34cm1_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_BE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE
9546 | OPTS_TYPE_PT_NEVERCRACK;
9547 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9548 dgst_size = DGST_SIZE_4_4;
9549 parse_func = oldoffice34cm2_parse_hash;
9550 sort_by_digest = sort_by_digest_4_4;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 9900: hash_type = HASH_TYPE_MD5;
9561 salt_type = SALT_TYPE_NONE;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_RADMIN2;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = radmin2_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_EARLY_SKIP
9571 | OPTI_TYPE_NOT_ITERATED
9572 | OPTI_TYPE_NOT_SALTED;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 3;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 1;
9577 break;
9578
9579 case 10000: hash_type = HASH_TYPE_SHA256;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9583 kern_type = KERN_TYPE_PBKDF2_SHA256;
9584 dgst_size = DGST_SIZE_4_32;
9585 parse_func = djangopbkdf2_parse_hash;
9586 sort_by_digest = sort_by_digest_4_32;
9587 opti_type = OPTI_TYPE_ZERO_BYTE;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 10100: hash_type = HASH_TYPE_SIPHASH;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9598 kern_type = KERN_TYPE_SIPHASH;
9599 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9600 parse_func = siphash_parse_hash;
9601 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9602 opti_type = OPTI_TYPE_ZERO_BYTE
9603 | OPTI_TYPE_NOT_ITERATED
9604 | OPTI_TYPE_RAW_HASH;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 10200: hash_type = HASH_TYPE_MD5;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE
9615 | OPTS_TYPE_ST_ADD80
9616 | OPTS_TYPE_ST_ADDBITS14;
9617 kern_type = KERN_TYPE_HMACMD5_PW;
9618 dgst_size = DGST_SIZE_4_4;
9619 parse_func = crammd5_parse_hash;
9620 sort_by_digest = sort_by_digest_4_4;
9621 opti_type = OPTI_TYPE_ZERO_BYTE
9622 | OPTI_TYPE_NOT_ITERATED;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 3;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 1;
9627 break;
9628
9629 case 10300: hash_type = HASH_TYPE_SHA1;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9633 kern_type = KERN_TYPE_SAPH_SHA1;
9634 dgst_size = DGST_SIZE_4_5;
9635 parse_func = saph_sha1_parse_hash;
9636 sort_by_digest = sort_by_digest_4_5;
9637 opti_type = OPTI_TYPE_ZERO_BYTE;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 10400: hash_type = HASH_TYPE_PDFU16;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_PDF11;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = pdf11_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 10410: hash_type = HASH_TYPE_PDFU16;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9664 kern_type = KERN_TYPE_PDF11CM1;
9665 dgst_size = DGST_SIZE_4_4;
9666 parse_func = pdf11cm1_parse_hash;
9667 sort_by_digest = sort_by_digest_4_4;
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_NOT_ITERATED;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 10420: hash_type = HASH_TYPE_PDFU16;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_PDF11CM2;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = pdf11cm2_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_NOT_ITERATED;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 10500: hash_type = HASH_TYPE_PDFU16;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9696 kern_type = KERN_TYPE_PDF14;
9697 dgst_size = DGST_SIZE_4_4;
9698 parse_func = pdf14_parse_hash;
9699 sort_by_digest = sort_by_digest_4_4;
9700 opti_type = OPTI_TYPE_ZERO_BYTE
9701 | OPTI_TYPE_NOT_ITERATED;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 10600: hash_type = HASH_TYPE_SHA256;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_BE
9712 | OPTS_TYPE_ST_ADD80
9713 | OPTS_TYPE_ST_ADDBITS15
9714 | OPTS_TYPE_HASH_COPY;
9715 kern_type = KERN_TYPE_SHA256_PWSLT;
9716 dgst_size = DGST_SIZE_4_8;
9717 parse_func = pdf17l3_parse_hash;
9718 sort_by_digest = sort_by_digest_4_8;
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_PRECOMPUTE_INIT
9721 | OPTI_TYPE_PRECOMPUTE_MERKLE
9722 | OPTI_TYPE_EARLY_SKIP
9723 | OPTI_TYPE_NOT_ITERATED
9724 | OPTI_TYPE_APPENDED_SALT
9725 | OPTI_TYPE_RAW_HASH;
9726 dgst_pos0 = 3;
9727 dgst_pos1 = 7;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 6;
9730 break;
9731
9732 case 10700: hash_type = HASH_TYPE_PDFU32;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE
9736 | OPTS_TYPE_HASH_COPY;
9737 kern_type = KERN_TYPE_PDF17L8;
9738 dgst_size = DGST_SIZE_4_8;
9739 parse_func = pdf17l8_parse_hash;
9740 sort_by_digest = sort_by_digest_4_8;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_NOT_ITERATED;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 10800: hash_type = HASH_TYPE_SHA384;
9750 salt_type = SALT_TYPE_NONE;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_BE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_PT_ADDBITS15;
9755 kern_type = KERN_TYPE_SHA384;
9756 dgst_size = DGST_SIZE_8_8;
9757 parse_func = sha384_parse_hash;
9758 sort_by_digest = sort_by_digest_8_8;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_PRECOMPUTE_MERKLE
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED
9764 | OPTI_TYPE_NOT_SALTED
9765 | OPTI_TYPE_USES_BITS_64
9766 | OPTI_TYPE_RAW_HASH;
9767 dgst_pos0 = 6;
9768 dgst_pos1 = 7;
9769 dgst_pos2 = 4;
9770 dgst_pos3 = 5;
9771 break;
9772
9773 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE
9777 | OPTS_TYPE_ST_BASE64
9778 | OPTS_TYPE_HASH_COPY;
9779 kern_type = KERN_TYPE_PBKDF2_SHA256;
9780 dgst_size = DGST_SIZE_4_32;
9781 parse_func = pbkdf2_sha256_parse_hash;
9782 sort_by_digest = sort_by_digest_4_32;
9783 opti_type = OPTI_TYPE_ZERO_BYTE;
9784 dgst_pos0 = 0;
9785 dgst_pos1 = 1;
9786 dgst_pos2 = 2;
9787 dgst_pos3 = 3;
9788 break;
9789
9790 case 11000: hash_type = HASH_TYPE_MD5;
9791 salt_type = SALT_TYPE_INTERN;
9792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9793 opts_type = OPTS_TYPE_PT_GENERATE_LE
9794 | OPTS_TYPE_PT_ADD80;
9795 kern_type = KERN_TYPE_PRESTASHOP;
9796 dgst_size = DGST_SIZE_4_4;
9797 parse_func = prestashop_parse_hash;
9798 sort_by_digest = sort_by_digest_4_4;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_PRECOMPUTE_INIT
9801 | OPTI_TYPE_NOT_ITERATED
9802 | OPTI_TYPE_PREPENDED_SALT;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 3;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 1;
9807 break;
9808
9809 case 11100: hash_type = HASH_TYPE_MD5;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE
9813 | OPTS_TYPE_ST_ADD80;
9814 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9815 dgst_size = DGST_SIZE_4_4;
9816 parse_func = postgresql_auth_parse_hash;
9817 sort_by_digest = sort_by_digest_4_4;
9818 opti_type = OPTI_TYPE_ZERO_BYTE
9819 | OPTI_TYPE_PRECOMPUTE_INIT
9820 | OPTI_TYPE_PRECOMPUTE_MERKLE
9821 | OPTI_TYPE_EARLY_SKIP;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 3;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 11200: hash_type = HASH_TYPE_SHA1;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_BE
9832 | OPTS_TYPE_PT_ADD80
9833 | OPTS_TYPE_ST_HEX;
9834 kern_type = KERN_TYPE_MYSQL_AUTH;
9835 dgst_size = DGST_SIZE_4_5;
9836 parse_func = mysql_auth_parse_hash;
9837 sort_by_digest = sort_by_digest_4_5;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_EARLY_SKIP;
9840 dgst_pos0 = 3;
9841 dgst_pos1 = 4;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 1;
9844 break;
9845
9846 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9847 salt_type = SALT_TYPE_EMBEDDED;
9848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE
9850 | OPTS_TYPE_ST_HEX
9851 | OPTS_TYPE_ST_ADD80;
9852 kern_type = KERN_TYPE_BITCOIN_WALLET;
9853 dgst_size = DGST_SIZE_4_4;
9854 parse_func = bitcoin_wallet_parse_hash;
9855 sort_by_digest = sort_by_digest_4_4;
9856 opti_type = OPTI_TYPE_ZERO_BYTE;
9857 dgst_pos0 = 0;
9858 dgst_pos1 = 1;
9859 dgst_pos2 = 2;
9860 dgst_pos3 = 3;
9861 break;
9862
9863 case 11400: hash_type = HASH_TYPE_MD5;
9864 salt_type = SALT_TYPE_EMBEDDED;
9865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9866 opts_type = OPTS_TYPE_PT_GENERATE_LE
9867 | OPTS_TYPE_PT_ADD80
9868 | OPTS_TYPE_HASH_COPY;
9869 kern_type = KERN_TYPE_SIP_AUTH;
9870 dgst_size = DGST_SIZE_4_4;
9871 parse_func = sip_auth_parse_hash;
9872 sort_by_digest = sort_by_digest_4_4;
9873 opti_type = OPTI_TYPE_ZERO_BYTE;
9874 dgst_pos0 = 0;
9875 dgst_pos1 = 3;
9876 dgst_pos2 = 2;
9877 dgst_pos3 = 1;
9878 break;
9879
9880 case 11500: hash_type = HASH_TYPE_CRC32;
9881 salt_type = SALT_TYPE_INTERN;
9882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9883 opts_type = OPTS_TYPE_PT_GENERATE_LE
9884 | OPTS_TYPE_ST_GENERATE_LE
9885 | OPTS_TYPE_ST_HEX;
9886 kern_type = KERN_TYPE_CRC32;
9887 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9888 parse_func = crc32_parse_hash;
9889 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9890 opti_type = OPTI_TYPE_ZERO_BYTE;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 11600: hash_type = HASH_TYPE_AES;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE
9901 | OPTS_TYPE_PT_NEVERCRACK;
9902 kern_type = KERN_TYPE_SEVEN_ZIP;
9903 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9904 parse_func = seven_zip_parse_hash;
9905 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9906 opti_type = OPTI_TYPE_ZERO_BYTE;
9907 dgst_pos0 = 0;
9908 dgst_pos1 = 1;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 3;
9911 break;
9912
9913 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9914 salt_type = SALT_TYPE_NONE;
9915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_LE
9917 | OPTS_TYPE_PT_ADD01;
9918 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9919 dgst_size = DGST_SIZE_4_8;
9920 parse_func = gost2012sbog_256_parse_hash;
9921 sort_by_digest = sort_by_digest_4_8;
9922 opti_type = OPTI_TYPE_ZERO_BYTE;
9923 dgst_pos0 = 0;
9924 dgst_pos1 = 1;
9925 dgst_pos2 = 2;
9926 dgst_pos3 = 3;
9927 break;
9928
9929 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9930 salt_type = SALT_TYPE_NONE;
9931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9932 opts_type = OPTS_TYPE_PT_GENERATE_LE
9933 | OPTS_TYPE_PT_ADD01;
9934 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9935 dgst_size = DGST_SIZE_4_16;
9936 parse_func = gost2012sbog_512_parse_hash;
9937 sort_by_digest = sort_by_digest_4_16;
9938 opti_type = OPTI_TYPE_ZERO_BYTE;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 1;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 3;
9943 break;
9944
9945 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9946 salt_type = SALT_TYPE_EMBEDDED;
9947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_ST_BASE64
9950 | OPTS_TYPE_HASH_COPY;
9951 kern_type = KERN_TYPE_PBKDF2_MD5;
9952 dgst_size = DGST_SIZE_4_32;
9953 parse_func = pbkdf2_md5_parse_hash;
9954 sort_by_digest = sort_by_digest_4_32;
9955 opti_type = OPTI_TYPE_ZERO_BYTE;
9956 dgst_pos0 = 0;
9957 dgst_pos1 = 1;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 3;
9960 break;
9961
9962 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9963 salt_type = SALT_TYPE_EMBEDDED;
9964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_LE
9966 | OPTS_TYPE_ST_BASE64
9967 | OPTS_TYPE_HASH_COPY;
9968 kern_type = KERN_TYPE_PBKDF2_SHA1;
9969 dgst_size = DGST_SIZE_4_32;
9970 parse_func = pbkdf2_sha1_parse_hash;
9971 sort_by_digest = sort_by_digest_4_32;
9972 opti_type = OPTI_TYPE_ZERO_BYTE;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE
9983 | OPTS_TYPE_ST_BASE64
9984 | OPTS_TYPE_HASH_COPY;
9985 kern_type = KERN_TYPE_PBKDF2_SHA512;
9986 dgst_size = DGST_SIZE_8_16;
9987 parse_func = pbkdf2_sha512_parse_hash;
9988 sort_by_digest = sort_by_digest_8_16;
9989 opti_type = OPTI_TYPE_ZERO_BYTE
9990 | OPTI_TYPE_USES_BITS_64;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_ECRYPTFS;
10002 dgst_size = DGST_SIZE_8_8;
10003 parse_func = ecryptfs_parse_hash;
10004 sort_by_digest = sort_by_digest_8_8;
10005 opti_type = OPTI_TYPE_ZERO_BYTE
10006 | OPTI_TYPE_USES_BITS_64;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 12300: hash_type = HASH_TYPE_ORACLET;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10017 kern_type = KERN_TYPE_ORACLET;
10018 dgst_size = DGST_SIZE_8_16;
10019 parse_func = oraclet_parse_hash;
10020 sort_by_digest = sort_by_digest_8_16;
10021 opti_type = OPTI_TYPE_ZERO_BYTE
10022 | OPTI_TYPE_USES_BITS_64;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10033 kern_type = KERN_TYPE_BSDICRYPT;
10034 dgst_size = DGST_SIZE_4_4;
10035 parse_func = bsdicrypt_parse_hash;
10036 sort_by_digest = sort_by_digest_4_4;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 12500: hash_type = HASH_TYPE_RAR3HP;
10046 salt_type = SALT_TYPE_EMBEDDED;
10047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10049 kern_type = KERN_TYPE_RAR3;
10050 dgst_size = DGST_SIZE_4_4;
10051 parse_func = rar3hp_parse_hash;
10052 sort_by_digest = sort_by_digest_4_4;
10053 opti_type = OPTI_TYPE_ZERO_BYTE;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 1;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 3;
10058 break;
10059
10060 case 12600: hash_type = HASH_TYPE_SHA256;
10061 salt_type = SALT_TYPE_INTERN;
10062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_BE
10064 | OPTS_TYPE_PT_ADD80;
10065 kern_type = KERN_TYPE_CF10;
10066 dgst_size = DGST_SIZE_4_8;
10067 parse_func = cf10_parse_hash;
10068 sort_by_digest = sort_by_digest_4_8;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_PRECOMPUTE_INIT
10071 | OPTI_TYPE_EARLY_SKIP
10072 | OPTI_TYPE_NOT_ITERATED;
10073 dgst_pos0 = 3;
10074 dgst_pos1 = 7;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 6;
10077 break;
10078
10079 case 12700: hash_type = HASH_TYPE_AES;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE
10083 | OPTS_TYPE_HASH_COPY;
10084 kern_type = KERN_TYPE_MYWALLET;
10085 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10086 parse_func = mywallet_parse_hash;
10087 sort_by_digest = sort_by_digest_4_5;
10088 opti_type = OPTI_TYPE_ZERO_BYTE;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10099 kern_type = KERN_TYPE_MS_DRSR;
10100 dgst_size = DGST_SIZE_4_8;
10101 parse_func = ms_drsr_parse_hash;
10102 sort_by_digest = sort_by_digest_4_8;
10103 opti_type = OPTI_TYPE_ZERO_BYTE;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10114 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10115 dgst_size = DGST_SIZE_4_8;
10116 parse_func = androidfde_samsung_parse_hash;
10117 sort_by_digest = sort_by_digest_4_8;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_RAR5;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = rar5_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE;
10134 dgst_pos0 = 0;
10135 dgst_pos1 = 1;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 3;
10138 break;
10139
10140 default: usage_mini_print (PROGNAME); return (-1);
10141 }
10142
10143 /**
10144 * transpose
10145 */
10146
10147 data.parse_func = parse_func;
10148
10149 /**
10150 * misc stuff
10151 */
10152
10153 if (hex_salt)
10154 {
10155 if (salt_type == SALT_TYPE_INTERN)
10156 {
10157 opts_type |= OPTS_TYPE_ST_HEX;
10158 }
10159 else
10160 {
10161 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10162
10163 return (-1);
10164 }
10165 }
10166
10167 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10168 | (salt_type == SALT_TYPE_EXTERN)
10169 | (salt_type == SALT_TYPE_EMBEDDED)
10170 | (salt_type == SALT_TYPE_VIRTUAL));
10171
10172 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10173
10174 data.hash_type = hash_type;
10175 data.attack_mode = attack_mode;
10176 data.attack_kern = attack_kern;
10177 data.attack_exec = attack_exec;
10178 data.kern_type = kern_type;
10179 data.opts_type = opts_type;
10180 data.dgst_size = dgst_size;
10181 data.salt_type = salt_type;
10182 data.isSalted = isSalted;
10183 data.sort_by_digest = sort_by_digest;
10184 data.dgst_pos0 = dgst_pos0;
10185 data.dgst_pos1 = dgst_pos1;
10186 data.dgst_pos2 = dgst_pos2;
10187 data.dgst_pos3 = dgst_pos3;
10188
10189 esalt_size = 0;
10190
10191 switch (hash_mode)
10192 {
10193 case 2500: esalt_size = sizeof (wpa_t); break;
10194 case 5300: esalt_size = sizeof (ikepsk_t); break;
10195 case 5400: esalt_size = sizeof (ikepsk_t); break;
10196 case 5500: esalt_size = sizeof (netntlm_t); break;
10197 case 5600: esalt_size = sizeof (netntlm_t); break;
10198 case 6211:
10199 case 6212:
10200 case 6213:
10201 case 6221:
10202 case 6222:
10203 case 6223:
10204 case 6231:
10205 case 6232:
10206 case 6233:
10207 case 6241:
10208 case 6242:
10209 case 6243: esalt_size = sizeof (tc_t); break;
10210 case 6600: esalt_size = sizeof (agilekey_t); break;
10211 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10212 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10213 case 7300: esalt_size = sizeof (rakp_t); break;
10214 case 7500: esalt_size = sizeof (krb5pa_t); break;
10215 case 8200: esalt_size = sizeof (cloudkey_t); break;
10216 case 8800: esalt_size = sizeof (androidfde_t); break;
10217 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10218 case 9400: esalt_size = sizeof (office2007_t); break;
10219 case 9500: esalt_size = sizeof (office2010_t); break;
10220 case 9600: esalt_size = sizeof (office2013_t); break;
10221 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10222 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10223 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10224 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10225 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10226 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10227 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10228 case 10200: esalt_size = sizeof (cram_md5_t); break;
10229 case 10400: esalt_size = sizeof (pdf_t); break;
10230 case 10410: esalt_size = sizeof (pdf_t); break;
10231 case 10420: esalt_size = sizeof (pdf_t); break;
10232 case 10500: esalt_size = sizeof (pdf_t); break;
10233 case 10600: esalt_size = sizeof (pdf_t); break;
10234 case 10700: esalt_size = sizeof (pdf_t); break;
10235 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10236 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10237 case 11400: esalt_size = sizeof (sip_t); break;
10238 case 11600: esalt_size = sizeof (seven_zip_t); break;
10239 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10240 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10241 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10242 case 13000: esalt_size = sizeof (rar5_t); break;
10243 }
10244
10245 data.esalt_size = esalt_size;
10246
10247 /**
10248 * choose dictionary parser
10249 */
10250
10251 if (hash_type == HASH_TYPE_LM)
10252 {
10253 get_next_word_func = get_next_word_lm;
10254 }
10255 else if (opts_type & OPTS_TYPE_PT_UPPER)
10256 {
10257 get_next_word_func = get_next_word_uc;
10258 }
10259 else
10260 {
10261 get_next_word_func = get_next_word_std;
10262 }
10263
10264 /**
10265 * dictstat
10266 */
10267
10268 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10269
10270 #ifdef _POSIX
10271 size_t dictstat_nmemb = 0;
10272 #endif
10273
10274 #ifdef _WIN
10275 uint dictstat_nmemb = 0;
10276 #endif
10277
10278 char dictstat[256] = { 0 };
10279
10280 FILE *dictstat_fp = NULL;
10281
10282 if (keyspace == 0)
10283 {
10284 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10285
10286 dictstat_fp = fopen (dictstat, "rb");
10287
10288 if (dictstat_fp)
10289 {
10290 #ifdef _POSIX
10291 struct stat tmpstat;
10292
10293 fstat (fileno (dictstat_fp), &tmpstat);
10294 #endif
10295
10296 #ifdef _WIN
10297 struct stat64 tmpstat;
10298
10299 _fstat64 (fileno (dictstat_fp), &tmpstat);
10300 #endif
10301
10302 if (tmpstat.st_mtime < COMPTIME)
10303 {
10304 /* with v0.15 the format changed so we have to ensure user is using a good version
10305 since there is no version-header in the dictstat file */
10306
10307 fclose (dictstat_fp);
10308
10309 unlink (dictstat);
10310 }
10311 else
10312 {
10313 while (!feof (dictstat_fp))
10314 {
10315 dictstat_t d;
10316
10317 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10318
10319 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10320
10321 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10322 {
10323 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10324
10325 return -1;
10326 }
10327 }
10328
10329 fclose (dictstat_fp);
10330 }
10331 }
10332 }
10333
10334 /**
10335 * potfile
10336 */
10337
10338 char potfile[256] = { 0 };
10339
10340 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10341
10342 data.pot_fp = NULL;
10343
10344 FILE *out_fp = NULL;
10345 FILE *pot_fp = NULL;
10346
10347 if (show == 1 || left == 1)
10348 {
10349 pot_fp = fopen (potfile, "rb");
10350
10351 if (pot_fp == NULL)
10352 {
10353 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10354
10355 return (-1);
10356 }
10357
10358 if (outfile != NULL)
10359 {
10360 if ((out_fp = fopen (outfile, "ab")) == NULL)
10361 {
10362 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10363
10364 fclose (pot_fp);
10365
10366 return (-1);
10367 }
10368 }
10369 else
10370 {
10371 out_fp = stdout;
10372 }
10373 }
10374 else
10375 {
10376 if (potfile_disable == 0)
10377 {
10378 pot_fp = fopen (potfile, "ab");
10379
10380 if (pot_fp == NULL)
10381 {
10382 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10383
10384 return (-1);
10385 }
10386
10387 data.pot_fp = pot_fp;
10388 }
10389 }
10390
10391 pot_t *pot = NULL;
10392
10393 uint pot_cnt = 0;
10394 uint pot_avail = 0;
10395
10396 if (show == 1 || left == 1)
10397 {
10398 SUPPRESS_OUTPUT = 1;
10399
10400 pot_avail = count_lines (pot_fp);
10401
10402 rewind (pot_fp);
10403
10404 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10405
10406 uint pot_hashes_avail = 0;
10407
10408 uint line_num = 0;
10409
10410 while (!feof (pot_fp))
10411 {
10412 line_num++;
10413
10414 char line_buf[BUFSIZ] = { 0 };
10415
10416 int line_len = fgetl (pot_fp, line_buf);
10417
10418 if (line_len == 0) continue;
10419
10420 char *plain_buf = line_buf + line_len;
10421
10422 pot_t *pot_ptr = &pot[pot_cnt];
10423
10424 hash_t *hashes_buf = &pot_ptr->hash;
10425
10426 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10427 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10428
10429 if (pot_cnt == pot_hashes_avail)
10430 {
10431 uint pos = 0;
10432
10433 for (pos = 0; pos < INCR_POT; pos++)
10434 {
10435 if ((pot_cnt + pos) >= pot_avail) break;
10436
10437 pot_t *tmp_pot = &pot[pot_cnt + pos];
10438
10439 hash_t *tmp_hash = &tmp_pot->hash;
10440
10441 tmp_hash->digest = mymalloc (dgst_size);
10442
10443 if (isSalted)
10444 {
10445 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10446 }
10447
10448 if (esalt_size)
10449 {
10450 tmp_hash->esalt = mymalloc (esalt_size);
10451 }
10452
10453 pot_hashes_avail++;
10454 }
10455 }
10456
10457 int plain_len = 0;
10458
10459 int parser_status;
10460
10461 int iter = MAX_CUT_TRIES;
10462
10463 do
10464 {
10465 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10466 {
10467 if (line_buf[i] == ':')
10468 {
10469 line_len--;
10470
10471 break;
10472 }
10473 }
10474
10475 if (data.hash_mode != 2500)
10476 {
10477 parser_status = parse_func (line_buf, line_len, hashes_buf);
10478 }
10479 else
10480 {
10481 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10482
10483 if (line_len > max_salt_size)
10484 {
10485 parser_status = PARSER_GLOBAL_LENGTH;
10486 }
10487 else
10488 {
10489 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10490
10491 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10492
10493 hashes_buf->salt->salt_len = line_len;
10494
10495 parser_status = PARSER_OK;
10496 }
10497 }
10498
10499 // if NOT parsed without error, we add the ":" to the plain
10500
10501 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10502 {
10503 plain_len++;
10504 plain_buf--;
10505 }
10506
10507 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10508
10509 if (parser_status < PARSER_GLOBAL_ZERO)
10510 {
10511 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10512
10513 continue;
10514 }
10515
10516 if (plain_len >= 255) continue;
10517
10518 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10519
10520 pot_ptr->plain_len = plain_len;
10521
10522 pot_cnt++;
10523 }
10524
10525 fclose (pot_fp);
10526
10527 SUPPRESS_OUTPUT = 0;
10528
10529 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10530 }
10531
10532 /**
10533 * word len
10534 */
10535
10536 uint pw_min = PW_MIN;
10537 uint pw_max = PW_MAX;
10538
10539 switch (hash_mode)
10540 {
10541 case 400: if (pw_max > 40) pw_max = 40;
10542 break;
10543 case 500: if (pw_max > 16) pw_max = 16;
10544 break;
10545 case 1500: if (pw_max > 8) pw_max = 8;
10546 break;
10547 case 1600: if (pw_max > 16) pw_max = 16;
10548 break;
10549 case 1800: if (pw_max > 16) pw_max = 16;
10550 break;
10551 case 2100: if (pw_max > 16) pw_max = 16;
10552 break;
10553 case 2500: if (pw_min < 8) pw_min = 8;
10554 break;
10555 case 3000: if (pw_max > 7) pw_max = 7;
10556 break;
10557 case 5200: if (pw_max > 24) pw_max = 24;
10558 break;
10559 case 5800: if (pw_max > 16) pw_max = 16;
10560 break;
10561 case 6300: if (pw_max > 16) pw_max = 16;
10562 break;
10563 case 7400: if (pw_max > 16) pw_max = 16;
10564 break;
10565 case 7900: if (pw_max > 48) pw_max = 48;
10566 break;
10567 case 8500: if (pw_max > 8) pw_max = 8;
10568 break;
10569 case 8600: if (pw_max > 16) pw_max = 16;
10570 break;
10571 case 9710: pw_min = 5;
10572 pw_max = 5;
10573 break;
10574 case 9810: pw_min = 5;
10575 pw_max = 5;
10576 break;
10577 case 10410: pw_min = 5;
10578 pw_max = 5;
10579 break;
10580 case 10300: if (pw_max < 3) pw_min = 3;
10581 if (pw_max > 40) pw_max = 40;
10582 break;
10583 case 10500: if (pw_max < 3) pw_min = 3;
10584 if (pw_max > 40) pw_max = 40;
10585 break;
10586 case 10700: if (pw_max > 16) pw_max = 16;
10587 break;
10588 case 11300: if (pw_max > 40) pw_max = 40;
10589 break;
10590 case 12500: if (pw_max > 20) pw_max = 20;
10591 break;
10592 case 12800: if (pw_max > 24) pw_max = 24;
10593 break;
10594 }
10595
10596 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10597 {
10598 switch (attack_kern)
10599 {
10600 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10601 break;
10602 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10603 break;
10604 }
10605 }
10606
10607 /**
10608 * charsets : keep them together for more easy maintainnce
10609 */
10610
10611 cs_t mp_sys[6] = { { { 0 }, 0 } };
10612 cs_t mp_usr[4] = { { { 0 }, 0 } };
10613
10614 mp_setup_sys (mp_sys);
10615
10616 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10617 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10618 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10619 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10620
10621 /**
10622 * load hashes, part I: find input mode, count hashes
10623 */
10624
10625 uint hashlist_mode = 0;
10626 uint hashlist_format = HLFMT_HASHCAT;
10627
10628 uint hashes_avail = 0;
10629
10630 if (benchmark == 0)
10631 {
10632 struct stat f;
10633
10634 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10635
10636 if ((hash_mode == 2500) ||
10637 (hash_mode == 5200) ||
10638 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10639 (hash_mode == 9000))
10640 {
10641 hashlist_mode = HL_MODE_ARG;
10642
10643 char *hashfile = myargv[optind];
10644
10645 data.hashfile = hashfile;
10646
10647 logfile_top_var_string ("target", hashfile);
10648 }
10649
10650 if (hashlist_mode == HL_MODE_ARG)
10651 {
10652 if (hash_mode == 2500)
10653 {
10654 struct stat st;
10655
10656 if (stat (data.hashfile, &st) == -1)
10657 {
10658 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10659
10660 return (-1);
10661 }
10662
10663 hashes_avail = st.st_size / sizeof (hccap_t);
10664 }
10665 else
10666 {
10667 hashes_avail = 1;
10668 }
10669 }
10670 else if (hashlist_mode == HL_MODE_FILE)
10671 {
10672 char *hashfile = myargv[optind];
10673
10674 data.hashfile = hashfile;
10675
10676 logfile_top_var_string ("target", hashfile);
10677
10678 FILE *fp = NULL;
10679
10680 if ((fp = fopen (hashfile, "rb")) == NULL)
10681 {
10682 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10683
10684 return (-1);
10685 }
10686
10687 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10688
10689 hashes_avail = count_lines (fp);
10690
10691 rewind (fp);
10692
10693 if (hashes_avail == 0)
10694 {
10695 log_error ("ERROR: hashfile is empty or corrupt");
10696
10697 fclose (fp);
10698
10699 return (-1);
10700 }
10701
10702 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10703
10704 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10705 {
10706 log_error ("ERROR: remove not supported in native hashfile-format mode");
10707
10708 fclose (fp);
10709
10710 return (-1);
10711 }
10712
10713 fclose (fp);
10714 }
10715 }
10716 else
10717 {
10718 hashlist_mode = HL_MODE_ARG;
10719
10720 hashes_avail = 1;
10721 }
10722
10723 if (hash_mode == 3000) hashes_avail *= 2;
10724
10725 data.hashlist_mode = hashlist_mode;
10726 data.hashlist_format = hashlist_format;
10727
10728 logfile_top_uint (hashlist_mode);
10729 logfile_top_uint (hashlist_format);
10730
10731 /**
10732 * load hashes, part II: allocate required memory, set pointers
10733 */
10734
10735 hash_t *hashes_buf = NULL;
10736 void *digests_buf = NULL;
10737 salt_t *salts_buf = NULL;
10738 void *esalts_buf = NULL;
10739
10740 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10741
10742 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10743
10744 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10745 {
10746 u32 hash_pos;
10747
10748 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10749 {
10750 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10751
10752 hashes_buf[hash_pos].hash_info = hash_info;
10753
10754 if (username && (remove || show || left))
10755 {
10756 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10757 }
10758
10759 if (benchmark)
10760 {
10761 hash_info->orighash = (char *) mymalloc (256);
10762 }
10763 }
10764 }
10765
10766 if (isSalted)
10767 {
10768 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10769
10770 if (esalt_size)
10771 {
10772 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10773 }
10774 }
10775 else
10776 {
10777 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10778 }
10779
10780 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10781 {
10782 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10783
10784 if (isSalted)
10785 {
10786 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10787
10788 if (esalt_size)
10789 {
10790 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10791 }
10792 }
10793 else
10794 {
10795 hashes_buf[hash_pos].salt = &salts_buf[0];
10796 }
10797 }
10798
10799 /**
10800 * load hashes, part III: parse hashes or generate them if benchmark
10801 */
10802
10803 uint hashes_cnt = 0;
10804
10805 if (benchmark == 0)
10806 {
10807 if (keyspace == 1)
10808 {
10809 // useless to read hash file for keyspace, cheat a little bit w/ optind
10810 }
10811 else if (hashes_avail == 0)
10812 {
10813 }
10814 else if (hashlist_mode == HL_MODE_ARG)
10815 {
10816 char *input_buf = myargv[optind];
10817
10818 uint input_len = strlen (input_buf);
10819
10820 logfile_top_var_string ("target", input_buf);
10821
10822 char *hash_buf = NULL;
10823 int hash_len = 0;
10824
10825 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10826
10827 if (hash_len)
10828 {
10829 if (opts_type & OPTS_TYPE_HASH_COPY)
10830 {
10831 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10832
10833 hash_info_tmp->orighash = mystrdup (hash_buf);
10834 }
10835
10836 if (isSalted)
10837 {
10838 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10839 }
10840
10841 int parser_status = PARSER_OK;
10842
10843 if (hash_mode == 2500)
10844 {
10845 if (hash_len == 0)
10846 {
10847 log_error ("ERROR: hccap file not specified");
10848
10849 return (-1);
10850 }
10851
10852 hashlist_mode = HL_MODE_FILE;
10853
10854 data.hashlist_mode = hashlist_mode;
10855
10856 FILE *fp = fopen (hash_buf, "rb");
10857
10858 if (fp == NULL)
10859 {
10860 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10861
10862 return (-1);
10863 }
10864
10865 if (hashes_avail < 1)
10866 {
10867 log_error ("ERROR: hccap file is empty or corrupt");
10868
10869 fclose (fp);
10870
10871 return (-1);
10872 }
10873
10874 uint hccap_size = sizeof (hccap_t);
10875
10876 char *in = (char *) mymalloc (hccap_size);
10877
10878 while (!feof (fp))
10879 {
10880 int n = fread (in, hccap_size, 1, fp);
10881
10882 if (n != 1)
10883 {
10884 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10885
10886 break;
10887 }
10888
10889 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10890
10891 if (parser_status != PARSER_OK)
10892 {
10893 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10894
10895 continue;
10896 }
10897
10898 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10899
10900 if ((show == 1) || (left == 1))
10901 {
10902 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10903
10904 char *salt_ptr = (char *) tmp_salt->salt_buf;
10905
10906 int cur_pos = tmp_salt->salt_len;
10907 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10908
10909 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10910
10911 u8 *pke_ptr = (u8 *) wpa->pke;
10912
10913 // do the appending task
10914
10915 snprintf (salt_ptr + cur_pos,
10916 rem_len,
10917 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10918 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10919 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10920
10921
10922 // memset () the remaining part of the salt
10923
10924 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10925 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10926
10927 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10928
10929 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10930 }
10931
10932 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);
10933 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);
10934
10935 hashes_cnt++;
10936 }
10937
10938 fclose (fp);
10939
10940 myfree (in);
10941 }
10942 else if (hash_mode == 3000)
10943 {
10944 if (hash_len == 32)
10945 {
10946 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10947
10948 hash_t *lm_hash_left = NULL;
10949
10950 if (parser_status == PARSER_OK)
10951 {
10952 lm_hash_left = &hashes_buf[hashes_cnt];
10953
10954 hashes_cnt++;
10955 }
10956 else
10957 {
10958 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10959 }
10960
10961 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10962
10963 hash_t *lm_hash_right = NULL;
10964
10965 if (parser_status == PARSER_OK)
10966 {
10967 lm_hash_right = &hashes_buf[hashes_cnt];
10968
10969 hashes_cnt++;
10970 }
10971 else
10972 {
10973 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10974 }
10975
10976 // show / left
10977
10978 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10979 {
10980 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);
10981 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);
10982 }
10983 }
10984 else
10985 {
10986 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10987
10988 if (parser_status == PARSER_OK)
10989 {
10990 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10991 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10992 }
10993
10994 if (parser_status == PARSER_OK)
10995 {
10996 hashes_cnt++;
10997 }
10998 else
10999 {
11000 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11001 }
11002 }
11003 }
11004 else
11005 {
11006 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11007
11008 if (parser_status == PARSER_OK)
11009 {
11010 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11011 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11012 }
11013
11014 if (parser_status == PARSER_OK)
11015 {
11016 hashes_cnt++;
11017 }
11018 else
11019 {
11020 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11021 }
11022 }
11023 }
11024 }
11025 else if (hashlist_mode == HL_MODE_FILE)
11026 {
11027 char *hashfile = data.hashfile;
11028
11029 FILE *fp;
11030
11031 if ((fp = fopen (hashfile, "rb")) == NULL)
11032 {
11033 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11034
11035 return (-1);
11036 }
11037
11038 uint line_num = 0;
11039
11040 while (!feof (fp))
11041 {
11042 line_num++;
11043
11044 char line_buf[BUFSIZ] = { 0 };
11045
11046 int line_len = fgetl (fp, line_buf);
11047
11048 if (line_len == 0) continue;
11049
11050 char *hash_buf = NULL;
11051 int hash_len = 0;
11052
11053 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11054
11055 if (username)
11056 {
11057 char *user_buf = NULL;
11058 int user_len = 0;
11059
11060 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11061
11062 if (remove || show)
11063 {
11064 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11065
11066 *user = (user_t *) mymalloc (sizeof (user_t));
11067
11068 user_t *user_ptr = *user;
11069
11070 if (user_buf != NULL)
11071 {
11072 user_ptr->user_name = mystrdup (user_buf);
11073 }
11074 else
11075 {
11076 user_ptr->user_name = mystrdup ("");
11077 }
11078
11079 user_ptr->user_len = user_len;
11080 }
11081 }
11082
11083 if (opts_type & OPTS_TYPE_HASH_COPY)
11084 {
11085 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11086
11087 hash_info_tmp->orighash = mystrdup (hash_buf);
11088 }
11089
11090 if (isSalted)
11091 {
11092 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11093 }
11094
11095 if (hash_mode == 3000)
11096 {
11097 if (hash_len == 32)
11098 {
11099 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11100
11101 if (parser_status < PARSER_GLOBAL_ZERO)
11102 {
11103 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11104
11105 continue;
11106 }
11107
11108 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11109
11110 hashes_cnt++;
11111
11112 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11113
11114 if (parser_status < PARSER_GLOBAL_ZERO)
11115 {
11116 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11117
11118 continue;
11119 }
11120
11121 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11122
11123 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);
11124
11125 hashes_cnt++;
11126
11127 // show / left
11128
11129 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);
11130 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);
11131 }
11132 else
11133 {
11134 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11135
11136 if (parser_status < PARSER_GLOBAL_ZERO)
11137 {
11138 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11139
11140 continue;
11141 }
11142
11143 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);
11144
11145 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11146 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11147
11148 hashes_cnt++;
11149 }
11150 }
11151 else
11152 {
11153 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11154
11155 if (parser_status < PARSER_GLOBAL_ZERO)
11156 {
11157 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11158
11159 continue;
11160 }
11161
11162 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);
11163
11164 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11165 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11166
11167 hashes_cnt++;
11168 }
11169 }
11170
11171 fclose (fp);
11172
11173 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11174
11175 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11176 }
11177 }
11178 else
11179 {
11180 if (isSalted)
11181 {
11182 hashes_buf[0].salt->salt_len = 8;
11183
11184 // special salt handling
11185
11186 switch (hash_mode)
11187 {
11188 case 1500: hashes_buf[0].salt->salt_len = 2;
11189 break;
11190 case 1731: hashes_buf[0].salt->salt_len = 4;
11191 break;
11192 case 2410: hashes_buf[0].salt->salt_len = 4;
11193 break;
11194 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11195 break;
11196 case 3100: hashes_buf[0].salt->salt_len = 1;
11197 break;
11198 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11199 break;
11200 case 5800: hashes_buf[0].salt->salt_len = 16;
11201 break;
11202 case 6800: hashes_buf[0].salt->salt_len = 32;
11203 break;
11204 case 8400: hashes_buf[0].salt->salt_len = 40;
11205 break;
11206 case 8800: hashes_buf[0].salt->salt_len = 16;
11207 break;
11208 case 8900: hashes_buf[0].salt->salt_len = 16;
11209 hashes_buf[0].salt->scrypt_N = 1024;
11210 hashes_buf[0].salt->scrypt_r = 1;
11211 hashes_buf[0].salt->scrypt_p = 1;
11212 break;
11213 case 9100: hashes_buf[0].salt->salt_len = 16;
11214 break;
11215 case 9300: hashes_buf[0].salt->salt_len = 14;
11216 hashes_buf[0].salt->scrypt_N = 16384;
11217 hashes_buf[0].salt->scrypt_r = 1;
11218 hashes_buf[0].salt->scrypt_p = 1;
11219 break;
11220 case 9400: hashes_buf[0].salt->salt_len = 16;
11221 break;
11222 case 9500: hashes_buf[0].salt->salt_len = 16;
11223 break;
11224 case 9600: hashes_buf[0].salt->salt_len = 16;
11225 break;
11226 case 9700: hashes_buf[0].salt->salt_len = 16;
11227 break;
11228 case 9710: hashes_buf[0].salt->salt_len = 16;
11229 break;
11230 case 9720: hashes_buf[0].salt->salt_len = 16;
11231 break;
11232 case 9800: hashes_buf[0].salt->salt_len = 16;
11233 break;
11234 case 9810: hashes_buf[0].salt->salt_len = 16;
11235 break;
11236 case 9820: hashes_buf[0].salt->salt_len = 16;
11237 break;
11238 case 10300: hashes_buf[0].salt->salt_len = 12;
11239 break;
11240 case 11500: hashes_buf[0].salt->salt_len = 4;
11241 break;
11242 case 11600: hashes_buf[0].salt->salt_len = 4;
11243 break;
11244 case 12400: hashes_buf[0].salt->salt_len = 4;
11245 break;
11246 case 12500: hashes_buf[0].salt->salt_len = 8;
11247 break;
11248 case 12600: hashes_buf[0].salt->salt_len = 64;
11249 break;
11250 }
11251
11252 // special esalt handling
11253
11254 switch (hash_mode)
11255 {
11256 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11257 break;
11258 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11259 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11260 break;
11261 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11262 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11263 break;
11264 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11265 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11266 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11267 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11268 break;
11269 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11270 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11271 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11272 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11273 break;
11274 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11275 break;
11276 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11277 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11278 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11279 break;
11280 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11281 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11282 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11283 break;
11284 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11285 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11286 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11287 break;
11288 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11289 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11290 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11291 break;
11292 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11293 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11294 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11295 break;
11296 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11297 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11298 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11299 break;
11300 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11301 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11302 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11303 break;
11304 }
11305 }
11306
11307 // set hashfile
11308
11309 switch (hash_mode)
11310 {
11311 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11312 break;
11313 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11314 break;
11315 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11316 break;
11317 case 6211:
11318 case 6212:
11319 case 6213:
11320 case 6221:
11321 case 6222:
11322 case 6223:
11323 case 6231:
11324 case 6232:
11325 case 6233:
11326 case 6241:
11327 case 6242:
11328 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11329 break;
11330 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11331 break;
11332 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11333 break;
11334 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11335 break;
11336 }
11337
11338 // set default iterations
11339
11340 switch (hash_mode)
11341 {
11342 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11343 break;
11344 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11345 break;
11346 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11347 break;
11348 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11349 break;
11350 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11351 break;
11352 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11353 break;
11354 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11355 break;
11356 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11357 break;
11358 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11359 break;
11360 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11361 break;
11362 case 6211:
11363 case 6212:
11364 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11365 break;
11366 case 6221:
11367 case 6222:
11368 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11369 break;
11370 case 6231:
11371 case 6232:
11372 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11373 break;
11374 case 6241:
11375 case 6242:
11376 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11377 break;
11378 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11379 break;
11380 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11381 break;
11382 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11383 break;
11384 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11385 break;
11386 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11387 break;
11388 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11389 break;
11390 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11391 break;
11392 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11393 break;
11394 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11395 break;
11396 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11397 break;
11398 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11399 break;
11400 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11401 break;
11402 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11403 break;
11404 case 8900: hashes_buf[0].salt->salt_iter = 1;
11405 break;
11406 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11407 break;
11408 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11409 break;
11410 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11411 break;
11412 case 9300: hashes_buf[0].salt->salt_iter = 1;
11413 break;
11414 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11415 break;
11416 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11417 break;
11418 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11419 break;
11420 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11421 break;
11422 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11423 break;
11424 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11425 break;
11426 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11427 break;
11428 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11429 break;
11430 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11431 break;
11432 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11433 break;
11434 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11435 break;
11436 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11437 break;
11438 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11439 break;
11440 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11441 break;
11442 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11443 break;
11444 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11445 break;
11446 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11447 break;
11448 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11449 break;
11450 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11451 break;
11452 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11453 break;
11454 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11455 break;
11456 }
11457
11458 hashes_cnt = 1;
11459 }
11460
11461 if (show == 1 || left == 1)
11462 {
11463 for (uint i = 0; i < pot_cnt; i++)
11464 {
11465 pot_t *pot_ptr = &pot[i];
11466
11467 hash_t *hashes_buf = &pot_ptr->hash;
11468
11469 local_free (hashes_buf->digest);
11470
11471 if (isSalted)
11472 {
11473 local_free (hashes_buf->salt);
11474 }
11475 }
11476
11477 local_free (pot);
11478
11479 if (data.quiet == 0) log_info_nn ("");
11480
11481 return (0);
11482 }
11483
11484 if (keyspace == 0)
11485 {
11486 if (hashes_cnt == 0)
11487 {
11488 log_error ("ERROR: No hashes loaded");
11489
11490 return (-1);
11491 }
11492 }
11493
11494 /**
11495 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11496 */
11497
11498 if (data.outfile != NULL)
11499 {
11500 if (data.hashfile != NULL)
11501 {
11502 #ifdef _POSIX
11503 struct stat tmpstat_outfile;
11504 struct stat tmpstat_hashfile;
11505 #endif
11506
11507 #ifdef _WIN
11508 struct stat64 tmpstat_outfile;
11509 struct stat64 tmpstat_hashfile;
11510 #endif
11511
11512 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11513
11514 if (tmp_outfile_fp)
11515 {
11516 #ifdef _POSIX
11517 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11518 #endif
11519
11520 #ifdef _WIN
11521 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11522 #endif
11523
11524 fclose (tmp_outfile_fp);
11525 }
11526
11527 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11528
11529 if (tmp_hashfile_fp)
11530 {
11531 #ifdef _POSIX
11532 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11533 #endif
11534
11535 #ifdef _WIN
11536 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11537 #endif
11538
11539 fclose (tmp_hashfile_fp);
11540 }
11541
11542 if (tmp_outfile_fp && tmp_outfile_fp)
11543 {
11544 tmpstat_outfile.st_mode = 0;
11545 tmpstat_outfile.st_nlink = 0;
11546 tmpstat_outfile.st_uid = 0;
11547 tmpstat_outfile.st_gid = 0;
11548 tmpstat_outfile.st_rdev = 0;
11549 tmpstat_outfile.st_atime = 0;
11550
11551 tmpstat_hashfile.st_mode = 0;
11552 tmpstat_hashfile.st_nlink = 0;
11553 tmpstat_hashfile.st_uid = 0;
11554 tmpstat_hashfile.st_gid = 0;
11555 tmpstat_hashfile.st_rdev = 0;
11556 tmpstat_hashfile.st_atime = 0;
11557
11558 #ifdef _POSIX
11559 tmpstat_outfile.st_blksize = 0;
11560 tmpstat_outfile.st_blocks = 0;
11561
11562 tmpstat_hashfile.st_blksize = 0;
11563 tmpstat_hashfile.st_blocks = 0;
11564 #endif
11565
11566 #ifdef _POSIX
11567 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11568 {
11569 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11570
11571 return (-1);
11572 }
11573 #endif
11574
11575 #ifdef _WIN
11576 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11577 {
11578 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11579
11580 return (-1);
11581 }
11582 #endif
11583 }
11584 }
11585 }
11586
11587 /**
11588 * Remove duplicates
11589 */
11590
11591 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11592
11593 if (isSalted)
11594 {
11595 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11596 }
11597 else
11598 {
11599 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11600 }
11601
11602 uint hashes_cnt_orig = hashes_cnt;
11603
11604 hashes_cnt = 1;
11605
11606 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11607 {
11608 if (isSalted)
11609 {
11610 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11611 {
11612 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11613 }
11614 }
11615 else
11616 {
11617 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11618 }
11619
11620 if (hashes_pos > hashes_cnt)
11621 {
11622 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11623 }
11624
11625 hashes_cnt++;
11626 }
11627
11628 /**
11629 * Potfile removes
11630 */
11631
11632 uint potfile_remove_cracks = 0;
11633
11634 if (potfile_disable == 0)
11635 {
11636 hash_t hash_buf;
11637
11638 hash_buf.digest = mymalloc (dgst_size);
11639 hash_buf.salt = NULL;
11640 hash_buf.esalt = NULL;
11641 hash_buf.hash_info = NULL;
11642 hash_buf.cracked = 0;
11643
11644 if (isSalted)
11645 {
11646 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11647 }
11648
11649 if (esalt_size)
11650 {
11651 hash_buf.esalt = mymalloc (esalt_size);
11652 }
11653
11654 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11655
11656 // no solution for these special hash types (for instane because they use hashfile in output etc)
11657 if ((hash_mode != 5200) &&
11658 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11659 (hash_mode != 9000))
11660 {
11661 FILE *fp = fopen (potfile, "rb");
11662
11663 if (fp != NULL)
11664 {
11665 while (!feof (fp))
11666 {
11667 char line_buf[BUFSIZ] = { 0 };
11668
11669 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11670
11671 if (ptr == NULL) break;
11672
11673 int line_len = strlen (line_buf);
11674
11675 if (line_len == 0) continue;
11676
11677 int iter = MAX_CUT_TRIES;
11678
11679 for (int i = line_len - 1; i && iter; i--, line_len--)
11680 {
11681 if (line_buf[i] != ':') continue;
11682
11683 if (isSalted)
11684 {
11685 memset (hash_buf.salt, 0, sizeof (salt_t));
11686 }
11687
11688 hash_t *found = NULL;
11689
11690 if (hash_mode == 6800)
11691 {
11692 if (i < 64) // 64 = 16 * uint in salt_buf[]
11693 {
11694 // manipulate salt_buf
11695 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11696
11697 hash_buf.salt->salt_len = i;
11698
11699 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11700 }
11701 }
11702 else if (hash_mode == 2500)
11703 {
11704 if (i < 64) // 64 = 16 * uint in salt_buf[]
11705 {
11706 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11707 // manipulate salt_buf
11708
11709 // to be safe work with a copy (because of line_len loop, i etc)
11710
11711 char line_buf_cpy[BUFSIZ] = { 0 };
11712
11713 memcpy (line_buf_cpy, line_buf, i);
11714
11715 char *mac2_pos = strrchr (line_buf_cpy, ':');
11716
11717 if (mac2_pos == NULL) continue;
11718
11719 mac2_pos[0] = 0;
11720 mac2_pos++;
11721
11722 if (strlen (mac2_pos) != 12) continue;
11723
11724 char *mac1_pos = strrchr (line_buf_cpy, ':');
11725
11726 if (mac1_pos == NULL) continue;
11727
11728 mac1_pos[0] = 0;
11729 mac1_pos++;
11730
11731 if (strlen (mac1_pos) != 12) continue;
11732
11733 uint essid_length = mac1_pos - line_buf_cpy - 1;
11734
11735 // here we need the ESSID
11736 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11737
11738 hash_buf.salt->salt_len = essid_length;
11739
11740 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11741
11742 if (found)
11743 {
11744 wpa_t *wpa = (wpa_t *) found->esalt;
11745
11746 uint pke[25] = { 0 };
11747
11748 char *pke_ptr = (char *) pke;
11749
11750 for (uint i = 0; i < 25; i++)
11751 {
11752 pke[i] = byte_swap_32 (wpa->pke[i]);
11753 }
11754
11755 u8 mac1[6] = { 0 };
11756 u8 mac2[6] = { 0 };
11757
11758 memcpy (mac1, pke_ptr + 23, 6);
11759 memcpy (mac2, pke_ptr + 29, 6);
11760
11761 // compare hex string(s) vs binary MAC address(es)
11762
11763 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11764 {
11765 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11766 {
11767 found = NULL;
11768 break;
11769 }
11770 }
11771
11772 // early skip ;)
11773 if (!found) continue;
11774
11775 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11776 {
11777 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11778 {
11779 found = NULL;
11780 break;
11781 }
11782 }
11783 }
11784 }
11785 }
11786 else
11787 {
11788 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11789
11790 if (parser_status == PARSER_OK)
11791 {
11792 if (isSalted)
11793 {
11794 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11795 }
11796 else
11797 {
11798 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11799 }
11800 }
11801 }
11802
11803 if (found == NULL) continue;
11804
11805 if (!found->cracked) potfile_remove_cracks++;
11806
11807 found->cracked = 1;
11808
11809 if (found) break;
11810
11811 iter--;
11812 }
11813 }
11814
11815 fclose (fp);
11816 }
11817 }
11818
11819 if (esalt_size)
11820 {
11821 local_free (hash_buf.esalt);
11822 }
11823
11824 if (isSalted)
11825 {
11826 local_free (hash_buf.salt);
11827 }
11828
11829 local_free (hash_buf.digest);
11830 }
11831
11832 /**
11833 * Now generate all the buffers required for later
11834 */
11835
11836 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11837
11838 salt_t *salts_buf_new = NULL;
11839 void *esalts_buf_new = NULL;
11840
11841 if (isSalted)
11842 {
11843 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11844
11845 if (esalt_size)
11846 {
11847 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11848 }
11849 }
11850 else
11851 {
11852 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11853 }
11854
11855 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11856
11857 uint digests_cnt = hashes_cnt;
11858 uint digests_done = 0;
11859
11860 uint size_digests = digests_cnt * dgst_size;
11861 uint size_shown = digests_cnt * sizeof (uint);
11862
11863 uint *digests_shown = (uint *) mymalloc (size_shown);
11864 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11865
11866 uint salts_cnt = 0;
11867 uint salts_done = 0;
11868
11869 hashinfo_t **hash_info = NULL;
11870
11871 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11872 {
11873 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11874
11875 if (username && (remove || show))
11876 {
11877 uint user_pos;
11878
11879 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11880 {
11881 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11882
11883 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11884 }
11885 }
11886 }
11887
11888 uint *salts_shown = (uint *) mymalloc (size_shown);
11889
11890 salt_t *salt_buf;
11891
11892 {
11893 // copied from inner loop
11894
11895 salt_buf = &salts_buf_new[salts_cnt];
11896
11897 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11898
11899 if (esalt_size)
11900 {
11901 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11902 }
11903
11904 salt_buf->digests_cnt = 0;
11905 salt_buf->digests_done = 0;
11906 salt_buf->digests_offset = 0;
11907
11908 salts_cnt++;
11909 }
11910
11911 if (hashes_buf[0].cracked == 1)
11912 {
11913 digests_shown[0] = 1;
11914
11915 digests_done++;
11916
11917 salt_buf->digests_done++;
11918 }
11919
11920 salt_buf->digests_cnt++;
11921
11922 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11923
11924 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11925 {
11926 hash_info[0] = hashes_buf[0].hash_info;
11927 }
11928
11929 // copy from inner loop
11930
11931 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11932 {
11933 if (isSalted)
11934 {
11935 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11936 {
11937 salt_buf = &salts_buf_new[salts_cnt];
11938
11939 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11940
11941 if (esalt_size)
11942 {
11943 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11944 }
11945
11946 salt_buf->digests_cnt = 0;
11947 salt_buf->digests_done = 0;
11948 salt_buf->digests_offset = hashes_pos;
11949
11950 salts_cnt++;
11951 }
11952 }
11953
11954 if (hashes_buf[hashes_pos].cracked == 1)
11955 {
11956 digests_shown[hashes_pos] = 1;
11957
11958 digests_done++;
11959
11960 salt_buf->digests_done++;
11961 }
11962
11963 salt_buf->digests_cnt++;
11964
11965 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11966
11967 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11968 {
11969 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11970 }
11971 }
11972
11973 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11974 {
11975 salt_t *salt_buf = &salts_buf_new[salt_pos];
11976
11977 if (salt_buf->digests_done == salt_buf->digests_cnt)
11978 {
11979 salts_shown[salt_pos] = 1;
11980
11981 salts_done++;
11982 }
11983
11984 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11985 }
11986
11987 local_free (digests_buf);
11988 local_free (salts_buf);
11989 local_free (esalts_buf);
11990
11991 digests_buf = digests_buf_new;
11992 salts_buf = salts_buf_new;
11993 esalts_buf = esalts_buf_new;
11994
11995 local_free (hashes_buf);
11996
11997 /**
11998 * special modification not set from parser
11999 */
12000
12001 switch (hash_mode)
12002 {
12003 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12004 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12005 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12006 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12007 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12008 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12009 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12010 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12011 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12012 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12013 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12014 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12015 }
12016
12017 if (truecrypt_keyfiles)
12018 {
12019 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12020
12021 char *keyfiles = strdup (truecrypt_keyfiles);
12022
12023 char *keyfile = strtok (keyfiles, ",");
12024
12025 do
12026 {
12027 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12028
12029 } while ((keyfile = strtok (NULL, ",")) != NULL);
12030
12031 free (keyfiles);
12032 }
12033
12034 data.digests_cnt = digests_cnt;
12035 data.digests_done = digests_done;
12036 data.digests_buf = digests_buf;
12037 data.digests_shown = digests_shown;
12038 data.digests_shown_tmp = digests_shown_tmp;
12039
12040 data.salts_cnt = salts_cnt;
12041 data.salts_done = salts_done;
12042 data.salts_buf = salts_buf;
12043 data.salts_shown = salts_shown;
12044
12045 data.esalts_buf = esalts_buf;
12046 data.hash_info = hash_info;
12047
12048 /**
12049 * Automatic Optimizers
12050 */
12051
12052 if (salts_cnt == 1)
12053 opti_type |= OPTI_TYPE_SINGLE_SALT;
12054
12055 if (digests_cnt == 1)
12056 opti_type |= OPTI_TYPE_SINGLE_HASH;
12057
12058 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12059 opti_type |= OPTI_TYPE_NOT_ITERATED;
12060
12061 if (attack_mode == ATTACK_MODE_BF)
12062 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12063
12064 data.opti_type = opti_type;
12065
12066 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12067 {
12068 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12069 {
12070 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12071 {
12072 if (opts_type & OPTS_TYPE_ST_ADD80)
12073 {
12074 opts_type &= ~OPTS_TYPE_ST_ADD80;
12075 opts_type |= OPTS_TYPE_PT_ADD80;
12076 }
12077
12078 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12079 {
12080 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12081 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12082 }
12083
12084 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12085 {
12086 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12087 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12088 }
12089 }
12090 }
12091 }
12092
12093 /**
12094 * Some algorithm, like descrypt, can benefit from JIT compilation
12095 */
12096
12097 int force_jit_compilation = -1;
12098
12099 if (hash_mode == 8900)
12100 {
12101 force_jit_compilation = 8900;
12102 }
12103 else if (hash_mode == 9300)
12104 {
12105 force_jit_compilation = 8900;
12106 }
12107 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12108 {
12109 force_jit_compilation = 1500;
12110 }
12111
12112 /**
12113 * generate bitmap tables
12114 */
12115
12116 const uint bitmap_shift1 = 5;
12117 const uint bitmap_shift2 = 13;
12118
12119 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12120
12121 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12122 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12123 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12124 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12125 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12126 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12127 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12128 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12129
12130 uint bitmap_bits;
12131 uint bitmap_nums;
12132 uint bitmap_mask;
12133 uint bitmap_size;
12134
12135 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12136 {
12137 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12138
12139 bitmap_nums = 1 << bitmap_bits;
12140
12141 bitmap_mask = bitmap_nums - 1;
12142
12143 bitmap_size = bitmap_nums * sizeof (uint);
12144
12145 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12146
12147 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;
12148 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;
12149
12150 break;
12151 }
12152
12153 bitmap_nums = 1 << bitmap_bits;
12154
12155 bitmap_mask = bitmap_nums - 1;
12156
12157 bitmap_size = bitmap_nums * sizeof (uint);
12158
12159 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);
12160 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);
12161
12162 /**
12163 * prepare quick rule
12164 */
12165
12166 data.rule_buf_l = rule_buf_l;
12167 data.rule_buf_r = rule_buf_r;
12168
12169 int rule_len_l = (int) strlen (rule_buf_l);
12170 int rule_len_r = (int) strlen (rule_buf_r);
12171
12172 data.rule_len_l = rule_len_l;
12173 data.rule_len_r = rule_len_r;
12174
12175 /**
12176 * load rules
12177 */
12178
12179 uint *all_kernel_rules_cnt = NULL;
12180
12181 kernel_rule_t **all_kernel_rules_buf = NULL;
12182
12183 if (rp_files_cnt)
12184 {
12185 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12186
12187 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12188 }
12189
12190 char rule_buf[BUFSIZ] = { 0 };
12191
12192 int rule_len = 0;
12193
12194 for (uint i = 0; i < rp_files_cnt; i++)
12195 {
12196 uint kernel_rules_avail = 0;
12197
12198 uint kernel_rules_cnt = 0;
12199
12200 kernel_rule_t *kernel_rules_buf = NULL;
12201
12202 char *rp_file = rp_files[i];
12203
12204 char in[BLOCK_SIZE] = { 0 };
12205 char out[BLOCK_SIZE] = { 0 };
12206
12207 FILE *fp = NULL;
12208
12209 uint rule_line = 0;
12210
12211 if ((fp = fopen (rp_file, "rb")) == NULL)
12212 {
12213 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12214
12215 return (-1);
12216 }
12217
12218 while (!feof (fp))
12219 {
12220 memset (rule_buf, 0, BUFSIZ);
12221
12222 rule_len = fgetl (fp, rule_buf);
12223
12224 rule_line++;
12225
12226 if (rule_len == 0) continue;
12227
12228 if (rule_buf[0] == '#') continue;
12229
12230 if (kernel_rules_avail == kernel_rules_cnt)
12231 {
12232 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12233
12234 kernel_rules_avail += INCR_RULES;
12235 }
12236
12237 memset (in, 0, BLOCK_SIZE);
12238 memset (out, 0, BLOCK_SIZE);
12239
12240 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12241
12242 if (result == -1)
12243 {
12244 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12245
12246 continue;
12247 }
12248
12249 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12250 {
12251 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12252
12253 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12254
12255 continue;
12256 }
12257
12258 /* its so slow
12259 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12260 {
12261 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12262
12263 continue;
12264 }
12265 */
12266
12267 kernel_rules_cnt++;
12268 }
12269
12270 fclose (fp);
12271
12272 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12273
12274 all_kernel_rules_buf[i] = kernel_rules_buf;
12275 }
12276
12277 /**
12278 * merge rules or automatic rule generator
12279 */
12280
12281 uint kernel_rules_cnt = 0;
12282
12283 kernel_rule_t *kernel_rules_buf = NULL;
12284
12285 if (attack_mode == ATTACK_MODE_STRAIGHT)
12286 {
12287 if (rp_files_cnt)
12288 {
12289 kernel_rules_cnt = 1;
12290
12291 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12292
12293 repeats[0] = kernel_rules_cnt;
12294
12295 for (uint i = 0; i < rp_files_cnt; i++)
12296 {
12297 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12298
12299 repeats[i + 1] = kernel_rules_cnt;
12300 }
12301
12302 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12303
12304 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12305
12306 for (uint i = 0; i < kernel_rules_cnt; i++)
12307 {
12308 uint out_pos = 0;
12309
12310 kernel_rule_t *out = &kernel_rules_buf[i];
12311
12312 for (uint j = 0; j < rp_files_cnt; j++)
12313 {
12314 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12315 uint in_pos;
12316
12317 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12318
12319 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12320 {
12321 if (out_pos == RULES_MAX - 1)
12322 {
12323 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12324
12325 break;
12326 }
12327
12328 out->cmds[out_pos] = in->cmds[in_pos];
12329 }
12330 }
12331 }
12332
12333 local_free (repeats);
12334 }
12335 else if (rp_gen)
12336 {
12337 uint kernel_rules_avail = 0;
12338
12339 while (kernel_rules_cnt < rp_gen)
12340 {
12341 if (kernel_rules_avail == kernel_rules_cnt)
12342 {
12343 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12344
12345 kernel_rules_avail += INCR_RULES;
12346 }
12347
12348 memset (rule_buf, 0, BLOCK_SIZE);
12349
12350 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12351
12352 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12353
12354 kernel_rules_cnt++;
12355 }
12356 }
12357 }
12358
12359 /**
12360 * generate NOP rules
12361 */
12362
12363 if (kernel_rules_cnt == 0)
12364 {
12365 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12366
12367 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12368
12369 kernel_rules_cnt++;
12370 }
12371
12372 data.kernel_rules_cnt = kernel_rules_cnt;
12373 data.kernel_rules_buf = kernel_rules_buf;
12374
12375 /**
12376 * OpenCL platforms: detect
12377 */
12378
12379 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12380 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12381
12382 cl_uint platforms_cnt = 0;
12383 cl_uint platform_devices_cnt = 0;
12384
12385 if (keyspace == 0)
12386 {
12387 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12388
12389 if (platforms_cnt == 0)
12390 {
12391 log_error ("ERROR: No OpenCL compatible platform found");
12392
12393 return (-1);
12394 }
12395 }
12396
12397 /**
12398 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12399 */
12400
12401 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12402 {
12403 cl_platform_id platform = platforms[platform_id];
12404
12405 char platform_vendor[INFOSZ] = { 0 };
12406
12407 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12408
12409 #ifdef HAVE_HWMON
12410 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12411 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12412 {
12413 // make sure that we do not directly control the fan for NVidia
12414
12415 gpu_temp_retain = 0;
12416
12417 data.gpu_temp_retain = gpu_temp_retain;
12418 }
12419 #endif // HAVE_NVML || HAVE_NVAPI
12420 #endif
12421 }
12422
12423 /**
12424 * OpenCL devices: simply push all devices from all platforms into the same device array
12425 */
12426
12427 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12428
12429 data.devices_param = devices_param;
12430
12431 uint devices_cnt = 0;
12432
12433 uint devices_active = 0;
12434
12435 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12436 {
12437 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12438
12439 cl_platform_id platform = platforms[platform_id];
12440
12441 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12442
12443 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12444 {
12445 size_t param_value_size = 0;
12446
12447 const uint device_id = devices_cnt;
12448
12449 hc_device_param_t *device_param = &data.devices_param[device_id];
12450
12451 device_param->device = platform_devices[platform_devices_id];
12452
12453 device_param->device_id = device_id;
12454
12455 device_param->platform_devices_id = platform_devices_id;
12456
12457 // device_type
12458
12459 cl_device_type device_type;
12460
12461 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12462
12463 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12464
12465 device_param->device_type = device_type;
12466
12467 // vendor_id
12468
12469 cl_uint vendor_id = 0;
12470
12471 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12472
12473 device_param->vendor_id = vendor_id;
12474
12475 // device_name
12476
12477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12478
12479 char *device_name = (char *) mymalloc (param_value_size);
12480
12481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12482
12483 device_param->device_name = device_name;
12484
12485 // tuning db
12486
12487 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode, workload_profile);
12488
12489 // device_version
12490
12491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12492
12493 char *device_version = (char *) mymalloc (param_value_size);
12494
12495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12496
12497 device_param->device_version = device_version;
12498
12499 // device_opencl_version
12500
12501 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12502
12503 char *device_opencl_version = (char *) mymalloc (param_value_size);
12504
12505 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12506
12507 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12508
12509 myfree (device_opencl_version);
12510
12511 if (strstr (device_version, "pocl"))
12512 {
12513 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12514 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12515
12516 cl_uint vendor_id = VENDOR_ID_GENERIC;
12517
12518 device_param->vendor_id = vendor_id;
12519 }
12520
12521 // vector_width
12522
12523 cl_uint vector_width;
12524
12525 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12526 {
12527 if (tuningdb_entry->vector_width == -1)
12528 {
12529 if (opti_type & OPTI_TYPE_USES_BITS_64)
12530 {
12531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12532 } else {
12533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12534 }
12535 }
12536 else
12537 {
12538 vector_width = (cl_uint) tuningdb_entry->vector_width;
12539 }
12540 }
12541 else
12542 {
12543 vector_width = opencl_vector_width;
12544 }
12545
12546 if (vector_width > 8) vector_width = 8;
12547
12548 device_param->vector_width = vector_width;
12549
12550 // max_compute_units
12551
12552 cl_uint device_processors;
12553
12554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12555
12556 device_param->device_processors = device_processors;
12557
12558 // max_mem_alloc_size
12559
12560 cl_ulong device_maxmem_alloc;
12561
12562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12563
12564 device_param->device_maxmem_alloc = device_maxmem_alloc;
12565
12566 // max_mem_alloc_size
12567
12568 cl_ulong device_global_mem;
12569
12570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12571
12572 device_param->device_global_mem = device_global_mem;
12573
12574 // max_clock_frequency
12575
12576 cl_uint device_maxclock_frequency;
12577
12578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12579
12580 device_param->device_maxclock_frequency = device_maxclock_frequency;
12581
12582 // skipped
12583
12584 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12585 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12586
12587 device_param->skipped = (skipped1 || skipped2);
12588
12589 // driver_version
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12591
12592 char *driver_version = (char *) mymalloc (param_value_size);
12593
12594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12595
12596 device_param->driver_version = driver_version;
12597
12598 // device_name_chksum
12599
12600 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12601
12602 #if __x86_64__
12603 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);
12604 #else
12605 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);
12606 #endif
12607
12608 uint device_name_digest[4] = { 0 };
12609
12610 md5_64 ((uint *) device_name_chksum, device_name_digest);
12611
12612 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12613
12614 device_param->device_name_chksum = device_name_chksum;
12615
12616 // device_processor_cores
12617
12618 if (device_type & CL_DEVICE_TYPE_CPU)
12619 {
12620 cl_uint device_processor_cores = 1;
12621
12622 device_param->device_processor_cores = device_processor_cores;
12623 }
12624
12625 if (device_type & CL_DEVICE_TYPE_GPU)
12626 {
12627 if (vendor_id == VENDOR_ID_AMD)
12628 {
12629 cl_uint device_processor_cores = 0;
12630
12631 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12632
12633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12634
12635 device_param->device_processor_cores = device_processor_cores;
12636 }
12637 else if (vendor_id == VENDOR_ID_NV)
12638 {
12639 cl_uint kernel_exec_timeout = 0;
12640
12641 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12642
12643 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12644
12645 device_param->kernel_exec_timeout = kernel_exec_timeout;
12646
12647 cl_uint device_processor_cores = 0;
12648
12649 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12650
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12652
12653 device_param->device_processor_cores = device_processor_cores;
12654
12655 cl_uint sm_minor = 0;
12656 cl_uint sm_major = 0;
12657
12658 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12659 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12660
12661 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12662 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12663
12664 device_param->sm_minor = sm_minor;
12665 device_param->sm_major = sm_major;
12666 }
12667 else
12668 {
12669 cl_uint device_processor_cores = 1;
12670
12671 device_param->device_processor_cores = device_processor_cores;
12672 }
12673 }
12674
12675 // display results
12676
12677 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12678 {
12679 if (device_param->skipped == 0)
12680 {
12681 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12682 device_id + 1,
12683 device_name,
12684 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12685 (unsigned int) (device_global_mem / 1024 / 1024),
12686 (unsigned int) (device_maxclock_frequency),
12687 (unsigned int) device_processors);
12688 }
12689 else
12690 {
12691 log_info ("Device #%u: %s, skipped",
12692 device_id + 1,
12693 device_name);
12694 }
12695 }
12696
12697 // common driver check
12698
12699 if (device_param->skipped == 0)
12700 {
12701 if (strstr (device_version, "pocl"))
12702 {
12703 if (force == 0)
12704 {
12705 log_info ("");
12706 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12707 log_info ("You are STRONGLY encouraged not to use it");
12708 log_info ("You can use --force to override this but do not post error reports if you do so");
12709 log_info ("");
12710
12711 return (-1);
12712 }
12713 }
12714
12715 if (device_type & CL_DEVICE_TYPE_GPU)
12716 {
12717 if (vendor_id == VENDOR_ID_NV)
12718 {
12719 if (device_param->kernel_exec_timeout != 0)
12720 {
12721 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);
12722 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12723 }
12724 }
12725 else if (vendor_id == VENDOR_ID_AMD)
12726 {
12727 int catalyst_check = (force == 1) ? 0 : 1;
12728
12729 int catalyst_warn = 0;
12730
12731 int catalyst_broken = 0;
12732
12733 if (catalyst_check == 1)
12734 {
12735 catalyst_warn = 1;
12736
12737 // v14.9 and higher
12738 if (atoi (device_param->driver_version) >= 1573)
12739 {
12740 catalyst_warn = 0;
12741 }
12742
12743 catalyst_check = 0;
12744 }
12745
12746 if (catalyst_broken == 1)
12747 {
12748 log_info ("");
12749 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12750 log_info ("It will pass over cracked hashes and does not report them as cracked");
12751 log_info ("You are STRONGLY encouraged not to use it");
12752 log_info ("You can use --force to override this but do not post error reports if you do so");
12753 log_info ("");
12754
12755 return (-1);
12756 }
12757
12758 if (catalyst_warn == 1)
12759 {
12760 log_info ("");
12761 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12762 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12763 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12764 #ifdef _WIN
12765 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12766 #endif
12767 log_info ("You can use --force to override this but do not post error reports if you do so");
12768 log_info ("");
12769
12770 return (-1);
12771 }
12772 }
12773 }
12774
12775 /**
12776 * kernel accel and loops auto adjustment
12777 */
12778
12779 uint _kernel_accel = kernel_accel;
12780 uint _kernel_loops = kernel_loops;
12781
12782 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode, workload_profile);
12783
12784 if (kernel_accel_chgd == 0)
12785 {
12786 _kernel_accel = tuningdb_entry->kernel_accel;
12787 }
12788
12789 if (kernel_loops_chgd == 0)
12790 {
12791 _kernel_loops = tuningdb_entry->kernel_loops;
12792 }
12793
12794 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
12795 {
12796 _kernel_loops = 1024;
12797 }
12798
12799 if (hash_mode == 12500)
12800 {
12801 _kernel_loops = ROUNDS_RAR3 / 16;
12802 }
12803
12804 device_param->kernel_accel = _kernel_accel;
12805 device_param->kernel_loops = _kernel_loops;
12806
12807 devices_active++;
12808 }
12809
12810 // next please
12811
12812 devices_cnt++;
12813 }
12814 }
12815
12816 if (keyspace == 0 && devices_active == 0)
12817 {
12818 log_error ("ERROR: No devices found/left");
12819
12820 return (-1);
12821 }
12822
12823 data.devices_cnt = devices_cnt;
12824
12825 data.devices_active = devices_active;
12826
12827 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12828 {
12829 log_info ("");
12830 }
12831
12832 /**
12833 * HM devices: init
12834 */
12835
12836 #ifdef HAVE_HWMON
12837 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12838 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12839 #endif
12840
12841 #ifdef HAVE_ADL
12842 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12843 #endif
12844
12845 if (gpu_temp_disable == 0)
12846 {
12847 #if defined(WIN) && defined(HAVE_NVAPI)
12848 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12849
12850 if (nvapi_init (nvapi) == 0)
12851 data.hm_nv = nvapi;
12852
12853 if (data.hm_nv)
12854 {
12855 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12856 {
12857 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12858
12859 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12860
12861 int tmp_out = 0;
12862
12863 for (int i = 0; i < tmp_in; i++)
12864 {
12865 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12866 }
12867
12868 for (int i = 0; i < tmp_out; i++)
12869 {
12870 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12871
12872 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12873
12874 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12875 }
12876 }
12877 }
12878 #endif // WIN && HAVE_NVAPI
12879
12880 #if defined(LINUX) && defined(HAVE_NVML)
12881 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12882
12883 if (nvml_init (nvml) == 0)
12884 data.hm_nv = nvml;
12885
12886 if (data.hm_nv)
12887 {
12888 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12889 {
12890 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12891
12892 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12893
12894 int tmp_out = 0;
12895
12896 for (int i = 0; i < tmp_in; i++)
12897 {
12898 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12899 }
12900
12901 for (int i = 0; i < tmp_out; i++)
12902 {
12903 unsigned int speed;
12904
12905 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12906 }
12907 }
12908 }
12909 #endif // LINUX && HAVE_NVML
12910
12911 data.hm_amd = NULL;
12912
12913 #ifdef HAVE_ADL
12914 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
12915
12916 if (adl_init (adl) == 0)
12917 data.hm_amd = adl;
12918
12919 if (data.hm_amd)
12920 {
12921 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12922 {
12923 // total number of adapters
12924
12925 int hm_adapters_num;
12926
12927 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
12928
12929 // adapter info
12930
12931 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
12932
12933 if (lpAdapterInfo == NULL) return (-1);
12934
12935 // get a list (of ids of) valid/usable adapters
12936
12937 int num_adl_adapters = 0;
12938
12939 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12940
12941 if (num_adl_adapters > 0)
12942 {
12943 hc_thread_mutex_lock (mux_adl);
12944
12945 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12946
12947 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12948
12949 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12950 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12951
12952 hc_thread_mutex_unlock (mux_adl);
12953 }
12954
12955 myfree (valid_adl_device_list);
12956 myfree (lpAdapterInfo);
12957 }
12958 }
12959 #endif // HAVE_ADL
12960
12961 if (data.hm_amd == NULL && data.hm_nv == NULL)
12962 {
12963 gpu_temp_disable = 1;
12964 }
12965 }
12966
12967 /**
12968 * OpenCL devices: allocate buffer for device specific information
12969 */
12970
12971 #ifdef HAVE_HWMON
12972 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
12973
12974 #ifdef HAVE_ADL
12975 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
12976
12977 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
12978 #endif // ADL
12979 #endif
12980
12981 /**
12982 * enable custom signal handler(s)
12983 */
12984
12985 if (benchmark == 0)
12986 {
12987 hc_signal (sigHandler_default);
12988 }
12989 else
12990 {
12991 hc_signal (sigHandler_benchmark);
12992 }
12993
12994 /**
12995 * User-defined GPU temp handling
12996 */
12997
12998 #ifdef HAVE_HWMON
12999 if (gpu_temp_disable == 1)
13000 {
13001 gpu_temp_abort = 0;
13002 gpu_temp_retain = 0;
13003 }
13004
13005 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13006 {
13007 if (gpu_temp_abort < gpu_temp_retain)
13008 {
13009 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13010
13011 return (-1);
13012 }
13013 }
13014
13015 data.gpu_temp_disable = gpu_temp_disable;
13016 data.gpu_temp_abort = gpu_temp_abort;
13017 data.gpu_temp_retain = gpu_temp_retain;
13018 #endif
13019
13020 /**
13021 * inform the user
13022 */
13023
13024 if (data.quiet == 0)
13025 {
13026 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13027
13028 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);
13029
13030 if (attack_mode == ATTACK_MODE_STRAIGHT)
13031 {
13032 log_info ("Rules: %u", kernel_rules_cnt);
13033 }
13034
13035 if (opti_type)
13036 {
13037 log_info ("Applicable Optimizers:");
13038
13039 for (uint i = 0; i < 32; i++)
13040 {
13041 const uint opti_bit = 1u << i;
13042
13043 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13044 }
13045 }
13046
13047 /**
13048 * Watchdog and Temperature balance
13049 */
13050
13051 #ifdef HAVE_HWMON
13052 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13053 {
13054 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13055 }
13056
13057 if (gpu_temp_abort == 0)
13058 {
13059 log_info ("Watchdog: Temperature abort trigger disabled");
13060 }
13061 else
13062 {
13063 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13064 }
13065
13066 if (gpu_temp_retain == 0)
13067 {
13068 log_info ("Watchdog: Temperature retain trigger disabled");
13069 }
13070 else
13071 {
13072 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13073 }
13074 #endif
13075 }
13076
13077 if (data.quiet == 0) log_info ("");
13078
13079 /**
13080 * HM devices: copy
13081 */
13082
13083 if (gpu_temp_disable == 0)
13084 {
13085 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13086 {
13087 hc_device_param_t *device_param = &data.devices_param[device_id];
13088
13089 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13090
13091 if (device_param->skipped) continue;
13092
13093 const uint platform_devices_id = device_param->platform_devices_id;
13094
13095 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13096 if (device_param->vendor_id == VENDOR_ID_NV)
13097 {
13098 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13099 }
13100 #endif
13101
13102 #ifdef HAVE_ADL
13103 if (device_param->vendor_id == VENDOR_ID_AMD)
13104 {
13105 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13106 }
13107 #endif
13108 }
13109 }
13110
13111 /*
13112 * Temporary fix:
13113 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13114 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13115 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13116 * Driver / ADL bug?
13117 */
13118
13119 #ifdef HAVE_ADL
13120 if (powertune_enable == 1)
13121 {
13122 hc_thread_mutex_lock (mux_adl);
13123
13124 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13125 {
13126 hc_device_param_t *device_param = &data.devices_param[device_id];
13127
13128 if (device_param->skipped) continue;
13129
13130 if (data.hm_device[device_id].od_version == 6)
13131 {
13132 // set powertune value only
13133
13134 int powertune_supported = 0;
13135
13136 int ADL_rc = 0;
13137
13138 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13139 {
13140 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13141
13142 return (-1);
13143 }
13144
13145 if (powertune_supported != 0)
13146 {
13147 // powertune set
13148 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13149
13150 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13151 {
13152 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13153
13154 return (-1);
13155 }
13156
13157 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13158 {
13159 log_error ("ERROR: Failed to set new ADL PowerControl values");
13160
13161 return (-1);
13162 }
13163 }
13164 }
13165 }
13166
13167 hc_thread_mutex_unlock (mux_adl);
13168 }
13169 #endif // HAVE_ADK
13170 #endif // HAVE_HWMON
13171
13172 #ifdef OSX
13173 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13174 {
13175 if (force == 0)
13176 {
13177 log_info ("");
13178 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13179 log_info ("You can use --force to override this but do not post error reports if you do so");
13180 log_info ("");
13181
13182 continue;
13183 }
13184 }
13185 #endif
13186
13187 #ifdef DEBUG
13188 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13189 #endif
13190
13191 uint kernel_blocks_all = 0;
13192
13193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13194 {
13195 /**
13196 * host buffer
13197 */
13198
13199 hc_device_param_t *device_param = &data.devices_param[device_id];
13200
13201 if (device_param->skipped) continue;
13202
13203 /**
13204 * device properties
13205 */
13206
13207 char *device_name_chksum = device_param->device_name_chksum;
13208
13209 uint device_processors = device_param->device_processors;
13210
13211 uint device_processor_cores = device_param->device_processor_cores;
13212
13213 uint kernel_accel = device_param->kernel_accel;
13214
13215 /**
13216 * create context for each device
13217 */
13218
13219 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13220
13221 /**
13222 * create command-queue
13223 */
13224
13225 // not supported with NV
13226 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13227
13228 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13229
13230 /**
13231 * create input buffers on device
13232 */
13233
13234 uint kernel_threads = KERNEL_THREADS;
13235
13236 // bcrypt
13237 if (hash_mode == 3200) kernel_threads = 8;
13238 if (hash_mode == 9000) kernel_threads = 8;
13239
13240 uint kernel_power = 1;
13241 uint kernel_blocks = 1;
13242
13243 uint size_pws = 4;
13244 uint size_tmps = 4;
13245 uint size_hooks = 4;
13246
13247 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13248
13249 while (kernel_accel)
13250 {
13251 kernel_power = device_processors * kernel_threads * kernel_accel;
13252 kernel_blocks = kernel_power;
13253
13254 // size_pws
13255
13256 size_pws = kernel_blocks * sizeof (pw_t);
13257
13258 // size_tmps
13259
13260 switch (hash_mode)
13261 {
13262 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13263 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13264 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13265 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13266 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13267 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13268 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13269 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13270 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13271 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13272 case 6211:
13273 case 6212:
13274 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13275 case 6221:
13276 case 6222:
13277 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13278 case 6231:
13279 case 6232:
13280 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13281 case 6241:
13282 case 6242:
13283 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13284 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13285 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13286 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13287 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13288 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13289 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13290 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13291 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13292 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13293 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13294 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13295 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13296 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13297 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13298 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13299 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13300 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13301 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13302 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13303 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13304 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13305 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13306 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13307 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13308 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13309 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13310 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13311 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13312 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13313 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13314 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13315 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13316 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13317 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13318 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13319 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13320 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13321 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13322 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13323 };
13324
13325 // size_hooks
13326
13327 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13328 {
13329 // none yet
13330 }
13331
13332 // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
13333 // if not, decrease amplifier and try again
13334
13335 if (size_pws > device_param->device_maxmem_alloc)
13336 {
13337 kernel_accel--;
13338
13339 continue;
13340 }
13341
13342 if (size_tmps > device_param->device_maxmem_alloc)
13343 {
13344 kernel_accel--;
13345
13346 continue;
13347 }
13348
13349 if (size_hooks > device_param->device_maxmem_alloc)
13350 {
13351 kernel_accel--;
13352
13353 continue;
13354 }
13355
13356 if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
13357 {
13358 kernel_accel--;
13359
13360 continue;
13361 }
13362
13363 break;
13364 }
13365
13366 if (kernel_accel == 0)
13367 {
13368 log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13369
13370 return -1;
13371 }
13372
13373 device_param->kernel_threads = kernel_threads;
13374 device_param->kernel_power_user = kernel_power;
13375 device_param->kernel_blocks_user = kernel_blocks;
13376
13377 kernel_blocks_all += kernel_blocks;
13378
13379 device_param->size_pws = size_pws;
13380 device_param->size_tmps = size_tmps;
13381 device_param->size_hooks = size_hooks;
13382
13383 // we can optimize some stuff here...
13384
13385 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13386 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13387
13388 device_param->size_root_css = size_root_css;
13389 device_param->size_markov_css = size_markov_css;
13390
13391 uint size_results = KERNEL_THREADS * sizeof (uint);
13392
13393 device_param->size_results = size_results;
13394
13395 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13396 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13397
13398 uint size_plains = digests_cnt * sizeof (plain_t);
13399 uint size_salts = salts_cnt * sizeof (salt_t);
13400 uint size_esalts = salts_cnt * esalt_size;
13401
13402 device_param->size_plains = size_plains;
13403 device_param->size_digests = size_digests;
13404 device_param->size_shown = size_shown;
13405 device_param->size_salts = size_salts;
13406
13407 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13408 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13409 uint size_tm = 32 * sizeof (bs_word_t);
13410
13411 // scrypt stuff
13412
13413 u64 size_scryptV = 1;
13414
13415 if ((hash_mode == 8900) || (hash_mode == 9300))
13416 {
13417 uint tmto_start = 0;
13418 uint tmto_stop = 10;
13419
13420 if (scrypt_tmto)
13421 {
13422 tmto_start = scrypt_tmto;
13423 }
13424 else
13425 {
13426 // in case the user did not specify the tmto manually
13427 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13428 // but set the lower end only in case the user has a device with too less memory
13429
13430 if (hash_mode == 8900)
13431 {
13432 if (device_param->vendor_id == VENDOR_ID_AMD)
13433 {
13434 tmto_start = 1;
13435 }
13436 else if (device_param->vendor_id == VENDOR_ID_NV)
13437 {
13438 tmto_start = 3;
13439 }
13440 }
13441 else if (hash_mode == 9300)
13442 {
13443 if (device_param->vendor_id == VENDOR_ID_AMD)
13444 {
13445 tmto_start = 3;
13446 }
13447 else if (device_param->vendor_id == VENDOR_ID_NV)
13448 {
13449 tmto_start = 5;
13450 }
13451 }
13452 }
13453
13454 if (quiet == 0) log_info ("");
13455
13456 uint shader_per_mp = 1;
13457
13458 if (device_param->vendor_id == VENDOR_ID_AMD)
13459 {
13460 shader_per_mp = 8;
13461 }
13462 else if (device_param->vendor_id == VENDOR_ID_NV)
13463 {
13464 shader_per_mp = 32;
13465 }
13466
13467 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13468 {
13469 // TODO: in theory the following calculation needs to be done per salt, not global
13470 // we assume all hashes have the same scrypt settings
13471
13472 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13473
13474 size_scryptV /= 1 << tmto;
13475
13476 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13477
13478 if (size_scryptV > device_param->device_maxmem_alloc)
13479 {
13480 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13481
13482 continue;
13483 }
13484
13485 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13486 {
13487 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13488 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13489 }
13490
13491 break;
13492 }
13493
13494 if (data.salts_buf[0].scrypt_phy == 0)
13495 {
13496 log_error ("ERROR: can't allocate enough device memory");
13497
13498 return -1;
13499 }
13500
13501 if (quiet == 0) log_info ("");
13502 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13503 }
13504
13505 /**
13506 * default building options
13507 */
13508
13509 char build_opts[1024] = { 0 };
13510
13511 // we don't have sm_* on vendors not NV but it doesn't matter
13512
13513 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -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);
13514
13515 /**
13516 * main kernel
13517 */
13518
13519 {
13520 /**
13521 * kernel source filename
13522 */
13523
13524 char source_file[256] = { 0 };
13525
13526 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13527
13528 struct stat sst;
13529
13530 if (stat (source_file, &sst) == -1)
13531 {
13532 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13533
13534 return -1;
13535 }
13536
13537 /**
13538 * kernel cached filename
13539 */
13540
13541 char cached_file[256] = { 0 };
13542
13543 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13544
13545 int cached = 1;
13546
13547 struct stat cst;
13548
13549 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13550 {
13551 cached = 0;
13552 }
13553
13554 /**
13555 * kernel compile or load
13556 */
13557
13558 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13559
13560 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13561
13562 if (force_jit_compilation == -1)
13563 {
13564 if (cached == 0)
13565 {
13566 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13567
13568 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13569
13570 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13571
13572 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13573
13574 if (rc != 0)
13575 {
13576 device_param->skipped = true;
13577 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13578 continue;
13579 }
13580
13581 size_t binary_size;
13582
13583 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13584
13585 u8 *binary = (u8 *) mymalloc (binary_size);
13586
13587 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13588
13589 writeProgramBin (cached_file, binary, binary_size);
13590
13591 local_free (binary);
13592 }
13593 else
13594 {
13595 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13596
13597 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13598
13599 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13600
13601 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13602 }
13603 }
13604 else
13605 {
13606 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13607
13608 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13609
13610 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13611
13612 char build_opts_update[1024] = { 0 };
13613
13614 if (force_jit_compilation == 1500)
13615 {
13616 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13617 }
13618 else if (force_jit_compilation == 8900)
13619 {
13620 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
13621 }
13622
13623 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13624
13625 if (rc != 0)
13626 {
13627 device_param->skipped = true;
13628 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13629 }
13630 }
13631
13632 local_free (kernel_lengths);
13633 local_free (kernel_sources[0]);
13634 local_free (kernel_sources);
13635 }
13636
13637 /**
13638 * word generator kernel
13639 */
13640
13641 if (attack_mode != ATTACK_MODE_STRAIGHT)
13642 {
13643 /**
13644 * kernel mp source filename
13645 */
13646
13647 char source_file[256] = { 0 };
13648
13649 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13650
13651 struct stat sst;
13652
13653 if (stat (source_file, &sst) == -1)
13654 {
13655 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13656
13657 return -1;
13658 }
13659
13660 /**
13661 * kernel mp cached filename
13662 */
13663
13664 char cached_file[256] = { 0 };
13665
13666 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13667
13668 int cached = 1;
13669
13670 struct stat cst;
13671
13672 if (stat (cached_file, &cst) == -1)
13673 {
13674 cached = 0;
13675 }
13676
13677 /**
13678 * kernel compile or load
13679 */
13680
13681 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13682
13683 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13684
13685 if (cached == 0)
13686 {
13687 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13688
13689 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13690
13691 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13692
13693 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13694
13695 if (rc != 0)
13696 {
13697 device_param->skipped = true;
13698 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13699 continue;
13700 }
13701
13702 size_t binary_size;
13703
13704 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13705
13706 u8 *binary = (u8 *) mymalloc (binary_size);
13707
13708 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13709
13710 writeProgramBin (cached_file, binary, binary_size);
13711
13712 local_free (binary);
13713 }
13714 else
13715 {
13716 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13717
13718 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13719
13720 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13721
13722 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13723 }
13724
13725 local_free (kernel_lengths);
13726 local_free (kernel_sources[0]);
13727 local_free (kernel_sources);
13728 }
13729
13730 /**
13731 * amplifier kernel
13732 */
13733
13734 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13735 {
13736
13737 }
13738 else
13739 {
13740 /**
13741 * kernel amp source filename
13742 */
13743
13744 char source_file[256] = { 0 };
13745
13746 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13747
13748 struct stat sst;
13749
13750 if (stat (source_file, &sst) == -1)
13751 {
13752 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13753
13754 return -1;
13755 }
13756
13757 /**
13758 * kernel amp cached filename
13759 */
13760
13761 char cached_file[256] = { 0 };
13762
13763 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13764
13765 int cached = 1;
13766
13767 struct stat cst;
13768
13769 if (stat (cached_file, &cst) == -1)
13770 {
13771 cached = 0;
13772 }
13773
13774 /**
13775 * kernel compile or load
13776 */
13777
13778 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13779
13780 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13781
13782 if (cached == 0)
13783 {
13784 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13785
13786 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13787
13788 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13789
13790 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13791
13792 if (rc != 0)
13793 {
13794 device_param->skipped = true;
13795 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13796 continue;
13797 }
13798
13799 size_t binary_size;
13800
13801 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13802
13803 u8 *binary = (u8 *) mymalloc (binary_size);
13804
13805 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13806
13807 writeProgramBin (cached_file, binary, binary_size);
13808
13809 local_free (binary);
13810 }
13811 else
13812 {
13813 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13814
13815 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13816
13817 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13818
13819 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
13820 }
13821
13822 local_free (kernel_lengths);
13823 local_free (kernel_sources[0]);
13824 local_free (kernel_sources);
13825 }
13826
13827 // some algorithm collide too fast, make that impossible
13828
13829 if (benchmark == 1)
13830 {
13831 ((uint *) digests_buf)[0] = -1;
13832 ((uint *) digests_buf)[1] = -1;
13833 ((uint *) digests_buf)[2] = -1;
13834 ((uint *) digests_buf)[3] = -1;
13835 }
13836
13837 /**
13838 * global buffers
13839 */
13840
13841 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13842 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13843 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13844 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13845 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13846 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13847 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13848 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13849 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13850 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13851 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13852 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13853 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13854 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13855 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13856 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13857 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13858 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13859
13860 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13861 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13862 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13863 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13864 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13865 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13866 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13867 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13868 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13869 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13870 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13871
13872 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13873 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13874 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13875 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13876 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13877 run_kernel_bzero (device_param, device_param->d_result, size_results);
13878
13879 /**
13880 * special buffers
13881 */
13882
13883 if (attack_kern == ATTACK_KERN_STRAIGHT)
13884 {
13885 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13886 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13887
13888 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13889
13890 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13891 }
13892 else if (attack_kern == ATTACK_KERN_COMBI)
13893 {
13894 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13895 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13896 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13897 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13898
13899 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13900 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13901 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13902 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13903 }
13904 else if (attack_kern == ATTACK_KERN_BF)
13905 {
13906 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13907 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13908 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13909 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13910 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13911
13912 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13913 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13914 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13915 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13916 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13917 }
13918
13919 if (size_esalts)
13920 {
13921 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13922
13923 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13924 }
13925
13926 /**
13927 * main host data
13928 */
13929
13930 uint *result = (uint *) mymalloc (size_results);
13931
13932 device_param->result = result;
13933
13934 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13935
13936 device_param->pws_buf = pws_buf;
13937
13938 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13939
13940 for (int i = 0; i < 64; i++)
13941 {
13942 pw_caches[i].pw_buf.pw_len = i;
13943 pw_caches[i].cnt = 0;
13944 }
13945
13946 device_param->pw_caches = pw_caches;
13947
13948 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13949
13950 device_param->combs_buf = combs_buf;
13951
13952 void *hooks_buf = mymalloc (size_hooks);
13953
13954 device_param->hooks_buf = hooks_buf;
13955
13956 device_param->pw_transpose = pw_transpose_to_hi1;
13957 device_param->pw_add = pw_add_to_hc1;
13958
13959 /**
13960 * kernel args
13961 */
13962
13963 device_param->kernel_params_buf32[21] = bitmap_mask;
13964 device_param->kernel_params_buf32[22] = bitmap_shift1;
13965 device_param->kernel_params_buf32[23] = bitmap_shift2;
13966 device_param->kernel_params_buf32[24] = 0; // salt_pos
13967 device_param->kernel_params_buf32[25] = 0; // loop_pos
13968 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13969 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13970 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13971 device_param->kernel_params_buf32[29] = 0; // digests_offset
13972 device_param->kernel_params_buf32[30] = 0; // combs_mode
13973 device_param->kernel_params_buf32[31] = 0; // gid_max
13974
13975 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13976 ? &device_param->d_pws_buf
13977 : &device_param->d_pws_amp_buf;
13978 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13979 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13980 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13981 device_param->kernel_params[ 4] = &device_param->d_tmps;
13982 device_param->kernel_params[ 5] = &device_param->d_hooks;
13983 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13984 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13985 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13986 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13987 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13988 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13989 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13990 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13991 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13992 device_param->kernel_params[15] = &device_param->d_digests_buf;
13993 device_param->kernel_params[16] = &device_param->d_digests_shown;
13994 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13995 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13996 device_param->kernel_params[19] = &device_param->d_result;
13997 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13998 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13999 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14000 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14001 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14002 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14003 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14004 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14005 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14006 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14007 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14008 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14009
14010 device_param->kernel_params_mp_buf64[3] = 0;
14011 device_param->kernel_params_mp_buf32[4] = 0;
14012 device_param->kernel_params_mp_buf32[5] = 0;
14013 device_param->kernel_params_mp_buf32[6] = 0;
14014 device_param->kernel_params_mp_buf32[7] = 0;
14015 device_param->kernel_params_mp_buf32[8] = 0;
14016
14017 device_param->kernel_params_mp[0] = NULL;
14018 device_param->kernel_params_mp[1] = NULL;
14019 device_param->kernel_params_mp[2] = NULL;
14020 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14021 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14022 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14023 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14024 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14025 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14026
14027 device_param->kernel_params_mp_l_buf64[3] = 0;
14028 device_param->kernel_params_mp_l_buf32[4] = 0;
14029 device_param->kernel_params_mp_l_buf32[5] = 0;
14030 device_param->kernel_params_mp_l_buf32[6] = 0;
14031 device_param->kernel_params_mp_l_buf32[7] = 0;
14032 device_param->kernel_params_mp_l_buf32[8] = 0;
14033 device_param->kernel_params_mp_l_buf32[9] = 0;
14034
14035 device_param->kernel_params_mp_l[0] = NULL;
14036 device_param->kernel_params_mp_l[1] = NULL;
14037 device_param->kernel_params_mp_l[2] = NULL;
14038 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14039 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14040 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14041 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14042 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14043 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14044 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14045
14046 device_param->kernel_params_mp_r_buf64[3] = 0;
14047 device_param->kernel_params_mp_r_buf32[4] = 0;
14048 device_param->kernel_params_mp_r_buf32[5] = 0;
14049 device_param->kernel_params_mp_r_buf32[6] = 0;
14050 device_param->kernel_params_mp_r_buf32[7] = 0;
14051 device_param->kernel_params_mp_r_buf32[8] = 0;
14052
14053 device_param->kernel_params_mp_r[0] = NULL;
14054 device_param->kernel_params_mp_r[1] = NULL;
14055 device_param->kernel_params_mp_r[2] = NULL;
14056 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14057 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14058 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14059 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14060 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14061 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14062
14063 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14064 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14065
14066 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14067 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14068 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14069 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14070 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14071 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14072 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14073
14074 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14075
14076 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14077 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14078
14079 /**
14080 * kernel name
14081 */
14082
14083 char kernel_name[64] = { 0 };
14084
14085 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14086 {
14087 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14088 {
14089 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14090
14091 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14092
14093 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14094
14095 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14096
14097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14098
14099 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14100 }
14101 else
14102 {
14103 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14104
14105 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14106
14107 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14108
14109 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14110
14111 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14112
14113 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14114 }
14115
14116 if (data.attack_mode == ATTACK_MODE_BF)
14117 {
14118 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14119 {
14120 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14121
14122 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14123
14124 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14125
14126 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14127 }
14128 }
14129 }
14130 else
14131 {
14132 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14133
14134 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14135
14136 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14137
14138 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14139
14140 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14141
14142 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14143
14144 if (opts_type & OPTS_TYPE_HOOK12)
14145 {
14146 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14147
14148 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14149 }
14150
14151 if (opts_type & OPTS_TYPE_HOOK23)
14152 {
14153 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14154
14155 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14156 }
14157 }
14158
14159 for (uint i = 0; i <= 20; i++)
14160 {
14161 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14162 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14163 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14164
14165 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14166 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14167 }
14168
14169 for (uint i = 21; i <= 31; i++)
14170 {
14171 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14172 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14173 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14174
14175 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14176 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14177 }
14178
14179 if (attack_mode == ATTACK_MODE_BF)
14180 {
14181 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14182 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14183
14184 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14185 {
14186 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14187
14188 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14189 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14190 }
14191 }
14192 else if (attack_mode == ATTACK_MODE_HYBRID1)
14193 {
14194 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14195 }
14196 else if (attack_mode == ATTACK_MODE_HYBRID2)
14197 {
14198 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14199 }
14200
14201 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14202 {
14203 // nothing to do
14204 }
14205 else
14206 {
14207 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14208 }
14209
14210 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14211 {
14212 // nothing to do
14213 }
14214 else
14215 {
14216 for (uint i = 0; i < 5; i++)
14217 {
14218 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14219 }
14220
14221 for (uint i = 5; i < 7; i++)
14222 {
14223 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14224 }
14225 }
14226
14227 /**
14228 * Store initial fanspeed if gpu_temp_retain is enabled
14229 */
14230
14231 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14232 int gpu_temp_retain_set = 0;
14233
14234 if (gpu_temp_disable == 0)
14235 {
14236 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14237 {
14238 hc_thread_mutex_lock (mux_adl);
14239
14240 if (data.hm_device[device_id].fan_supported == 1)
14241 {
14242 if (gpu_temp_retain_chgd == 0)
14243 {
14244 uint cur_temp = 0;
14245 uint default_temp = 0;
14246
14247 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14248
14249 if (ADL_rc == ADL_OK)
14250 {
14251 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14252
14253 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14254
14255 // special case with multi gpu setups: always use minimum retain
14256
14257 if (gpu_temp_retain_set == 0)
14258 {
14259 gpu_temp_retain = gpu_temp_retain_target;
14260 gpu_temp_retain_set = 1;
14261 }
14262 else
14263 {
14264 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14265 }
14266
14267 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14268 }
14269 }
14270
14271 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14272
14273 temp_retain_fanspeed_value[device_id] = fan_speed;
14274
14275 if (fan_speed == -1)
14276 {
14277 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14278
14279 temp_retain_fanspeed_value[device_id] = 0;
14280 }
14281 }
14282
14283 hc_thread_mutex_unlock (mux_adl);
14284 }
14285 }
14286
14287 /**
14288 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14289 */
14290
14291 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14292 {
14293 hc_thread_mutex_lock (mux_adl);
14294
14295 if (data.hm_device[device_id].od_version == 6)
14296 {
14297 int ADL_rc;
14298
14299 // check powertune capabilities first, if not available then skip device
14300
14301 int powertune_supported = 0;
14302
14303 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14304 {
14305 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14306
14307 return (-1);
14308 }
14309
14310 if (powertune_supported != 0)
14311 {
14312 // powercontrol settings
14313
14314 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14315
14316 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14317 {
14318 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14319 }
14320
14321 if (ADL_rc != ADL_OK)
14322 {
14323 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14324
14325 return (-1);
14326 }
14327
14328 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14329 {
14330 log_error ("ERROR: Failed to set new ADL PowerControl values");
14331
14332 return (-1);
14333 }
14334
14335 // clocks
14336
14337 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14338
14339 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14340
14341 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14342 {
14343 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14344
14345 return (-1);
14346 }
14347
14348 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14349
14350 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14351
14352 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14353 {
14354 log_error ("ERROR: Failed to get ADL device capabilities");
14355
14356 return (-1);
14357 }
14358
14359 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14360 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14361
14362 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14363 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14364
14365 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14366 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14367
14368 // warning if profile has too low max values
14369
14370 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14371 {
14372 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14373 }
14374
14375 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14376 {
14377 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14378 }
14379
14380 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14381
14382 performance_state->iNumberOfPerformanceLevels = 2;
14383
14384 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14385 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14386 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14387 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14388
14389 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14390 {
14391 log_info ("ERROR: Failed to set ADL performance state");
14392
14393 return (-1);
14394 }
14395
14396 local_free (performance_state);
14397 }
14398 }
14399
14400 hc_thread_mutex_unlock (mux_adl);
14401 }
14402 #endif // HAVE_HWMON && HAVE_ADL
14403 }
14404
14405 data.kernel_blocks_all = kernel_blocks_all;
14406
14407 if (data.quiet == 0) log_info ("");
14408
14409 /**
14410 * Inform user which algorithm is checked and at which workload setting
14411 */
14412
14413 if (benchmark == 1)
14414 {
14415 quiet = 0;
14416
14417 data.quiet = quiet;
14418
14419 char *hash_type = strhashtype (data.hash_mode); // not a bug
14420
14421 log_info ("Hashtype: %s", hash_type);
14422 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14423 log_info ("");
14424 }
14425
14426 /**
14427 * keep track of the progress
14428 */
14429
14430 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14431 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14432 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14433
14434 /**
14435 * open filehandles
14436 */
14437
14438 #if _WIN
14439 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14440 {
14441 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14442
14443 return (-1);
14444 }
14445
14446 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14447 {
14448 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14449
14450 return (-1);
14451 }
14452
14453 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14454 {
14455 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14456
14457 return (-1);
14458 }
14459 #endif
14460
14461 /**
14462 * dictionary pad
14463 */
14464
14465 segment_size *= (1024 * 1024);
14466
14467 data.segment_size = segment_size;
14468
14469 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14470
14471 wl_data->buf = (char *) mymalloc (segment_size);
14472 wl_data->avail = segment_size;
14473 wl_data->incr = segment_size;
14474 wl_data->cnt = 0;
14475 wl_data->pos = 0;
14476
14477 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14478
14479 data.wordlist_mode = wordlist_mode;
14480
14481 cs_t *css_buf = NULL;
14482 uint css_cnt = 0;
14483 uint dictcnt = 0;
14484 uint maskcnt = 1;
14485 char **masks = NULL;
14486 char **dictfiles = NULL;
14487
14488 uint mask_from_file = 0;
14489
14490 if (attack_mode == ATTACK_MODE_STRAIGHT)
14491 {
14492 if (wordlist_mode == WL_MODE_FILE)
14493 {
14494 int wls_left = myargc - (optind + 1);
14495
14496 for (int i = 0; i < wls_left; i++)
14497 {
14498 char *l0_filename = myargv[optind + 1 + i];
14499
14500 struct stat l0_stat;
14501
14502 if (stat (l0_filename, &l0_stat) == -1)
14503 {
14504 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14505
14506 return (-1);
14507 }
14508
14509 uint is_dir = S_ISDIR (l0_stat.st_mode);
14510
14511 if (is_dir == 0)
14512 {
14513 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14514
14515 dictcnt++;
14516
14517 dictfiles[dictcnt - 1] = l0_filename;
14518 }
14519 else
14520 {
14521 // do not allow --keyspace w/ a directory
14522
14523 if (keyspace == 1)
14524 {
14525 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14526
14527 return (-1);
14528 }
14529
14530 char **dictionary_files = NULL;
14531
14532 dictionary_files = scan_directory (l0_filename);
14533
14534 if (dictionary_files != NULL)
14535 {
14536 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14537
14538 for (int d = 0; dictionary_files[d] != NULL; d++)
14539 {
14540 char *l1_filename = dictionary_files[d];
14541
14542 struct stat l1_stat;
14543
14544 if (stat (l1_filename, &l1_stat) == -1)
14545 {
14546 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14547
14548 return (-1);
14549 }
14550
14551 if (S_ISREG (l1_stat.st_mode))
14552 {
14553 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14554
14555 dictcnt++;
14556
14557 dictfiles[dictcnt - 1] = strdup (l1_filename);
14558 }
14559 }
14560 }
14561
14562 local_free (dictionary_files);
14563 }
14564 }
14565
14566 if (dictcnt < 1)
14567 {
14568 log_error ("ERROR: No usable dictionary file found.");
14569
14570 return (-1);
14571 }
14572 }
14573 else if (wordlist_mode == WL_MODE_STDIN)
14574 {
14575 dictcnt = 1;
14576 }
14577 }
14578 else if (attack_mode == ATTACK_MODE_COMBI)
14579 {
14580 // display
14581
14582 char *dictfile1 = myargv[optind + 1 + 0];
14583 char *dictfile2 = myargv[optind + 1 + 1];
14584
14585 // find the bigger dictionary and use as base
14586
14587 FILE *fp1 = NULL;
14588 FILE *fp2 = NULL;
14589
14590 struct stat tmp_stat;
14591
14592 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14593 {
14594 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14595
14596 return (-1);
14597 }
14598
14599 if (stat (dictfile1, &tmp_stat) == -1)
14600 {
14601 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14602
14603 fclose (fp1);
14604
14605 return (-1);
14606 }
14607
14608 if (S_ISDIR (tmp_stat.st_mode))
14609 {
14610 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14611
14612 fclose (fp1);
14613
14614 return (-1);
14615 }
14616
14617 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14618 {
14619 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14620
14621 fclose (fp1);
14622
14623 return (-1);
14624 }
14625
14626 if (stat (dictfile2, &tmp_stat) == -1)
14627 {
14628 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14629
14630 fclose (fp1);
14631 fclose (fp2);
14632
14633 return (-1);
14634 }
14635
14636 if (S_ISDIR (tmp_stat.st_mode))
14637 {
14638 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14639
14640 fclose (fp1);
14641 fclose (fp2);
14642
14643 return (-1);
14644 }
14645
14646 data.combs_cnt = 1;
14647
14648 data.quiet = 1;
14649
14650 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14651
14652 data.quiet = quiet;
14653
14654 if (words1_cnt == 0)
14655 {
14656 log_error ("ERROR: %s: empty file", dictfile1);
14657
14658 fclose (fp1);
14659 fclose (fp2);
14660
14661 return (-1);
14662 }
14663
14664 data.combs_cnt = 1;
14665
14666 data.quiet = 1;
14667
14668 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14669
14670 data.quiet = quiet;
14671
14672 if (words2_cnt == 0)
14673 {
14674 log_error ("ERROR: %s: empty file", dictfile2);
14675
14676 fclose (fp1);
14677 fclose (fp2);
14678
14679 return (-1);
14680 }
14681
14682 fclose (fp1);
14683 fclose (fp2);
14684
14685 data.dictfile = dictfile1;
14686 data.dictfile2 = dictfile2;
14687
14688 if (words1_cnt >= words2_cnt)
14689 {
14690 data.combs_cnt = words2_cnt;
14691 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14692
14693 dictfiles = &data.dictfile;
14694
14695 dictcnt = 1;
14696 }
14697 else
14698 {
14699 data.combs_cnt = words1_cnt;
14700 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14701
14702 dictfiles = &data.dictfile2;
14703
14704 dictcnt = 1;
14705
14706 // we also have to switch wordlist related rules!
14707
14708 char *tmpc = data.rule_buf_l;
14709
14710 data.rule_buf_l = data.rule_buf_r;
14711 data.rule_buf_r = tmpc;
14712
14713 int tmpi = data.rule_len_l;
14714
14715 data.rule_len_l = data.rule_len_r;
14716 data.rule_len_r = tmpi;
14717 }
14718 }
14719 else if (attack_mode == ATTACK_MODE_BF)
14720 {
14721 char *mask = NULL;
14722
14723 maskcnt = 0;
14724
14725 if (benchmark == 0)
14726 {
14727 mask = myargv[optind + 1];
14728
14729 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14730
14731 if ((optind + 2) <= myargc)
14732 {
14733 struct stat file_stat;
14734
14735 if (stat (mask, &file_stat) == -1)
14736 {
14737 maskcnt = 1;
14738
14739 masks[maskcnt - 1] = mystrdup (mask);
14740 }
14741 else
14742 {
14743 int wls_left = myargc - (optind + 1);
14744
14745 uint masks_avail = INCR_MASKS;
14746
14747 for (int i = 0; i < wls_left; i++)
14748 {
14749 if (i != 0)
14750 {
14751 mask = myargv[optind + 1 + i];
14752
14753 if (stat (mask, &file_stat) == -1)
14754 {
14755 log_error ("ERROR: %s: %s", mask, strerror (errno));
14756
14757 return (-1);
14758 }
14759 }
14760
14761 uint is_file = S_ISREG (file_stat.st_mode);
14762
14763 if (is_file == 1)
14764 {
14765 FILE *mask_fp;
14766
14767 if ((mask_fp = fopen (mask, "r")) == NULL)
14768 {
14769 log_error ("ERROR: %s: %s", mask, strerror (errno));
14770
14771 return (-1);
14772 }
14773
14774 char line_buf[BUFSIZ] = { 0 };
14775
14776 while (!feof (mask_fp))
14777 {
14778 memset (line_buf, 0, BUFSIZ);
14779
14780 int line_len = fgetl (mask_fp, line_buf);
14781
14782 if (line_len == 0) continue;
14783
14784 if (line_buf[0] == '#') continue;
14785
14786 if (masks_avail == maskcnt)
14787 {
14788 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14789
14790 masks_avail += INCR_MASKS;
14791 }
14792
14793 masks[maskcnt] = mystrdup (line_buf);
14794
14795 maskcnt++;
14796 }
14797
14798 fclose (mask_fp);
14799 }
14800 else
14801 {
14802 log_error ("ERROR: %s: unsupported file-type", mask);
14803
14804 return (-1);
14805 }
14806 }
14807
14808 mask_from_file = 1;
14809 }
14810 }
14811 else
14812 {
14813 custom_charset_1 = (char *) "?l?d?u";
14814 custom_charset_2 = (char *) "?l?d";
14815 custom_charset_3 = (char *) "?l?d*!$@_";
14816
14817 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14818 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14819 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14820
14821 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14822
14823 wordlist_mode = WL_MODE_MASK;
14824
14825 data.wordlist_mode = wordlist_mode;
14826
14827 increment = 1;
14828
14829 maskcnt = 1;
14830 }
14831 }
14832 else
14833 {
14834 /**
14835 * generate full masks and charsets
14836 */
14837
14838 masks = (char **) mymalloc (sizeof (char *));
14839
14840 switch (hash_mode)
14841 {
14842 case 1731: pw_min = 5;
14843 pw_max = 5;
14844 mask = mystrdup ("?b?b?b?b?b");
14845 break;
14846 case 12500: pw_min = 5;
14847 pw_max = 5;
14848 mask = mystrdup ("?b?b?b?b?b");
14849 break;
14850 default: pw_min = 7;
14851 pw_max = 7;
14852 mask = mystrdup ("?b?b?b?b?b?b?b");
14853 break;
14854 }
14855
14856 maskcnt = 1;
14857
14858 masks[maskcnt - 1] = mystrdup (mask);
14859
14860 wordlist_mode = WL_MODE_MASK;
14861
14862 data.wordlist_mode = wordlist_mode;
14863
14864 increment = 1;
14865 }
14866
14867 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14868
14869 if (increment)
14870 {
14871 if (increment_min > pw_min) pw_min = increment_min;
14872
14873 if (increment_max < pw_max) pw_max = increment_max;
14874 }
14875 }
14876 else if (attack_mode == ATTACK_MODE_HYBRID1)
14877 {
14878 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14879
14880 // display
14881
14882 char *mask = myargv[myargc - 1];
14883
14884 maskcnt = 0;
14885
14886 masks = (char **) mymalloc (1 * sizeof (char *));
14887
14888 // mod
14889
14890 struct stat file_stat;
14891
14892 if (stat (mask, &file_stat) == -1)
14893 {
14894 maskcnt = 1;
14895
14896 masks[maskcnt - 1] = mystrdup (mask);
14897 }
14898 else
14899 {
14900 uint is_file = S_ISREG (file_stat.st_mode);
14901
14902 if (is_file == 1)
14903 {
14904 FILE *mask_fp;
14905
14906 if ((mask_fp = fopen (mask, "r")) == NULL)
14907 {
14908 log_error ("ERROR: %s: %s", mask, strerror (errno));
14909
14910 return (-1);
14911 }
14912
14913 char line_buf[BUFSIZ] = { 0 };
14914
14915 uint masks_avail = 1;
14916
14917 while (!feof (mask_fp))
14918 {
14919 memset (line_buf, 0, BUFSIZ);
14920
14921 int line_len = fgetl (mask_fp, line_buf);
14922
14923 if (line_len == 0) continue;
14924
14925 if (line_buf[0] == '#') continue;
14926
14927 if (masks_avail == maskcnt)
14928 {
14929 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14930
14931 masks_avail += INCR_MASKS;
14932 }
14933
14934 masks[maskcnt] = mystrdup (line_buf);
14935
14936 maskcnt++;
14937 }
14938
14939 fclose (mask_fp);
14940
14941 mask_from_file = 1;
14942 }
14943 else
14944 {
14945 maskcnt = 1;
14946
14947 masks[maskcnt - 1] = mystrdup (mask);
14948 }
14949 }
14950
14951 // base
14952
14953 int wls_left = myargc - (optind + 2);
14954
14955 for (int i = 0; i < wls_left; i++)
14956 {
14957 char *filename = myargv[optind + 1 + i];
14958
14959 struct stat file_stat;
14960
14961 if (stat (filename, &file_stat) == -1)
14962 {
14963 log_error ("ERROR: %s: %s", filename, strerror (errno));
14964
14965 return (-1);
14966 }
14967
14968 uint is_dir = S_ISDIR (file_stat.st_mode);
14969
14970 if (is_dir == 0)
14971 {
14972 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14973
14974 dictcnt++;
14975
14976 dictfiles[dictcnt - 1] = filename;
14977 }
14978 else
14979 {
14980 // do not allow --keyspace w/ a directory
14981
14982 if (keyspace == 1)
14983 {
14984 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14985
14986 return (-1);
14987 }
14988
14989 char **dictionary_files = NULL;
14990
14991 dictionary_files = scan_directory (filename);
14992
14993 if (dictionary_files != NULL)
14994 {
14995 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14996
14997 for (int d = 0; dictionary_files[d] != NULL; d++)
14998 {
14999 char *l1_filename = dictionary_files[d];
15000
15001 struct stat l1_stat;
15002
15003 if (stat (l1_filename, &l1_stat) == -1)
15004 {
15005 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15006
15007 return (-1);
15008 }
15009
15010 if (S_ISREG (l1_stat.st_mode))
15011 {
15012 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15013
15014 dictcnt++;
15015
15016 dictfiles[dictcnt - 1] = strdup (l1_filename);
15017 }
15018 }
15019 }
15020
15021 local_free (dictionary_files);
15022 }
15023 }
15024
15025 if (dictcnt < 1)
15026 {
15027 log_error ("ERROR: No usable dictionary file found.");
15028
15029 return (-1);
15030 }
15031
15032 if (increment)
15033 {
15034 maskcnt = 0;
15035
15036 uint mask_min = increment_min; // we can't reject smaller masks here
15037 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15038
15039 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15040 {
15041 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15042
15043 if (cur_mask == NULL) break;
15044
15045 masks[maskcnt] = cur_mask;
15046
15047 maskcnt++;
15048
15049 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15050 }
15051 }
15052 }
15053 else if (attack_mode == ATTACK_MODE_HYBRID2)
15054 {
15055 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15056
15057 // display
15058
15059 char *mask = myargv[optind + 1 + 0];
15060
15061 maskcnt = 0;
15062
15063 masks = (char **) mymalloc (1 * sizeof (char *));
15064
15065 // mod
15066
15067 struct stat file_stat;
15068
15069 if (stat (mask, &file_stat) == -1)
15070 {
15071 maskcnt = 1;
15072
15073 masks[maskcnt - 1] = mystrdup (mask);
15074 }
15075 else
15076 {
15077 uint is_file = S_ISREG (file_stat.st_mode);
15078
15079 if (is_file == 1)
15080 {
15081 FILE *mask_fp;
15082
15083 if ((mask_fp = fopen (mask, "r")) == NULL)
15084 {
15085 log_error ("ERROR: %s: %s", mask, strerror (errno));
15086
15087 return (-1);
15088 }
15089
15090 char line_buf[BUFSIZ] = { 0 };
15091
15092 uint masks_avail = 1;
15093
15094 while (!feof (mask_fp))
15095 {
15096 memset (line_buf, 0, BUFSIZ);
15097
15098 int line_len = fgetl (mask_fp, line_buf);
15099
15100 if (line_len == 0) continue;
15101
15102 if (line_buf[0] == '#') continue;
15103
15104 if (masks_avail == maskcnt)
15105 {
15106 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15107
15108 masks_avail += INCR_MASKS;
15109 }
15110
15111 masks[maskcnt] = mystrdup (line_buf);
15112
15113 maskcnt++;
15114 }
15115
15116 fclose (mask_fp);
15117
15118 mask_from_file = 1;
15119 }
15120 else
15121 {
15122 maskcnt = 1;
15123
15124 masks[maskcnt - 1] = mystrdup (mask);
15125 }
15126 }
15127
15128 // base
15129
15130 int wls_left = myargc - (optind + 2);
15131
15132 for (int i = 0; i < wls_left; i++)
15133 {
15134 char *filename = myargv[optind + 2 + i];
15135
15136 struct stat file_stat;
15137
15138 if (stat (filename, &file_stat) == -1)
15139 {
15140 log_error ("ERROR: %s: %s", filename, strerror (errno));
15141
15142 return (-1);
15143 }
15144
15145 uint is_dir = S_ISDIR (file_stat.st_mode);
15146
15147 if (is_dir == 0)
15148 {
15149 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15150
15151 dictcnt++;
15152
15153 dictfiles[dictcnt - 1] = filename;
15154 }
15155 else
15156 {
15157 // do not allow --keyspace w/ a directory
15158
15159 if (keyspace == 1)
15160 {
15161 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15162
15163 return (-1);
15164 }
15165
15166 char **dictionary_files = NULL;
15167
15168 dictionary_files = scan_directory (filename);
15169
15170 if (dictionary_files != NULL)
15171 {
15172 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15173
15174 for (int d = 0; dictionary_files[d] != NULL; d++)
15175 {
15176 char *l1_filename = dictionary_files[d];
15177
15178 struct stat l1_stat;
15179
15180 if (stat (l1_filename, &l1_stat) == -1)
15181 {
15182 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15183
15184 return (-1);
15185 }
15186
15187 if (S_ISREG (l1_stat.st_mode))
15188 {
15189 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15190
15191 dictcnt++;
15192
15193 dictfiles[dictcnt - 1] = strdup (l1_filename);
15194 }
15195 }
15196 }
15197
15198 local_free (dictionary_files);
15199 }
15200 }
15201
15202 if (dictcnt < 1)
15203 {
15204 log_error ("ERROR: No usable dictionary file found.");
15205
15206 return (-1);
15207 }
15208
15209 if (increment)
15210 {
15211 maskcnt = 0;
15212
15213 uint mask_min = increment_min; // we can't reject smaller masks here
15214 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15215
15216 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15217 {
15218 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15219
15220 if (cur_mask == NULL) break;
15221
15222 masks[maskcnt] = cur_mask;
15223
15224 maskcnt++;
15225
15226 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15227 }
15228 }
15229 }
15230
15231 data.pw_min = pw_min;
15232 data.pw_max = pw_max;
15233
15234 /**
15235 * weak hash check
15236 */
15237
15238 if (weak_hash_threshold >= salts_cnt)
15239 {
15240 hc_device_param_t *device_param = NULL;
15241
15242 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15243 {
15244 device_param = &data.devices_param[device_id];
15245
15246 if (device_param->skipped) continue;
15247
15248 break;
15249 }
15250
15251 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15252
15253 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15254 {
15255 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15256 }
15257 }
15258
15259 // Display hack, guarantee that there is at least one \r before real start
15260
15261 if (data.quiet == 0) log_info_nn ("");
15262
15263 /**
15264 * status and monitor threads
15265 */
15266
15267 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15268
15269 hc_thread_t i_thread = 0;
15270
15271 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15272 {
15273 hc_thread_create (i_thread, thread_keypress, &benchmark);
15274 }
15275
15276 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15277
15278 uint ni_threads_cnt = 0;
15279
15280 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15281
15282 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15283
15284 ni_threads_cnt++;
15285
15286 /**
15287 * Outfile remove
15288 */
15289
15290 if (keyspace == 0)
15291 {
15292 if (outfile_check_timer != 0)
15293 {
15294 if (data.outfile_check_directory != NULL)
15295 {
15296 if ((hash_mode != 5200) &&
15297 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15298 (hash_mode != 9000))
15299 {
15300 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15301
15302 ni_threads_cnt++;
15303 }
15304 else
15305 {
15306 outfile_check_timer = 0;
15307 }
15308 }
15309 else
15310 {
15311 outfile_check_timer = 0;
15312 }
15313 }
15314 }
15315
15316 /**
15317 * Inform the user if we got some hashes remove because of the pot file remove feature
15318 */
15319
15320 if (data.quiet == 0)
15321 {
15322 if (potfile_remove_cracks > 0)
15323 {
15324 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15325 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15326 }
15327 }
15328
15329 data.outfile_check_timer = outfile_check_timer;
15330
15331 /**
15332 * main loop
15333 */
15334
15335 char **induction_dictionaries = NULL;
15336
15337 int induction_dictionaries_cnt = 0;
15338
15339 hcstat_table_t *root_table_buf = NULL;
15340 hcstat_table_t *markov_table_buf = NULL;
15341
15342 uint initial_restore_done = 0;
15343
15344 data.maskcnt = maskcnt;
15345
15346 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15347 {
15348 if (data.devices_status == STATUS_CRACKED) break;
15349
15350 data.devices_status = STATUS_INIT;
15351
15352 if (maskpos > rd->maskpos)
15353 {
15354 rd->dictpos = 0;
15355 }
15356
15357 rd->maskpos = maskpos;
15358 data.maskpos = maskpos;
15359
15360 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15361 {
15362 char *mask = masks[maskpos];
15363
15364 if (mask_from_file == 1)
15365 {
15366 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15367
15368 char *str_ptr;
15369 uint str_pos;
15370
15371 uint mask_offset = 0;
15372
15373 uint separator_cnt;
15374
15375 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15376 {
15377 str_ptr = strstr (mask + mask_offset, ",");
15378
15379 if (str_ptr == NULL) break;
15380
15381 str_pos = str_ptr - mask;
15382
15383 // escaped separator, i.e. "\,"
15384
15385 if (str_pos > 0)
15386 {
15387 if (mask[str_pos - 1] == '\\')
15388 {
15389 separator_cnt --;
15390
15391 mask_offset = str_pos + 1;
15392
15393 continue;
15394 }
15395 }
15396
15397 // reset the offset
15398
15399 mask_offset = 0;
15400
15401 mask[str_pos] = '\0';
15402
15403 switch (separator_cnt)
15404 {
15405 case 0:
15406 mp_reset_usr (mp_usr, 0);
15407
15408 custom_charset_1 = mask;
15409 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15410 break;
15411
15412 case 1:
15413 mp_reset_usr (mp_usr, 1);
15414
15415 custom_charset_2 = mask;
15416 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15417 break;
15418
15419 case 2:
15420 mp_reset_usr (mp_usr, 2);
15421
15422 custom_charset_3 = mask;
15423 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15424 break;
15425
15426 case 3:
15427 mp_reset_usr (mp_usr, 3);
15428
15429 custom_charset_4 = mask;
15430 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15431 break;
15432 }
15433
15434 mask = mask + str_pos + 1;
15435 }
15436 }
15437
15438 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15439 {
15440 if (maskpos > 0)
15441 {
15442 local_free (css_buf);
15443 local_free (data.root_css_buf);
15444 local_free (data.markov_css_buf);
15445
15446 local_free (masks[maskpos - 1]);
15447 }
15448
15449 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15450
15451 data.mask = mask;
15452 data.css_cnt = css_cnt;
15453 data.css_buf = css_buf;
15454
15455 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15456
15457 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15458
15459 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15460 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15461
15462 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15463
15464 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15465
15466 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15467 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15468
15469 data.root_css_buf = root_css_buf;
15470 data.markov_css_buf = markov_css_buf;
15471
15472 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15473
15474 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15475
15476 local_free (root_table_buf);
15477 local_free (markov_table_buf);
15478
15479 // args
15480
15481 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15482 {
15483 hc_device_param_t *device_param = &data.devices_param[device_id];
15484
15485 if (device_param->skipped) continue;
15486
15487 device_param->kernel_params_mp[0] = &device_param->d_combs;
15488 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15489 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15490
15491 device_param->kernel_params_mp_buf64[3] = 0;
15492 device_param->kernel_params_mp_buf32[4] = css_cnt;
15493 device_param->kernel_params_mp_buf32[5] = 0;
15494 device_param->kernel_params_mp_buf32[6] = 0;
15495 device_param->kernel_params_mp_buf32[7] = 0;
15496
15497 if (attack_mode == ATTACK_MODE_HYBRID1)
15498 {
15499 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15500 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15501 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15502 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15503 }
15504 else if (attack_mode == ATTACK_MODE_HYBRID2)
15505 {
15506 device_param->kernel_params_mp_buf32[5] = 0;
15507 device_param->kernel_params_mp_buf32[6] = 0;
15508 device_param->kernel_params_mp_buf32[7] = 0;
15509 }
15510
15511 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15512 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15513 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15514
15515 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15516 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15517 }
15518 }
15519 else if (attack_mode == ATTACK_MODE_BF)
15520 {
15521 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15522
15523 if (increment)
15524 {
15525 for (uint i = 0; i < dictcnt; i++)
15526 {
15527 local_free (dictfiles[i]);
15528 }
15529
15530 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15531 {
15532 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15533
15534 if (l1_filename == NULL) break;
15535
15536 dictcnt++;
15537
15538 dictfiles[dictcnt - 1] = l1_filename;
15539 }
15540 }
15541 else
15542 {
15543 dictcnt++;
15544
15545 dictfiles[dictcnt - 1] = mask;
15546 }
15547
15548 if (dictcnt == 0)
15549 {
15550 log_error ("ERROR: Mask is too small");
15551
15552 return (-1);
15553 }
15554 }
15555 }
15556
15557 free (induction_dictionaries);
15558
15559 // induction_dictionaries_cnt = 0; // implied
15560
15561 if (attack_mode != ATTACK_MODE_BF)
15562 {
15563 if (keyspace == 0)
15564 {
15565 induction_dictionaries = scan_directory (induction_directory);
15566
15567 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15568 }
15569 }
15570
15571 if (induction_dictionaries_cnt)
15572 {
15573 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15574 }
15575
15576 /**
15577 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15578 */
15579 if (keyspace == 1)
15580 {
15581 if ((maskcnt > 1) || (dictcnt > 1))
15582 {
15583 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15584
15585 return (-1);
15586 }
15587 }
15588
15589 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15590 {
15591 char *subid = logfile_generate_subid ();
15592
15593 data.subid = subid;
15594
15595 logfile_sub_msg ("START");
15596
15597 data.devices_status = STATUS_INIT;
15598
15599 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15600 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15601 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15602
15603 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15604
15605 data.cpt_pos = 0;
15606
15607 data.cpt_start = time (NULL);
15608
15609 data.cpt_total = 0;
15610
15611 if (data.restore == 0)
15612 {
15613 rd->words_cur = skip;
15614
15615 skip = 0;
15616
15617 data.skip = 0;
15618 }
15619
15620 data.ms_paused = 0;
15621
15622 data.words_cur = rd->words_cur;
15623
15624 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15625 {
15626 hc_device_param_t *device_param = &data.devices_param[device_id];
15627
15628 if (device_param->skipped) continue;
15629
15630 device_param->speed_pos = 0;
15631
15632 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15633 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15634 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15635
15636 device_param->exec_pos = 0;
15637
15638 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15639
15640 device_param->kernel_power = device_param->kernel_power_user;
15641 device_param->kernel_blocks = device_param->kernel_blocks_user;
15642
15643 device_param->outerloop_pos = 0;
15644 device_param->outerloop_left = 0;
15645 device_param->innerloop_pos = 0;
15646 device_param->innerloop_left = 0;
15647
15648 // some more resets:
15649
15650 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15651
15652 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15653
15654 device_param->pw_cnt = 0;
15655 device_param->pws_cnt = 0;
15656
15657 device_param->words_off = 0;
15658 device_param->words_done = 0;
15659 }
15660
15661 data.kernel_blocks_div = 0;
15662
15663 // figure out some workload
15664
15665 if (attack_mode == ATTACK_MODE_STRAIGHT)
15666 {
15667 if (data.wordlist_mode == WL_MODE_FILE)
15668 {
15669 char *dictfile = NULL;
15670
15671 if (induction_dictionaries_cnt)
15672 {
15673 dictfile = induction_dictionaries[0];
15674 }
15675 else
15676 {
15677 dictfile = dictfiles[dictpos];
15678 }
15679
15680 data.dictfile = dictfile;
15681
15682 logfile_sub_string (dictfile);
15683
15684 for (uint i = 0; i < rp_files_cnt; i++)
15685 {
15686 logfile_sub_var_string ("rulefile", rp_files[i]);
15687 }
15688
15689 FILE *fd2 = fopen (dictfile, "rb");
15690
15691 if (fd2 == NULL)
15692 {
15693 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15694
15695 return (-1);
15696 }
15697
15698 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15699
15700 fclose (fd2);
15701
15702 if (data.words_cnt == 0)
15703 {
15704 if (data.devices_status == STATUS_CRACKED) break;
15705 if (data.devices_status == STATUS_ABORTED) break;
15706
15707 dictpos++;
15708
15709 continue;
15710 }
15711 }
15712 }
15713 else if (attack_mode == ATTACK_MODE_COMBI)
15714 {
15715 char *dictfile = data.dictfile;
15716 char *dictfile2 = data.dictfile2;
15717
15718 logfile_sub_string (dictfile);
15719 logfile_sub_string (dictfile2);
15720
15721 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15722 {
15723 FILE *fd2 = fopen (dictfile, "rb");
15724
15725 if (fd2 == NULL)
15726 {
15727 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15728
15729 return (-1);
15730 }
15731
15732 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15733
15734 fclose (fd2);
15735 }
15736 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15737 {
15738 FILE *fd2 = fopen (dictfile2, "rb");
15739
15740 if (fd2 == NULL)
15741 {
15742 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15743
15744 return (-1);
15745 }
15746
15747 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15748
15749 fclose (fd2);
15750 }
15751
15752 if (data.words_cnt == 0)
15753 {
15754 if (data.devices_status == STATUS_CRACKED) break;
15755 if (data.devices_status == STATUS_ABORTED) break;
15756
15757 dictpos++;
15758
15759 continue;
15760 }
15761 }
15762 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15763 {
15764 char *dictfile = NULL;
15765
15766 if (induction_dictionaries_cnt)
15767 {
15768 dictfile = induction_dictionaries[0];
15769 }
15770 else
15771 {
15772 dictfile = dictfiles[dictpos];
15773 }
15774
15775 data.dictfile = dictfile;
15776
15777 char *mask = data.mask;
15778
15779 logfile_sub_string (dictfile);
15780 logfile_sub_string (mask);
15781
15782 FILE *fd2 = fopen (dictfile, "rb");
15783
15784 if (fd2 == NULL)
15785 {
15786 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15787
15788 return (-1);
15789 }
15790
15791 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15792
15793 fclose (fd2);
15794
15795 if (data.words_cnt == 0)
15796 {
15797 if (data.devices_status == STATUS_CRACKED) break;
15798 if (data.devices_status == STATUS_ABORTED) break;
15799
15800 dictpos++;
15801
15802 continue;
15803 }
15804 }
15805 else if (attack_mode == ATTACK_MODE_BF)
15806 {
15807 local_free (css_buf);
15808 local_free (data.root_css_buf);
15809 local_free (data.markov_css_buf);
15810
15811 char *mask = dictfiles[dictpos];
15812
15813 logfile_sub_string (mask);
15814
15815 // base
15816
15817 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15818
15819 if (opts_type & OPTS_TYPE_PT_UNICODE)
15820 {
15821 uint css_cnt_unicode = css_cnt * 2;
15822
15823 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15824
15825 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15826 {
15827 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15828
15829 css_buf_unicode[j + 1].cs_buf[0] = 0;
15830 css_buf_unicode[j + 1].cs_len = 1;
15831 }
15832
15833 free (css_buf);
15834
15835 css_buf = css_buf_unicode;
15836 css_cnt = css_cnt_unicode;
15837 }
15838
15839 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15840
15841 uint mask_min = pw_min;
15842 uint mask_max = pw_max;
15843
15844 if (opts_type & OPTS_TYPE_PT_UNICODE)
15845 {
15846 mask_min *= 2;
15847 mask_max *= 2;
15848 }
15849
15850 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15851 {
15852 if (css_cnt < mask_min)
15853 {
15854 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15855 }
15856
15857 if (css_cnt > mask_max)
15858 {
15859 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15860 }
15861
15862 // skip to next mask
15863
15864 dictpos++;
15865
15866 rd->dictpos = dictpos;
15867
15868 logfile_sub_msg ("STOP");
15869
15870 continue;
15871 }
15872
15873 uint save_css_cnt = css_cnt;
15874
15875 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15876 {
15877 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15878 {
15879 uint salt_len = (uint) data.salts_buf[0].salt_len;
15880 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15881
15882 uint css_cnt_salt = css_cnt + salt_len;
15883
15884 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15885
15886 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15887
15888 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15889 {
15890 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15891 css_buf_salt[j].cs_len = 1;
15892 }
15893
15894 free (css_buf);
15895
15896 css_buf = css_buf_salt;
15897 css_cnt = css_cnt_salt;
15898 }
15899 }
15900
15901 data.mask = mask;
15902 data.css_cnt = css_cnt;
15903 data.css_buf = css_buf;
15904
15905 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15906
15907 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15908
15909 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15910
15911 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15912 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15913
15914 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15915
15916 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15917
15918 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15919 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15920
15921 data.root_css_buf = root_css_buf;
15922 data.markov_css_buf = markov_css_buf;
15923
15924 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15925
15926 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15927
15928 local_free (root_table_buf);
15929 local_free (markov_table_buf);
15930
15931 // copy + args
15932
15933 uint css_cnt_l = css_cnt;
15934 uint css_cnt_r;
15935
15936 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15937 {
15938 if (save_css_cnt < 6)
15939 {
15940 css_cnt_r = 1;
15941 }
15942 else if (save_css_cnt == 6)
15943 {
15944 css_cnt_r = 2;
15945 }
15946 else
15947 {
15948 if (opts_type & OPTS_TYPE_PT_UNICODE)
15949 {
15950 if (save_css_cnt == 8 || save_css_cnt == 10)
15951 {
15952 css_cnt_r = 2;
15953 }
15954 else
15955 {
15956 css_cnt_r = 4;
15957 }
15958 }
15959 else
15960 {
15961 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15962 {
15963 css_cnt_r = 3;
15964 }
15965 else
15966 {
15967 css_cnt_r = 4;
15968 }
15969 }
15970 }
15971 }
15972 else
15973 {
15974 css_cnt_r = 1;
15975
15976 /* unfinished code?
15977 int sum = css_buf[css_cnt_r - 1].cs_len;
15978
15979 for (uint i = 1; i < 4 && i < css_cnt; i++)
15980 {
15981 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15982
15983 css_cnt_r++;
15984
15985 sum *= css_buf[css_cnt_r - 1].cs_len;
15986 }
15987 */
15988 }
15989
15990 css_cnt_l -= css_cnt_r;
15991
15992 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15993
15994 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15995 {
15996 hc_device_param_t *device_param = &data.devices_param[device_id];
15997
15998 if (device_param->skipped) continue;
15999
16000 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16001 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16002 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16003
16004 device_param->kernel_params_mp_l_buf64[3] = 0;
16005 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16006 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16007 device_param->kernel_params_mp_l_buf32[6] = 0;
16008 device_param->kernel_params_mp_l_buf32[7] = 0;
16009 device_param->kernel_params_mp_l_buf32[8] = 0;
16010
16011 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16012 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16013 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16014 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16015
16016 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16017 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16018 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16019
16020 device_param->kernel_params_mp_r_buf64[3] = 0;
16021 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16022 device_param->kernel_params_mp_r_buf32[5] = 0;
16023 device_param->kernel_params_mp_r_buf32[6] = 0;
16024 device_param->kernel_params_mp_r_buf32[7] = 0;
16025
16026 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
16027 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
16028 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
16029
16030 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
16031 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
16032 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
16033
16034 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16035 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16036 }
16037 }
16038
16039 u64 words_base = data.words_cnt;
16040
16041 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16042 {
16043 if (data.kernel_rules_cnt)
16044 {
16045 words_base /= data.kernel_rules_cnt;
16046 }
16047 }
16048 else if (data.attack_kern == ATTACK_KERN_COMBI)
16049 {
16050 if (data.combs_cnt)
16051 {
16052 words_base /= data.combs_cnt;
16053 }
16054 }
16055 else if (data.attack_kern == ATTACK_KERN_BF)
16056 {
16057 if (data.bfs_cnt)
16058 {
16059 words_base /= data.bfs_cnt;
16060 }
16061 }
16062
16063 data.words_base = words_base;
16064
16065 if (keyspace == 1)
16066 {
16067 log_info ("%llu", (unsigned long long int) words_base);
16068
16069 return (0);
16070 }
16071
16072 if (data.words_cur > data.words_base)
16073 {
16074 log_error ("ERROR: restore value greater keyspace");
16075
16076 return (-1);
16077 }
16078
16079 if (data.words_cur)
16080 {
16081 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16082 {
16083 for (uint i = 0; i < data.salts_cnt; i++)
16084 {
16085 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16086 }
16087 }
16088 else if (data.attack_kern == ATTACK_KERN_COMBI)
16089 {
16090 for (uint i = 0; i < data.salts_cnt; i++)
16091 {
16092 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16093 }
16094 }
16095 else if (data.attack_kern == ATTACK_KERN_BF)
16096 {
16097 for (uint i = 0; i < data.salts_cnt; i++)
16098 {
16099 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16100 }
16101 }
16102 }
16103
16104 /*
16105 * Inform user about possible slow speeds
16106 */
16107
16108 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16109 {
16110 if (data.words_base < kernel_blocks_all)
16111 {
16112 if (quiet == 0)
16113 {
16114 log_info ("");
16115 log_info ("ATTENTION!");
16116 log_info (" The wordlist or mask you are using is too small.");
16117 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16118 log_info (" The cracking speed will drop.");
16119 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16120 log_info ("");
16121 }
16122 }
16123 }
16124
16125 /*
16126 * Update loopback file
16127 */
16128
16129 if (loopback == 1)
16130 {
16131 time_t now;
16132
16133 time (&now);
16134
16135 uint random_num = get_random_num (0, 9999);
16136
16137 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16138
16139 data.loopback_file = loopback_file;
16140 }
16141
16142 /*
16143 * Update dictionary statistic
16144 */
16145
16146 if (keyspace == 0)
16147 {
16148 dictstat_fp = fopen (dictstat, "wb");
16149
16150 if (dictstat_fp)
16151 {
16152 lock_file (dictstat_fp);
16153
16154 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16155
16156 fclose (dictstat_fp);
16157 }
16158 }
16159
16160 data.devices_status = STATUS_RUNNING;
16161
16162 if (initial_restore_done == 0)
16163 {
16164 if (data.restore_disable == 0) cycle_restore ();
16165
16166 initial_restore_done = 1;
16167 }
16168
16169 hc_timer_set (&data.timer_running);
16170
16171 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16172 {
16173 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16174 {
16175 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16176 if (quiet == 0) fflush (stdout);
16177 }
16178 }
16179 else if (wordlist_mode == WL_MODE_STDIN)
16180 {
16181 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16182 if (data.quiet == 0) log_info ("");
16183 }
16184
16185 time_t runtime_start;
16186
16187 time (&runtime_start);
16188
16189 data.runtime_start = runtime_start;
16190
16191 /**
16192 * create cracker threads
16193 */
16194
16195 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16196
16197 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16198 {
16199 hc_device_param_t *device_param = &devices_param[device_id];
16200
16201 if (wordlist_mode == WL_MODE_STDIN)
16202 {
16203 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16204 }
16205 else
16206 {
16207 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16208 }
16209 }
16210
16211 // wait for crack threads to exit
16212
16213 hc_thread_wait (data.devices_cnt, c_threads);
16214
16215 local_free (c_threads);
16216
16217 data.restore = 0;
16218
16219 // finalize task
16220
16221 logfile_sub_var_uint ("status-after-work", data.devices_status);
16222
16223 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16224
16225 if (data.devices_status == STATUS_CRACKED) break;
16226 if (data.devices_status == STATUS_ABORTED) break;
16227
16228 if (data.devices_status == STATUS_BYPASS)
16229 {
16230 data.devices_status = STATUS_RUNNING;
16231 }
16232
16233 if (induction_dictionaries_cnt)
16234 {
16235 unlink (induction_dictionaries[0]);
16236 }
16237
16238 free (induction_dictionaries);
16239
16240 if (attack_mode != ATTACK_MODE_BF)
16241 {
16242 induction_dictionaries = scan_directory (induction_directory);
16243
16244 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16245 }
16246
16247 if (benchmark == 0)
16248 {
16249 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16250 {
16251 if (quiet == 0) clear_prompt ();
16252
16253 if (quiet == 0) log_info ("");
16254
16255 if (status == 1)
16256 {
16257 status_display ();
16258 }
16259 else
16260 {
16261 if (quiet == 0) status_display ();
16262 }
16263
16264 if (quiet == 0) log_info ("");
16265 }
16266 }
16267
16268 if (attack_mode == ATTACK_MODE_BF)
16269 {
16270 dictpos++;
16271
16272 rd->dictpos = dictpos;
16273 }
16274 else
16275 {
16276 if (induction_dictionaries_cnt)
16277 {
16278 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16279 }
16280 else
16281 {
16282 dictpos++;
16283
16284 rd->dictpos = dictpos;
16285 }
16286 }
16287
16288 time_t runtime_stop;
16289
16290 time (&runtime_stop);
16291
16292 data.runtime_stop = runtime_stop;
16293
16294 logfile_sub_uint (runtime_start);
16295 logfile_sub_uint (runtime_stop);
16296
16297 logfile_sub_msg ("STOP");
16298
16299 global_free (subid);
16300 }
16301
16302 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16303
16304 if (data.devices_status == STATUS_CRACKED) break;
16305 if (data.devices_status == STATUS_ABORTED) break;
16306 if (data.devices_status == STATUS_QUIT) break;
16307
16308 if (data.devices_status == STATUS_BYPASS)
16309 {
16310 data.devices_status = STATUS_RUNNING;
16311 }
16312 }
16313
16314 // 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
16315
16316 if (attack_mode == ATTACK_MODE_STRAIGHT)
16317 {
16318 if (data.wordlist_mode == WL_MODE_FILE)
16319 {
16320 if (data.dictfile == NULL)
16321 {
16322 if (dictfiles != NULL)
16323 {
16324 data.dictfile = dictfiles[0];
16325
16326 hc_timer_set (&data.timer_running);
16327 }
16328 }
16329 }
16330 }
16331 // NOTE: combi is okay because it is already set beforehand
16332 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16333 {
16334 if (data.dictfile == NULL)
16335 {
16336 if (dictfiles != NULL)
16337 {
16338 hc_timer_set (&data.timer_running);
16339
16340 data.dictfile = dictfiles[0];
16341 }
16342 }
16343 }
16344 else if (attack_mode == ATTACK_MODE_BF)
16345 {
16346 if (data.mask == NULL)
16347 {
16348 hc_timer_set (&data.timer_running);
16349
16350 data.mask = masks[0];
16351 }
16352 }
16353
16354 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16355 {
16356 data.devices_status = STATUS_EXHAUSTED;
16357 }
16358
16359 // if cracked / aborted remove last induction dictionary
16360
16361 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16362 {
16363 struct stat induct_stat;
16364
16365 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16366 {
16367 unlink (induction_dictionaries[file_pos]);
16368 }
16369 }
16370
16371 // wait for non-interactive threads
16372
16373 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16374 {
16375 hc_thread_wait (1, &ni_threads[thread_idx]);
16376 }
16377
16378 local_free (ni_threads);
16379
16380 // wait for interactive threads
16381
16382 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16383 {
16384 hc_thread_wait (1, &i_thread);
16385 }
16386
16387 // we dont need restore file anymore
16388 if (data.restore_disable == 0)
16389 {
16390 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16391 {
16392 unlink (eff_restore_file);
16393 unlink (new_restore_file);
16394 }
16395 else
16396 {
16397 cycle_restore ();
16398 }
16399 }
16400
16401 // finally save left hashes
16402
16403 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16404 {
16405 save_hash ();
16406 }
16407
16408 /**
16409 * Clean up
16410 */
16411
16412 if (benchmark == 1)
16413 {
16414 status_benchmark ();
16415
16416 log_info ("");
16417 }
16418 else
16419 {
16420 if (quiet == 0) clear_prompt ();
16421
16422 if (quiet == 0) log_info ("");
16423
16424 if (status == 1)
16425 {
16426 status_display ();
16427 }
16428 else
16429 {
16430 if (quiet == 0) status_display ();
16431 }
16432
16433 if (quiet == 0) log_info ("");
16434 }
16435
16436 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16437 {
16438 hc_device_param_t *device_param = &data.devices_param[device_id];
16439
16440 if (device_param->skipped) continue;
16441
16442 local_free (device_param->result);
16443
16444 local_free (device_param->pw_caches);
16445
16446 local_free (device_param->combs_buf);
16447
16448 local_free (device_param->hooks_buf);
16449
16450 local_free (device_param->device_name);
16451
16452 local_free (device_param->device_name_chksum);
16453
16454 local_free (device_param->device_version);
16455
16456 local_free (device_param->driver_version);
16457
16458 if (device_param->pws_buf) myfree (device_param->pws_buf);
16459 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16460 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16461 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16462 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16463 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16464 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16465 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16466 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16467 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16468 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16469 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16470 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16471 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16472 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16473 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16474 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16475 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16476 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16477 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16478 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16479 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16480 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16481 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16482 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16483 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16484 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16485 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16486 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16487
16488 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16489 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16490 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16491 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16492 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16493 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16494 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16495 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16496 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16497 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16498 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16499
16500 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16501 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16502 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16503
16504 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16505 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16506 }
16507
16508 // reset default fan speed
16509
16510 #ifdef HAVE_HWMON
16511 if (gpu_temp_disable == 0)
16512 {
16513 #ifdef HAVE_ADL
16514 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16515 {
16516 hc_thread_mutex_lock (mux_adl);
16517
16518 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16519 {
16520 hc_device_param_t *device_param = &data.devices_param[device_id];
16521
16522 if (device_param->skipped) continue;
16523
16524 if (data.hm_device[device_id].fan_supported == 1)
16525 {
16526 int fanspeed = temp_retain_fanspeed_value[device_id];
16527
16528 if (fanspeed == -1) continue;
16529
16530 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16531
16532 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16533 }
16534 }
16535
16536 hc_thread_mutex_unlock (mux_adl);
16537 }
16538 #endif // HAVE_ADL
16539 }
16540
16541 #ifdef HAVE_ADL
16542 // reset power tuning
16543
16544 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16545 {
16546 hc_thread_mutex_lock (mux_adl);
16547
16548 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16549 {
16550 hc_device_param_t *device_param = &data.devices_param[device_id];
16551
16552 if (device_param->skipped) continue;
16553
16554 if (data.hm_device[device_id].od_version == 6)
16555 {
16556 // check powertune capabilities first, if not available then skip device
16557
16558 int powertune_supported = 0;
16559
16560 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16561 {
16562 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16563
16564 return (-1);
16565 }
16566
16567 if (powertune_supported != 0)
16568 {
16569 // powercontrol settings
16570
16571 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16572 {
16573 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16574
16575 return (-1);
16576 }
16577
16578 // clocks
16579
16580 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16581
16582 performance_state->iNumberOfPerformanceLevels = 2;
16583
16584 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16585 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16586 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16587 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16588
16589 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16590 {
16591 log_info ("ERROR: Failed to restore ADL performance state");
16592
16593 return (-1);
16594 }
16595
16596 local_free (performance_state);
16597 }
16598 }
16599 }
16600
16601 hc_thread_mutex_unlock (mux_adl);
16602 }
16603 #endif // HAVE_ADL
16604
16605 if (gpu_temp_disable == 0)
16606 {
16607 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16608 if (data.hm_nv)
16609 {
16610 #if defined(LINUX) && defined(HAVE_NVML)
16611
16612 hm_NVML_nvmlShutdown (data.hm_nv);
16613
16614 nvml_close (data.hm_nv);
16615
16616 #elif defined(WIN) && (HAVE_NVAPI)
16617
16618 hm_NvAPI_Unload (data.hm_nv);
16619
16620 nvapi_close (data.hm_nv);
16621
16622 #endif
16623
16624 data.hm_nv = NULL;
16625 }
16626 #endif
16627
16628 #ifdef HAVE_ADL
16629 if (data.hm_amd)
16630 {
16631 hm_ADL_Main_Control_Destroy (data.hm_amd);
16632
16633 adl_close (data.hm_amd);
16634 data.hm_amd = NULL;
16635 }
16636 #endif
16637 }
16638 #endif // HAVE_HWMON
16639
16640 // free memory
16641
16642 local_free (masks);
16643
16644 local_free (dictstat_base);
16645
16646 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16647 {
16648 pot_t *pot_ptr = &pot[pot_pos];
16649
16650 hash_t *hash = &pot_ptr->hash;
16651
16652 local_free (hash->digest);
16653
16654 if (isSalted)
16655 {
16656 local_free (hash->salt);
16657 }
16658 }
16659
16660 local_free (pot);
16661
16662 local_free (all_kernel_rules_cnt);
16663 local_free (all_kernel_rules_buf);
16664
16665 local_free (wl_data->buf);
16666 local_free (wl_data);
16667
16668 local_free (bitmap_s1_a);
16669 local_free (bitmap_s1_b);
16670 local_free (bitmap_s1_c);
16671 local_free (bitmap_s1_d);
16672 local_free (bitmap_s2_a);
16673 local_free (bitmap_s2_b);
16674 local_free (bitmap_s2_c);
16675 local_free (bitmap_s2_d);
16676
16677 #ifdef HAVE_HWMON
16678 local_free (temp_retain_fanspeed_value);
16679 #ifdef HAVE_ADL
16680 local_free (od_clock_mem_status);
16681 local_free (od_power_control_status);
16682 #endif // ADL
16683 #endif
16684
16685 global_free (devices_param);
16686
16687 global_free (kernel_rules_buf);
16688
16689 global_free (root_css_buf);
16690 global_free (markov_css_buf);
16691
16692 global_free (digests_buf);
16693 global_free (digests_shown);
16694 global_free (digests_shown_tmp);
16695
16696 global_free (salts_buf);
16697 global_free (salts_shown);
16698
16699 global_free (esalts_buf);
16700
16701 global_free (words_progress_done);
16702 global_free (words_progress_rejected);
16703 global_free (words_progress_restored);
16704
16705 if (pot_fp) fclose (pot_fp);
16706
16707 if (data.devices_status == STATUS_QUIT) break;
16708 }
16709
16710 // destroy others mutex
16711
16712 hc_thread_mutex_delete (mux_dispatcher);
16713 hc_thread_mutex_delete (mux_counter);
16714 hc_thread_mutex_delete (mux_display);
16715 hc_thread_mutex_delete (mux_adl);
16716
16717 // free memory
16718
16719 local_free (eff_restore_file);
16720 local_free (new_restore_file);
16721
16722 local_free (rd);
16723
16724 // tuning db
16725
16726 tuning_db_destroy (tuning_db);
16727
16728 // loopback
16729
16730 local_free (loopback_file);
16731
16732 if (loopback == 1) unlink (loopback_file);
16733
16734 // induction directory
16735
16736 if (induction_dir == NULL)
16737 {
16738 if (attack_mode != ATTACK_MODE_BF)
16739 {
16740 if (rmdir (induction_directory) == -1)
16741 {
16742 if (errno == ENOENT)
16743 {
16744 // good, we can ignore
16745 }
16746 else if (errno == ENOTEMPTY)
16747 {
16748 // good, we can ignore
16749 }
16750 else
16751 {
16752 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16753
16754 return (-1);
16755 }
16756 }
16757
16758 local_free (induction_directory);
16759 }
16760 }
16761
16762 // outfile-check directory
16763
16764 if (outfile_check_dir == NULL)
16765 {
16766 if (rmdir (outfile_check_directory) == -1)
16767 {
16768 if (errno == ENOENT)
16769 {
16770 // good, we can ignore
16771 }
16772 else if (errno == ENOTEMPTY)
16773 {
16774 // good, we can ignore
16775 }
16776 else
16777 {
16778 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16779
16780 return (-1);
16781 }
16782 }
16783
16784 local_free (outfile_check_directory);
16785 }
16786
16787 time_t proc_stop;
16788
16789 time (&proc_stop);
16790
16791 logfile_top_uint (proc_start);
16792 logfile_top_uint (proc_stop);
16793
16794 logfile_top_msg ("STOP");
16795
16796 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16797 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16798
16799 if (data.ocl) ocl_close (data.ocl);
16800
16801 if (data.devices_status == STATUS_ABORTED) return 2;
16802 if (data.devices_status == STATUS_QUIT) return 2;
16803 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16804 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16805 if (data.devices_status == STATUS_CRACKED) return 0;
16806
16807 return -1;
16808 }
Hashcat additions to support pwdhash