projects / hashcat.git / blob
? search:


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