projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #207 from gm4tr1x/clEnqueueNDRangeKernelMod
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 #ifndef OSX
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 #else
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
397 #endif
398 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
399 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
400 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
401 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
402 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
403 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
404 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 #ifdef HAVE_HWMON
407 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
408 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
409 #ifdef HAVE_ADL
410 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
411 #endif
412 #endif
413 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
414 "",
415 "* Distributed:",
416 "",
417 " -s, --skip=NUM Skip number of words",
418 " -l, --limit=NUM Limit number of words",
419 " --keyspace Show keyspace base:mod values and quit",
420 "",
421 "* Rules:",
422 "",
423 " -j, --rule-left=RULE Single rule applied to each word from left dict",
424 " -k, --rule-right=RULE Single rule applied to each word from right dict",
425 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
426 " -g, --generate-rules=NUM Generate NUM random rules",
427 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
428 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
429 " --generate-rules-seed=NUM Force RNG seed to NUM",
430 "",
431 "* Custom charsets:",
432 "",
433 " -1, --custom-charset1=CS User-defined charsets",
434 " -2, --custom-charset2=CS Example:",
435 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
436 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
437 "",
438 "* Increment:",
439 "",
440 " -i, --increment Enable increment mode",
441 " --increment-min=NUM Start incrementing at NUM",
442 " --increment-max=NUM Stop incrementing at NUM",
443 "",
444 "==========",
445 "References",
446 "==========",
447 "",
448 "* Workload Profile:",
449 "",
450 " 1 = Reduced performance profile (low latency desktop)",
451 " 2 = Default performance profile",
452 " 3 = Tuned performance profile (high latency desktop)",
453 "",
454 "* Benchmark Settings:",
455 "",
456 " 0 = Manual Tuning",
457 " 1 = Performance Tuning, default",
458 "",
459 "* OpenCL device-types:",
460 "",
461 " 1 = CPU devices",
462 " 2 = GPU devices",
463 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
464 "",
465 "* Outfile Formats:",
466 "",
467 " 1 = hash[:salt]",
468 " 2 = plain",
469 " 3 = hash[:salt]:plain",
470 " 4 = hex_plain",
471 " 5 = hash[:salt]:hex_plain",
472 " 6 = plain:hex_plain",
473 " 7 = hash[:salt]:plain:hex_plain",
474 " 8 = crackpos",
475 " 9 = hash[:salt]:crackpos",
476 " 10 = plain:crackpos",
477 " 11 = hash[:salt]:plain:crackpos",
478 " 12 = hex_plain:crackpos",
479 " 13 = hash[:salt]:hex_plain:crackpos",
480 " 14 = plain:hex_plain:crackpos",
481 " 15 = hash[:salt]:plain:hex_plain:crackpos",
482 "",
483 "* Debug mode output formats (for hybrid mode only, by using rules):",
484 "",
485 " 1 = save finding rule",
486 " 2 = save original word",
487 " 3 = save original word and finding rule",
488 " 4 = save original word, finding rule and modified plain",
489 "",
490 "* Built-in charsets:",
491 "",
492 " ?l = abcdefghijklmnopqrstuvwxyz",
493 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
494 " ?d = 0123456789",
495 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
496 " ?a = ?l?u?d?s",
497 " ?b = 0x00 - 0xff",
498 "",
499 "* Attack modes:",
500 "",
501 " 0 = Straight",
502 " 1 = Combination",
503 " 3 = Brute-force",
504 " 6 = Hybrid dict + mask",
505 " 7 = Hybrid mask + dict",
506 "",
507 "* Hash types:",
508 "",
509 "[[ Roll-your-own: Raw Hashes ]]",
510 "",
511 " 900 = MD4",
512 " 0 = MD5",
513 " 5100 = Half MD5",
514 " 100 = SHA1",
515 " 10800 = SHA-384",
516 " 1400 = SHA-256",
517 " 1700 = SHA-512",
518 " 5000 = SHA-3(Keccak)",
519 " 10100 = SipHash",
520 " 6000 = RipeMD160",
521 " 6100 = Whirlpool",
522 " 6900 = GOST R 34.11-94",
523 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
524 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
525 "",
526 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
527 "",
528 " 10 = md5($pass.$salt)",
529 " 20 = md5($salt.$pass)",
530 " 30 = md5(unicode($pass).$salt)",
531 " 40 = md5($salt.unicode($pass))",
532 " 3800 = md5($salt.$pass.$salt)",
533 " 3710 = md5($salt.md5($pass))",
534 " 2600 = md5(md5($pass)",
535 " 4300 = md5(strtoupper(md5($pass)))",
536 " 4400 = md5(sha1($pass))",
537 " 110 = sha1($pass.$salt)",
538 " 120 = sha1($salt.$pass)",
539 " 130 = sha1(unicode($pass).$salt)",
540 " 140 = sha1($salt.unicode($pass))",
541 " 4500 = sha1(sha1($pass)",
542 " 4700 = sha1(md5($pass))",
543 " 4900 = sha1($salt.$pass.$salt)",
544 " 1410 = sha256($pass.$salt)",
545 " 1420 = sha256($salt.$pass)",
546 " 1430 = sha256(unicode($pass).$salt)",
547 " 1440 = sha256($salt.unicode($pass))",
548 " 1710 = sha512($pass.$salt)",
549 " 1720 = sha512($salt.$pass)",
550 " 1730 = sha512(unicode($pass).$salt)",
551 " 1740 = sha512($salt.unicode($pass))",
552 "",
553 "[[ Roll-your-own: Authenticated Hashes ]]",
554 "",
555 " 50 = HMAC-MD5 (key = $pass)",
556 " 60 = HMAC-MD5 (key = $salt)",
557 " 150 = HMAC-SHA1 (key = $pass)",
558 " 160 = HMAC-SHA1 (key = $salt)",
559 " 1450 = HMAC-SHA256 (key = $pass)",
560 " 1460 = HMAC-SHA256 (key = $salt)",
561 " 1750 = HMAC-SHA512 (key = $pass)",
562 " 1760 = HMAC-SHA512 (key = $salt)",
563 "",
564 "[[ Generic KDF ]]",
565 "",
566 " 400 = phpass",
567 " 8900 = scrypt",
568 " 11900 = PBKDF2-HMAC-MD5",
569 " 12000 = PBKDF2-HMAC-SHA1",
570 " 10900 = PBKDF2-HMAC-SHA256",
571 " 12100 = PBKDF2-HMAC-SHA512",
572 "",
573 "[[ Network protocols, Challenge-Response ]]",
574 "",
575 " 23 = Skype",
576 " 2500 = WPA/WPA2",
577 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
578 " 5300 = IKE-PSK MD5",
579 " 5400 = IKE-PSK SHA1",
580 " 5500 = NetNTLMv1",
581 " 5500 = NetNTLMv1 + ESS",
582 " 5600 = NetNTLMv2",
583 " 7300 = IPMI2 RAKP HMAC-SHA1",
584 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
585 " 8300 = DNSSEC (NSEC3)",
586 " 10200 = Cram MD5",
587 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
588 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
589 " 11400 = SIP digest authentication (MD5)",
590 "",
591 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
592 "",
593 " 121 = SMF (Simple Machines Forum)",
594 " 400 = phpBB3",
595 " 2611 = vBulletin < v3.8.5",
596 " 2711 = vBulletin > v3.8.5",
597 " 2811 = MyBB",
598 " 2811 = IPB (Invison Power Board)",
599 " 8400 = WBB3 (Woltlab Burning Board)",
600 " 11 = Joomla < 2.5.18",
601 " 400 = Joomla > 2.5.18",
602 " 400 = Wordpress",
603 " 2612 = PHPS",
604 " 7900 = Drupal7",
605 " 21 = osCommerce",
606 " 21 = xt:Commerce",
607 " 11000 = PrestaShop",
608 " 124 = Django (SHA-1)",
609 " 10000 = Django (PBKDF2-SHA256)",
610 " 3711 = Mediawiki B type",
611 " 7600 = Redmine",
612 "",
613 "[[ Database Server ]]",
614 "",
615 " 12 = PostgreSQL",
616 " 131 = MSSQL(2000)",
617 " 132 = MSSQL(2005)",
618 " 1731 = MSSQL(2012)",
619 " 1731 = MSSQL(2014)",
620 " 200 = MySQL323",
621 " 300 = MySQL4.1/MySQL5",
622 " 3100 = Oracle H: Type (Oracle 7+)",
623 " 112 = Oracle S: Type (Oracle 11+)",
624 " 12300 = Oracle T: Type (Oracle 12+)",
625 " 8000 = Sybase ASE",
626 "",
627 "[[ HTTP, SMTP, LDAP Server ]]",
628 "",
629 " 141 = EPiServer 6.x < v4",
630 " 1441 = EPiServer 6.x > v4",
631 " 1600 = Apache $apr1$",
632 " 12600 = ColdFusion 10+",
633 " 1421 = hMailServer",
634 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
635 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
636 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
637 "",
638 "[[ Checksums ]]",
639 "",
640 " 11500 = CRC32",
641 "",
642 "[[ Operating-Systems ]]",
643 "",
644 " 3000 = LM",
645 " 1000 = NTLM",
646 " 1100 = Domain Cached Credentials (DCC), MS Cache",
647 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
648 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
649 " 1500 = descrypt, DES(Unix), Traditional DES",
650 " 12400 = BSDiCrypt, Extended DES",
651 " 500 = md5crypt $1$, MD5(Unix)",
652 " 3200 = bcrypt $2*$, Blowfish(Unix)",
653 " 7400 = sha256crypt $5$, SHA256(Unix)",
654 " 1800 = sha512crypt $6$, SHA512(Unix)",
655 " 122 = OSX v10.4",
656 " 122 = OSX v10.5",
657 " 122 = OSX v10.6",
658 " 1722 = OSX v10.7",
659 " 7100 = OSX v10.8",
660 " 7100 = OSX v10.9",
661 " 7100 = OSX v10.10",
662 " 6300 = AIX {smd5}",
663 " 6700 = AIX {ssha1}",
664 " 6400 = AIX {ssha256}",
665 " 6500 = AIX {ssha512}",
666 " 2400 = Cisco-PIX",
667 " 2410 = Cisco-ASA",
668 " 500 = Cisco-IOS $1$",
669 " 5700 = Cisco-IOS $4$",
670 " 9200 = Cisco-IOS $8$",
671 " 9300 = Cisco-IOS $9$",
672 " 22 = Juniper Netscreen/SSG (ScreenOS)",
673 " 501 = Juniper IVE",
674 " 5800 = Android PIN",
675 " 8100 = Citrix Netscaler",
676 " 8500 = RACF",
677 " 7200 = GRUB 2",
678 " 9900 = Radmin2",
679 "",
680 "[[ Enterprise Application Software (EAS) ]]",
681 "",
682 " 7700 = SAP CODVN B (BCODE)",
683 " 7800 = SAP CODVN F/G (PASSCODE)",
684 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
685 " 8600 = Lotus Notes/Domino 5",
686 " 8700 = Lotus Notes/Domino 6",
687 " 9100 = Lotus Notes/Domino 8",
688 " 133 = PeopleSoft",
689 "",
690 "[[ Archives ]]",
691 "",
692 " 11600 = 7-Zip",
693 " 12500 = RAR3-hp",
694 " 13000 = RAR5",
695 "",
696 "[[ Full-Disk encryptions (FDE) ]]",
697 "",
698 " 62XY = TrueCrypt 5.0+",
699 " X = 1 = PBKDF2-HMAC-RipeMD160",
700 " X = 2 = PBKDF2-HMAC-SHA512",
701 " X = 3 = PBKDF2-HMAC-Whirlpool",
702 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
703 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
704 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
705 " Y = 3 = XTS 1536 bit (Ciphers: All)",
706 " 8800 = Android FDE < v4.3",
707 " 12900 = Android FDE (Samsung DEK)",
708 " 12200 = eCryptfs",
709 "",
710 "[[ Documents ]]",
711 "",
712 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
713 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
714 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
715 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
716 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
717 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
718 " 9400 = MS Office 2007",
719 " 9500 = MS Office 2010",
720 " 9600 = MS Office 2013",
721 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
722 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
723 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
724 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
725 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
726 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
727 "",
728 "[[ Password Managers ]]",
729 "",
730 " 9000 = Password Safe v2",
731 " 5200 = Password Safe v3",
732 " 6800 = Lastpass",
733 " 6600 = 1Password, agilekeychain",
734 " 8200 = 1Password, cloudkeychain",
735 " 11300 = Bitcoin/Litecoin wallet.dat",
736 " 12700 = Blockchain, My Wallet",
737 "",
738 NULL
739 };
740
741 /**
742 * oclHashcat specific functions
743 */
744
745 void status_display_automat ()
746 {
747 FILE *out = stdout;
748
749 fprintf (out, "STATUS\t%u\t", data.devices_status);
750
751 /**
752 * speed new
753 */
754
755 fprintf (out, "SPEED\t");
756
757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
758 {
759 hc_device_param_t *device_param = &data.devices_param[device_id];
760
761 if (device_param->skipped) continue;
762
763 u64 speed_cnt = 0;
764 float speed_ms = 0;
765
766 for (int i = 0; i < SPEED_CACHE; i++)
767 {
768 float rec_ms;
769
770 hc_timer_get (device_param->speed_rec[i], rec_ms);
771
772 if (rec_ms > SPEED_MAXAGE) continue;
773
774 speed_cnt += device_param->speed_cnt[i];
775 speed_ms += device_param->speed_ms[i];
776 }
777
778 speed_cnt /= SPEED_CACHE;
779 speed_ms /= SPEED_CACHE;
780
781 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
782 }
783
784 /**
785 * words_cur
786 */
787
788 u64 words_cur = get_lowest_words_done ();
789
790 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
791
792 /**
793 * counter
794 */
795
796 uint salts_left = data.salts_cnt - data.salts_done;
797
798 if (salts_left == 0) salts_left = 1;
799
800 u64 progress_total = data.words_cnt * salts_left;
801
802 u64 all_done = 0;
803 u64 all_rejected = 0;
804 u64 all_restored = 0;
805
806 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
807 {
808 if (salts_left > 1)
809 {
810 // otherwise the final cracked status shows 0/XXX progress
811
812 if (data.salts_shown[salt_pos] == 1) continue;
813 }
814
815 all_done += data.words_progress_done[salt_pos];
816 all_rejected += data.words_progress_rejected[salt_pos];
817 all_restored += data.words_progress_restored[salt_pos];
818 }
819
820 u64 progress_cur = all_restored + all_done + all_rejected;
821 u64 progress_end = progress_total;
822
823 u64 progress_skip = 0;
824
825 if (data.skip)
826 {
827 progress_skip = MIN (data.skip, data.words_base) * salts_left;
828
829 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
830 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
831 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
832 }
833
834 if (data.limit)
835 {
836 progress_end = MIN (data.limit, data.words_base) * salts_left;
837
838 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
839 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
840 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
841 }
842
843 u64 progress_cur_relative_skip = progress_cur - progress_skip;
844 u64 progress_end_relative_skip = progress_end - progress_skip;
845
846 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
847
848 /**
849 * cracks
850 */
851
852 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
853 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
854
855 /**
856 * temperature
857 */
858
859 #ifdef HAVE_HWMON
860 if (data.gpu_temp_disable == 0)
861 {
862 fprintf (out, "TEMP\t");
863
864 hc_thread_mutex_lock (mux_adl);
865
866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
867 {
868 hc_device_param_t *device_param = &data.devices_param[device_id];
869
870 if (device_param->skipped) continue;
871
872 int temp = hm_get_temperature_with_device_id (device_id);
873
874 fprintf (out, "%d\t", temp);
875 }
876
877 hc_thread_mutex_unlock (mux_adl);
878 }
879 #endif // HAVE_HWMON
880
881 #ifdef _WIN
882 fputc ('\r', out);
883 fputc ('\n', out);
884 #endif
885
886 #ifdef _POSIX
887 fputc ('\n', out);
888 #endif
889
890 fflush (out);
891 }
892
893 void status_display ()
894 {
895 if (data.devices_status == STATUS_INIT) return;
896 if (data.devices_status == STATUS_STARTING) return;
897 if (data.devices_status == STATUS_BYPASS) return;
898
899 if (data.status_automat == 1)
900 {
901 status_display_automat ();
902
903 return;
904 }
905
906 char tmp_buf[1000] = { 0 };
907
908 uint tmp_len = 0;
909
910 log_info ("Session.Name...: %s", data.session);
911
912 char *status_type = strstatus (data.devices_status);
913
914 uint hash_mode = data.hash_mode;
915
916 char *hash_type = strhashtype (hash_mode); // not a bug
917
918 log_info ("Status.........: %s", status_type);
919
920 /**
921 * show rules
922 */
923
924 if (data.rp_files_cnt)
925 {
926 uint i;
927
928 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
929 {
930 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
931 }
932
933 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
934
935 log_info ("Rules.Type.....: %s", tmp_buf);
936
937 tmp_len = 0;
938 }
939
940 if (data.rp_gen)
941 {
942 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
943
944 if (data.rp_gen_seed)
945 {
946 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
947 }
948 }
949
950 /**
951 * show input
952 */
953
954 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
955 {
956 if (data.wordlist_mode == WL_MODE_FILE)
957 {
958 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
959 }
960 else if (data.wordlist_mode == WL_MODE_STDIN)
961 {
962 log_info ("Input.Mode.....: Pipe");
963 }
964 }
965 else if (data.attack_mode == ATTACK_MODE_COMBI)
966 {
967 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
968 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
969 }
970 else if (data.attack_mode == ATTACK_MODE_BF)
971 {
972 char *mask = data.mask;
973
974 if (mask != NULL)
975 {
976 uint mask_len = data.css_cnt;
977
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
979
980 if (mask_len > 0)
981 {
982 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
983 {
984 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
985 {
986 mask_len -= data.salts_buf[0].salt_len;
987 }
988 }
989
990 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
991
992 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
993 }
994
995 if (data.maskcnt > 1)
996 {
997 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1000 }
1001
1002 log_info ("Input.Mode.....: %s", tmp_buf);
1003 }
1004
1005 tmp_len = 0;
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1008 {
1009 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1010 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1013 {
1014 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1015 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1016 }
1017
1018 if (data.digests_cnt == 1)
1019 {
1020 if (data.hash_mode == 2500)
1021 {
1022 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1023
1024 uint pke[25] = { 0 };
1025
1026 char *pke_ptr = (char *) pke;
1027
1028 for (uint i = 0; i < 25; i++)
1029 {
1030 pke[i] = byte_swap_32 (wpa->pke[i]);
1031 }
1032
1033 char mac1[6] = { 0 };
1034 char mac2[6] = { 0 };
1035
1036 memcpy (mac1, pke_ptr + 23, 6);
1037 memcpy (mac2, pke_ptr + 29, 6);
1038
1039 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1040 (char *) data.salts_buf[0].salt_buf,
1041 mac1[0] & 0xff,
1042 mac1[1] & 0xff,
1043 mac1[2] & 0xff,
1044 mac1[3] & 0xff,
1045 mac1[4] & 0xff,
1046 mac1[5] & 0xff,
1047 mac2[0] & 0xff,
1048 mac2[1] & 0xff,
1049 mac2[2] & 0xff,
1050 mac2[3] & 0xff,
1051 mac2[4] & 0xff,
1052 mac2[5] & 0xff);
1053 }
1054 else if (data.hash_mode == 5200)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if (data.hash_mode == 9000)
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else
1067 {
1068 char out_buf[4096] = { 0 };
1069
1070 ascii_digest (out_buf, 0, 0);
1071
1072 // limit length
1073 if (strlen (out_buf) > 40)
1074 {
1075 out_buf[41] = '.';
1076 out_buf[42] = '.';
1077 out_buf[43] = '.';
1078 out_buf[44] = 0;
1079 }
1080
1081 log_info ("Hash.Target....: %s", out_buf);
1082 }
1083 }
1084 else
1085 {
1086 if (data.hash_mode == 3000)
1087 {
1088 char out_buf1[4096] = { 0 };
1089 char out_buf2[4096] = { 0 };
1090
1091 ascii_digest (out_buf1, 0, 0);
1092 ascii_digest (out_buf2, 0, 1);
1093
1094 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1095 }
1096 else
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 }
1101
1102 log_info ("Hash.Type......: %s", hash_type);
1103
1104 /**
1105 * speed new
1106 */
1107
1108 u64 speed_cnt[DEVICES_MAX] = { 0 };
1109 float speed_ms[DEVICES_MAX] = { 0 };
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hc_device_param_t *device_param = &data.devices_param[device_id];
1114
1115 if (device_param->skipped) continue;
1116
1117 // we need to clear values (set to 0) because in case the device does
1118 // not get new candidates it idles around but speed display would
1119 // show it as working.
1120 // if we instantly set it to 0 after reading it happens that the
1121 // speed can be shown as zero if the users refreshes too fast.
1122 // therefore, we add a timestamp when a stat was recorded and if its
1123 // too old we will not use it
1124
1125 speed_cnt[device_id] = 0;
1126 speed_ms[device_id] = 0;
1127
1128 for (int i = 0; i < SPEED_CACHE; i++)
1129 {
1130 float rec_ms;
1131
1132 hc_timer_get (device_param->speed_rec[i], rec_ms);
1133
1134 if (rec_ms > SPEED_MAXAGE) continue;
1135
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 float hashes_all_ms = 0;
1145
1146 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * timers
1166 */
1167
1168 float ms_running = 0;
1169
1170 hc_timer_get (data.timer_running, ms_running);
1171
1172 float ms_paused = data.ms_paused;
1173
1174 if (data.devices_status == STATUS_PAUSED)
1175 {
1176 float ms_paused_tmp = 0;
1177
1178 hc_timer_get (data.timer_paused, ms_paused_tmp);
1179
1180 ms_paused += ms_paused_tmp;
1181 }
1182
1183 #ifdef WIN
1184
1185 __time64_t sec_run = ms_running / 1000;
1186
1187 #else
1188
1189 time_t sec_run = ms_running / 1000;
1190
1191 #endif
1192
1193 if (sec_run)
1194 {
1195 char display_run[32] = { 0 };
1196
1197 struct tm tm_run;
1198
1199 struct tm *tmp = NULL;
1200
1201 #ifdef WIN
1202
1203 tmp = _gmtime64 (&sec_run);
1204
1205 #else
1206
1207 tmp = gmtime (&sec_run);
1208
1209 #endif
1210
1211 if (tmp != NULL)
1212 {
1213 memset (&tm_run, 0, sizeof (tm_run));
1214
1215 memcpy (&tm_run, tmp, sizeof (tm_run));
1216
1217 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1218
1219 char *start = ctime (&data.proc_start);
1220
1221 size_t start_len = strlen (start);
1222
1223 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1224 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1225
1226 log_info ("Time.Started...: %s (%s)", start, display_run);
1227 }
1228 }
1229 else
1230 {
1231 log_info ("Time.Started...: 0 secs");
1232 }
1233
1234 /**
1235 * counters
1236 */
1237
1238 uint salts_left = data.salts_cnt - data.salts_done;
1239
1240 if (salts_left == 0) salts_left = 1;
1241
1242 u64 progress_total = data.words_cnt * salts_left;
1243
1244 u64 all_done = 0;
1245 u64 all_rejected = 0;
1246 u64 all_restored = 0;
1247
1248 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1249 {
1250 if (salts_left > 1)
1251 {
1252 // otherwise the final cracked status shows 0/XXX progress
1253
1254 if (data.salts_shown[salt_pos] == 1) continue;
1255 }
1256
1257 all_done += data.words_progress_done[salt_pos];
1258 all_rejected += data.words_progress_rejected[salt_pos];
1259 all_restored += data.words_progress_restored[salt_pos];
1260 }
1261
1262 u64 progress_cur = all_restored + all_done + all_rejected;
1263 u64 progress_end = progress_total;
1264
1265 u64 progress_skip = 0;
1266
1267 if (data.skip)
1268 {
1269 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1270
1271 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1272 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1273 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1274 }
1275
1276 if (data.limit)
1277 {
1278 progress_end = MIN (data.limit, data.words_base) * salts_left;
1279
1280 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1281 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1282 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1283 }
1284
1285 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1286 u64 progress_end_relative_skip = progress_end - progress_skip;
1287
1288 float speed_ms_real = ms_running - ms_paused;
1289 u64 speed_plains_real = all_done;
1290
1291 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1292 {
1293 if (data.devices_status != STATUS_CRACKED)
1294 {
1295 u64 words_per_ms = 0;
1296
1297 if (speed_plains_real && speed_ms_real)
1298 {
1299 words_per_ms = speed_plains_real / speed_ms_real;
1300 }
1301
1302 #ifdef WIN
1303 __time64_t sec_etc = 0;
1304 #else
1305 time_t sec_etc = 0;
1306 #endif
1307
1308 if (words_per_ms)
1309 {
1310 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1311
1312 u64 ms_left = progress_left_relative_skip / words_per_ms;
1313
1314 sec_etc = ms_left / 1000;
1315 }
1316
1317 if (sec_etc == 0)
1318 {
1319 log_info ("Time.Estimated.: 0 secs");
1320 }
1321 else if ((u64) sec_etc > ETC_MAX)
1322 {
1323 log_info ("Time.Estimated.: > 10 Years");
1324 }
1325 else
1326 {
1327 char display_etc[32] = { 0 };
1328
1329 struct tm tm_etc;
1330
1331 struct tm *tmp = NULL;
1332
1333 #ifdef WIN
1334
1335 tmp = _gmtime64 (&sec_etc);
1336
1337 #else
1338
1339 tmp = gmtime (&sec_etc);
1340
1341 #endif
1342
1343 if (tmp != NULL)
1344 {
1345 memset (&tm_etc, 0, sizeof (tm_etc));
1346
1347 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1348
1349 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1350
1351 time_t now;
1352
1353 time (&now);
1354
1355 now += sec_etc;
1356
1357 char *etc = ctime (&now);
1358
1359 size_t etc_len = strlen (etc);
1360
1361 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1362 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1363
1364 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1365 }
1366 }
1367 }
1368 }
1369
1370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1371 {
1372 hc_device_param_t *device_param = &data.devices_param[device_id];
1373
1374 if (device_param->skipped) continue;
1375
1376 char display_dev_cur[16] = { 0 };
1377
1378 strncpy (display_dev_cur, "0.00", 4);
1379
1380 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1381
1382 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1383 }
1384
1385 char display_all_cur[16] = { 0 };
1386
1387 strncpy (display_all_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1390
1391 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1392
1393 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1394 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1395
1396 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1397
1398 // crack-per-time
1399
1400 if (data.digests_cnt > 100)
1401 {
1402 time_t now = time (NULL);
1403
1404 int cpt_cur_min = 0;
1405 int cpt_cur_hour = 0;
1406 int cpt_cur_day = 0;
1407
1408 for (int i = 0; i < CPT_BUF; i++)
1409 {
1410 const uint cracked = data.cpt_buf[i].cracked;
1411 const time_t timestamp = data.cpt_buf[i].timestamp;
1412
1413 if ((timestamp + 60) > now)
1414 {
1415 cpt_cur_min += cracked;
1416 }
1417
1418 if ((timestamp + 3600) > now)
1419 {
1420 cpt_cur_hour += cracked;
1421 }
1422
1423 if ((timestamp + 86400) > now)
1424 {
1425 cpt_cur_day += cracked;
1426 }
1427 }
1428
1429 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1430 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1431 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1432
1433 if ((data.cpt_start + 86400) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_cur_hour,
1438 cpt_cur_day,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else if ((data.cpt_start + 3600) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 60) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else
1461 {
1462 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 }
1468
1469 // Restore point
1470
1471 u64 restore_point = get_lowest_words_done ();
1472
1473 u64 restore_total = data.words_base;
1474
1475 float percent_restore = 0;
1476
1477 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1478
1479 if (progress_end_relative_skip)
1480 {
1481 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1482 {
1483 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1484 float percent_rejected = 0.0;
1485
1486 if (progress_cur)
1487 {
1488 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1489 }
1490
1491 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1492 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1493
1494 if (data.restore_disable == 0)
1495 {
1496 if (percent_finished != 1)
1497 {
1498 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1499 }
1500 }
1501 }
1502 }
1503 else
1504 {
1505 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1506 {
1507 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509
1510 if (data.restore_disable == 0)
1511 {
1512 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513 }
1514 }
1515 else
1516 {
1517 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1518 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1519
1520 // --restore not allowed if stdin is used -- really? why?
1521
1522 //if (data.restore_disable == 0)
1523 //{
1524 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1525 //}
1526 }
1527 }
1528
1529 #ifdef HAVE_HWMON
1530 if (data.gpu_temp_disable == 0)
1531 {
1532 hc_thread_mutex_lock (mux_adl);
1533
1534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1535 {
1536 hc_device_param_t *device_param = &data.devices_param[device_id];
1537
1538 if (device_param->skipped) continue;
1539
1540 #define HM_STR_BUF_SIZE 255
1541
1542 if (data.hm_device[device_id].fan_supported == 1)
1543 {
1544 char utilization[HM_STR_BUF_SIZE] = { 0 };
1545 char temperature[HM_STR_BUF_SIZE] = { 0 };
1546 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1547
1548 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1549 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1550
1551 if (device_param->vendor_id == VENDOR_ID_AMD)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555 else if (device_param->vendor_id == VENDOR_ID_NV)
1556 {
1557 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1558 }
1559
1560 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1561 }
1562 else
1563 {
1564 char utilization[HM_STR_BUF_SIZE] = { 0 };
1565 char temperature[HM_STR_BUF_SIZE] = { 0 };
1566
1567 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1568 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1569
1570 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1571 }
1572 }
1573
1574 hc_thread_mutex_unlock (mux_adl);
1575 }
1576 #endif // HAVE_HWMON
1577 }
1578
1579 static void status_benchmark ()
1580 {
1581 if (data.devices_status == STATUS_INIT) return;
1582 if (data.devices_status == STATUS_STARTING) return;
1583
1584 if (data.words_cnt == 0) return;
1585
1586 u64 speed_cnt[DEVICES_MAX] = { 0 };
1587 float speed_ms[DEVICES_MAX] = { 0 };
1588
1589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1590 {
1591 hc_device_param_t *device_param = &data.devices_param[device_id];
1592
1593 if (device_param->skipped) continue;
1594
1595 speed_cnt[device_id] = 0;
1596 speed_ms[device_id] = 0;
1597
1598 for (int i = 0; i < SPEED_CACHE; i++)
1599 {
1600 speed_cnt[device_id] += device_param->speed_cnt[i];
1601 speed_ms[device_id] += device_param->speed_ms[i];
1602 }
1603
1604 speed_cnt[device_id] /= SPEED_CACHE;
1605 speed_ms[device_id] /= SPEED_CACHE;
1606 }
1607
1608 float hashes_all_ms = 0;
1609
1610 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1611
1612 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1613 {
1614 hc_device_param_t *device_param = &data.devices_param[device_id];
1615
1616 if (device_param->skipped) continue;
1617
1618 hashes_dev_ms[device_id] = 0;
1619
1620 if (speed_ms[device_id])
1621 {
1622 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1623
1624 hashes_all_ms += hashes_dev_ms[device_id];
1625 }
1626 }
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 char display_dev_cur[16] = { 0 };
1635
1636 strncpy (display_dev_cur, "0.00", 4);
1637
1638 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1639
1640 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1641 }
1642
1643 char display_all_cur[16] = { 0 };
1644
1645 strncpy (display_all_cur, "0.00", 4);
1646
1647 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1648
1649 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1650 }
1651
1652 /**
1653 * oclHashcat -only- functions
1654 */
1655
1656 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1657 {
1658 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1659 {
1660 if (attack_kern == ATTACK_KERN_STRAIGHT)
1661 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1662 else if (attack_kern == ATTACK_KERN_COMBI)
1663 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1664 else if (attack_kern == ATTACK_KERN_BF)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1666 }
1667 else
1668 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1669 }
1670
1671 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)
1672 {
1673 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1674 {
1675 if (attack_kern == ATTACK_KERN_STRAIGHT)
1676 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1677 else if (attack_kern == ATTACK_KERN_COMBI)
1678 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1679 else if (attack_kern == ATTACK_KERN_BF)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 }
1682 else
1683 {
1684 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1685 }
1686 }
1687
1688 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1689 {
1690 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1691 {
1692 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1693 }
1694 else
1695 {
1696 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1697 }
1698 }
1699
1700 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)
1701 {
1702 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1703 {
1704 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1705 }
1706 else
1707 {
1708 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1709 }
1710 }
1711
1712 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1713 {
1714 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1715 }
1716
1717 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1718 {
1719 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1720 }
1721
1722 static uint convert_from_hex (char *line_buf, const uint line_len)
1723 {
1724 if (line_len & 1) return (line_len); // not in hex
1725
1726 if (data.hex_wordlist == 1)
1727 {
1728 uint i;
1729 uint j;
1730
1731 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1732 {
1733 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1734 }
1735
1736 memset (line_buf + i, 0, line_len - i);
1737
1738 return (i);
1739 }
1740 else if (line_len >= 6) // $HEX[] = 6
1741 {
1742 if (line_buf[0] != '$') return (line_len);
1743 if (line_buf[1] != 'H') return (line_len);
1744 if (line_buf[2] != 'E') return (line_len);
1745 if (line_buf[3] != 'X') return (line_len);
1746 if (line_buf[4] != '[') return (line_len);
1747 if (line_buf[line_len - 1] != ']') return (line_len);
1748
1749 uint i;
1750 uint j;
1751
1752 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1753 {
1754 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1755 }
1756
1757 memset (line_buf + i, 0, line_len - i);
1758
1759 return (i);
1760 }
1761
1762 return (line_len);
1763 }
1764
1765 static uint count_lines (FILE *fd)
1766 {
1767 uint cnt = 0;
1768
1769 char *buf = (char *) mymalloc (BUFSIZ + 1);
1770
1771 size_t nread_tmp = 0;
1772
1773 char *ptr = buf;
1774
1775 while (!feof (fd))
1776 {
1777 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1778 nread_tmp = nread;
1779
1780 if (nread < 1) continue;
1781
1782 ptr = buf;
1783
1784 do
1785 {
1786 if (*ptr++ == '\n') cnt++;
1787
1788 } while (nread--);
1789 }
1790
1791 // special case (if last line did not contain a newline char ... at the very end of the file)
1792
1793 if (nread_tmp > 3)
1794 {
1795 ptr -= 2;
1796
1797 if (*ptr != '\n')
1798 {
1799 ptr--;
1800
1801 if (*ptr != '\n') // needed ? different on windows systems?
1802 {
1803 cnt++;
1804 }
1805 }
1806 }
1807
1808 myfree (buf);
1809
1810 return cnt;
1811 }
1812
1813 static void clear_prompt ()
1814 {
1815 fputc ('\r', stdout);
1816
1817 for (size_t i = 0; i < strlen (PROMPT); i++)
1818 {
1819 fputc (' ', stdout);
1820 }
1821
1822 fputc ('\r', stdout);
1823
1824 fflush (stdout);
1825 }
1826
1827 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1828 {
1829 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);
1830 }
1831
1832 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1833 {
1834 char *outfile = data.outfile;
1835 uint quiet = data.quiet;
1836 FILE *pot_fp = data.pot_fp;
1837 uint loopback = data.loopback;
1838 uint debug_mode = data.debug_mode;
1839 char *debug_file = data.debug_file;
1840
1841 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1842 int debug_rule_len = 0; // -1 error
1843 uint debug_plain_len = 0;
1844
1845 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1846
1847 // hash
1848
1849 char out_buf[4096] = { 0 };
1850
1851 ascii_digest (out_buf, salt_pos, digest_pos);
1852
1853 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1854
1855 // plain
1856
1857 plain_t plain;
1858
1859 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);
1860
1861 uint gidvid = plain.gidvid;
1862 uint il_pos = plain.il_pos;
1863
1864 u64 crackpos = device_param->words_off;
1865
1866 uint plain_buf[16] = { 0 };
1867
1868 u8 *plain_ptr = (u8 *) plain_buf;
1869 unsigned int plain_len = 0;
1870
1871 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1872 {
1873 u64 gidd = gidvid;
1874 u64 gidm = 0;
1875
1876 pw_t pw;
1877
1878 gidd_to_pw_t (device_param, gidd, &pw);
1879
1880 for (int i = 0, j = gidm; i < 16; i++, j++)
1881 {
1882 plain_buf[i] = pw.h.hi1[0][j];
1883 }
1884
1885 plain_len = pw.pw_len;
1886
1887 const uint off = device_param->innerloop_pos + il_pos;
1888
1889 if (debug_mode > 0)
1890 {
1891 debug_rule_len = 0;
1892
1893 // save rule
1894 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1897
1898 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1899 }
1900
1901 // save plain
1902 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1903 {
1904 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1905
1906 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1907
1908 debug_plain_len = plain_len;
1909 }
1910 }
1911
1912 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1913
1914 crackpos += gidvid;
1915 crackpos *= data.kernel_rules_cnt;
1916 crackpos += device_param->innerloop_pos + il_pos;
1917
1918 if (plain_len > data.pw_max) plain_len = data.pw_max;
1919 }
1920 else if (data.attack_mode == ATTACK_MODE_COMBI)
1921 {
1922 u64 gidd = gidvid;
1923 u64 gidm = 0;
1924
1925 pw_t pw;
1926
1927 gidd_to_pw_t (device_param, gidd, &pw);
1928
1929 for (int i = 0, j = gidm; i < 16; i++, j++)
1930 {
1931 plain_buf[i] = pw.h.hi1[0][j];
1932 }
1933
1934 plain_len = pw.pw_len;
1935
1936 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1937 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1938
1939 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1940 {
1941 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1942 }
1943 else
1944 {
1945 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1946
1947 memcpy (plain_ptr, comb_buf, comb_len);
1948 }
1949
1950 plain_len += comb_len;
1951
1952 crackpos += gidvid;
1953 crackpos *= data.combs_cnt;
1954 crackpos += device_param->innerloop_pos + il_pos;
1955
1956 if (data.pw_max != PW_DICTMAX1)
1957 {
1958 if (plain_len > data.pw_max) plain_len = data.pw_max;
1959 }
1960 }
1961 else if (data.attack_mode == ATTACK_MODE_BF)
1962 {
1963 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1964 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1965
1966 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1967 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1968
1969 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1970 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1971
1972 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1973 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1974
1975 plain_len = data.css_cnt;
1976
1977 crackpos += gidvid;
1978 crackpos *= data.bfs_cnt;
1979 crackpos += device_param->innerloop_pos + il_pos;
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1982 {
1983 u64 gidd = gidvid;
1984 u64 gidm = 0;
1985
1986 pw_t pw;
1987
1988 gidd_to_pw_t (device_param, gidd, &pw);
1989
1990 for (int i = 0, j = gidm; i < 16; i++, j++)
1991 {
1992 plain_buf[i] = pw.h.hi1[0][j];
1993 }
1994
1995 plain_len = pw.pw_len;
1996
1997 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1998
1999 uint start = 0;
2000 uint stop = device_param->kernel_params_mp_buf32[4];
2001
2002 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2003
2004 plain_len += start + stop;
2005
2006 crackpos += gidvid;
2007 crackpos *= data.combs_cnt;
2008 crackpos += device_param->innerloop_pos + il_pos;
2009
2010 if (data.pw_max != PW_DICTMAX1)
2011 {
2012 if (plain_len > data.pw_max) plain_len = data.pw_max;
2013 }
2014 }
2015 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2016 {
2017 u64 gidd = gidvid;
2018 u64 gidm = 0;
2019
2020 pw_t pw;
2021
2022 gidd_to_pw_t (device_param, gidd, &pw);
2023
2024 for (int i = 0, j = gidm; i < 16; i++, j++)
2025 {
2026 plain_buf[i] = pw.h.hi1[0][j];
2027 }
2028
2029 plain_len = pw.pw_len;
2030
2031 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2032
2033 uint start = 0;
2034 uint stop = device_param->kernel_params_mp_buf32[4];
2035
2036 memmove (plain_ptr + stop, plain_ptr, plain_len);
2037
2038 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051
2052 if (data.attack_mode == ATTACK_MODE_BF)
2053 {
2054 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2055 {
2056 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2057 {
2058 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2059 {
2060 plain_len = plain_len - data.salts_buf[0].salt_len;
2061 }
2062 }
2063
2064 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2065 {
2066 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2067 {
2068 plain_ptr[j] = plain_ptr[i];
2069 }
2070
2071 plain_len = plain_len / 2;
2072 }
2073 }
2074 }
2075
2076 // if enabled, update also the potfile
2077
2078 if (pot_fp)
2079 {
2080 lock_file (pot_fp);
2081
2082 fprintf (pot_fp, "%s:", out_buf);
2083
2084 format_plain (pot_fp, plain_ptr, plain_len, 1);
2085
2086 fputc ('\n', pot_fp);
2087
2088 fflush (pot_fp);
2089
2090 unlock_file (pot_fp);
2091 }
2092
2093 // outfile
2094
2095 FILE *out_fp = NULL;
2096
2097 if (outfile != NULL)
2098 {
2099 if ((out_fp = fopen (outfile, "ab")) == NULL)
2100 {
2101 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2102
2103 out_fp = stdout;
2104 }
2105 lock_file (out_fp);
2106 }
2107 else
2108 {
2109 out_fp = stdout;
2110
2111 if (quiet == 0) clear_prompt ();
2112 }
2113
2114 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2115
2116 if (outfile != NULL)
2117 {
2118 if (out_fp != stdout)
2119 {
2120 fclose (out_fp);
2121 }
2122 }
2123 else
2124 {
2125 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2126 {
2127 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2128 {
2129 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2130 if (quiet == 0) fflush (stdout);
2131 }
2132 }
2133 }
2134
2135 // loopback
2136
2137 if (loopback)
2138 {
2139 char *loopback_file = data.loopback_file;
2140
2141 FILE *fb_fp = NULL;
2142
2143 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2144 {
2145 lock_file (fb_fp);
2146
2147 format_plain (fb_fp, plain_ptr, plain_len, 1);
2148
2149 fputc ('\n', fb_fp);
2150
2151 fclose (fb_fp);
2152 }
2153 }
2154
2155 // (rule) debug mode
2156
2157 // the next check implies that:
2158 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2159 // - debug_mode > 0
2160
2161 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2162 {
2163 if (debug_rule_len < 0) debug_rule_len = 0;
2164
2165 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2166
2167 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2168
2169 if ((quiet == 0) && (debug_file == NULL))
2170 {
2171 fprintf (stdout, "%s", PROMPT);
2172 fflush (stdout);
2173 }
2174 }
2175 }
2176
2177 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2178 {
2179 salt_t *salt_buf = &data.salts_buf[salt_pos];
2180
2181 int found = 0;
2182
2183 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);
2184
2185 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2186
2187 if (found == 1)
2188 {
2189 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2190
2191 log_info_nn ("");
2192
2193 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);
2194
2195 uint cpt_cracked = 0;
2196
2197 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2198 {
2199 uint idx = salt_buf->digests_offset + digest_pos;
2200
2201 if (data.digests_shown_tmp[idx] == 0) continue;
2202
2203 if (data.digests_shown[idx] == 1) continue;
2204
2205 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2206 {
2207 data.digests_shown[idx] = 1;
2208
2209 data.digests_done++;
2210
2211 cpt_cracked++;
2212
2213 salt_buf->digests_done++;
2214
2215 if (salt_buf->digests_done == salt_buf->digests_cnt)
2216 {
2217 data.salts_shown[salt_pos] = 1;
2218
2219 data.salts_done++;
2220 }
2221 }
2222
2223 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2224
2225 check_hash (device_param, salt_pos, digest_pos);
2226 }
2227
2228 if (cpt_cracked > 0)
2229 {
2230 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2231 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2232
2233 data.cpt_pos++;
2234
2235 data.cpt_total += cpt_cracked;
2236
2237 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2238 }
2239
2240 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2241 {
2242 // we need to reset cracked state on the device
2243 // otherwise host thinks again and again the hash was cracked
2244 // and returns invalid password each time
2245
2246 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2247
2248 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);
2249 }
2250
2251 memset (device_param->result, 0, device_param->size_results);
2252
2253 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);
2254 }
2255 }
2256
2257 static void save_hash ()
2258 {
2259 char *hashfile = data.hashfile;
2260
2261 char new_hashfile[256] = { 0 };
2262 char old_hashfile[256] = { 0 };
2263
2264 snprintf (new_hashfile, 255, "%s.new", hashfile);
2265 snprintf (old_hashfile, 255, "%s.old", hashfile);
2266
2267 unlink (new_hashfile);
2268
2269 char separator = data.separator;
2270
2271 FILE *fp = fopen (new_hashfile, "wb");
2272
2273 if (fp == NULL)
2274 {
2275 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2276
2277 exit (-1);
2278 }
2279
2280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2281 {
2282 if (data.salts_shown[salt_pos] == 1) continue;
2283
2284 salt_t *salt_buf = &data.salts_buf[salt_pos];
2285
2286 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2287 {
2288 uint idx = salt_buf->digests_offset + digest_pos;
2289
2290 if (data.digests_shown[idx] == 1) continue;
2291
2292 if (data.hash_mode != 2500)
2293 {
2294 char out_buf[4096] = { 0 };
2295
2296 if (data.username == 1)
2297 {
2298 user_t *user = data.hash_info[idx]->user;
2299
2300 uint i;
2301
2302 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2303
2304 fputc (separator, fp);
2305 }
2306
2307 ascii_digest (out_buf, salt_pos, digest_pos);
2308
2309 fputs (out_buf, fp);
2310
2311 log_out (fp, "");
2312 }
2313 else
2314 {
2315 hccap_t hccap;
2316
2317 to_hccap_t (&hccap, salt_pos, digest_pos);
2318
2319 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2320 }
2321 }
2322 }
2323
2324 fflush (fp);
2325
2326 fclose (fp);
2327
2328 unlink (old_hashfile);
2329
2330 if (rename (hashfile, old_hashfile) != 0)
2331 {
2332 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2333
2334 exit (-1);
2335 }
2336
2337 unlink (hashfile);
2338
2339 if (rename (new_hashfile, hashfile) != 0)
2340 {
2341 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2342
2343 exit (-1);
2344 }
2345
2346 unlink (old_hashfile);
2347 }
2348
2349 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2350 {
2351 // function called only in case kernel_blocks_all > words_left)
2352
2353 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2354
2355 kernel_blocks_div += kernel_blocks_div / 100;
2356
2357 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2358
2359 while (kernel_blocks_new < total_left)
2360 {
2361 kernel_blocks_div += kernel_blocks_div / 100;
2362
2363 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2364 }
2365
2366 if (data.quiet == 0)
2367 {
2368 clear_prompt ();
2369
2370 log_info ("");
2371
2372 log_info ("INFO: approaching final keyspace, workload adjusted");
2373
2374 log_info ("");
2375
2376 fprintf (stdout, "%s", PROMPT);
2377
2378 fflush (stdout);
2379 }
2380
2381 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2382
2383 return kernel_blocks_div;
2384 }
2385
2386 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2387 {
2388 uint num_elements = num;
2389
2390 device_param->kernel_params_buf32[30] = data.combs_mode;
2391 device_param->kernel_params_buf32[31] = num;
2392
2393 uint kernel_threads = device_param->kernel_threads;
2394
2395 while (num_elements % kernel_threads) num_elements++;
2396
2397 cl_kernel kernel = NULL;
2398
2399 switch (kern_run)
2400 {
2401 case KERN_RUN_1: kernel = device_param->kernel1; break;
2402 case KERN_RUN_12: kernel = device_param->kernel12; break;
2403 case KERN_RUN_2: kernel = device_param->kernel2; break;
2404 case KERN_RUN_23: kernel = device_param->kernel23; break;
2405 case KERN_RUN_3: kernel = device_param->kernel3; break;
2406 }
2407
2408 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2409 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2410 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2411 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2412 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2413 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2414 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2415 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2416 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2417 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2418 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2419
2420 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2421 {
2422 const size_t global_work_size[3] = { num_elements, 32, 1 };
2423 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2424
2425 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2426 }
2427 else
2428 {
2429 const size_t global_work_size[3] = { num_elements, 1, 1 };
2430 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2431
2432 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);
2433
2434 if (rc != CL_SUCCESS)
2435 {
2436 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2437
2438 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2439 }
2440 }
2441
2442 hc_clFlush (data.ocl, device_param->command_queue);
2443
2444 hc_clFinish (data.ocl, device_param->command_queue);
2445 }
2446
2447 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2448 {
2449 uint num_elements = num;
2450
2451 switch (kern_run)
2452 {
2453 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2454 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2455 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2456 }
2457
2458 // causes problems with special threads like in bcrypt
2459 // const uint kernel_threads = device_param->kernel_threads;
2460
2461 const uint kernel_threads = KERNEL_THREADS;
2462
2463 while (num_elements % kernel_threads) num_elements++;
2464
2465 cl_kernel kernel = NULL;
2466
2467 switch (kern_run)
2468 {
2469 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2470 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2471 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2472 }
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2477 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2478 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2479 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2480 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2481 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2482 break;
2483 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2484 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2485 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2486 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2487 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2488 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2489 break;
2490 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2491 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2492 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2493 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2494 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2495 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2496 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2497 break;
2498 }
2499
2500 const size_t global_work_size[3] = { num_elements, 1, 1 };
2501 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2502
2503 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);
2504
2505 if (rc != CL_SUCCESS)
2506 {
2507 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2508
2509 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2510 }
2511
2512 hc_clFlush (data.ocl, device_param->command_queue);
2513
2514 hc_clFinish (data.ocl, device_param->command_queue);
2515 }
2516
2517 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2518 {
2519 uint num_elements = num;
2520
2521 uint kernel_threads = device_param->kernel_threads;
2522
2523 while (num_elements % kernel_threads) num_elements++;
2524
2525 cl_kernel kernel = device_param->kernel_tb;
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 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);
2531
2532 if (rc != CL_SUCCESS)
2533 {
2534 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2535
2536 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2537 }
2538
2539 hc_clFlush (data.ocl, device_param->command_queue);
2540
2541 hc_clFinish (data.ocl, device_param->command_queue);
2542 }
2543
2544 static void run_kernel_tm (hc_device_param_t *device_param)
2545 {
2546 const uint num_elements = 1024; // fixed
2547
2548 const uint kernel_threads = 32;
2549
2550 cl_kernel kernel = device_param->kernel_tm;
2551
2552 const size_t global_work_size[3] = { num_elements, 1, 1 };
2553 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2554
2555 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);
2556
2557 if (rc != CL_SUCCESS)
2558 {
2559 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2562 }
2563
2564 hc_clFlush (data.ocl, device_param->command_queue);
2565
2566 hc_clFinish (data.ocl, device_param->command_queue);
2567 }
2568
2569 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2570 {
2571 uint num_elements = num;
2572
2573 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2574 device_param->kernel_params_amp_buf32[6] = num_elements;
2575
2576 // causes problems with special threads like in bcrypt
2577 // const uint kernel_threads = device_param->kernel_threads;
2578
2579 const uint kernel_threads = KERNEL_THREADS;
2580
2581 while (num_elements % kernel_threads) num_elements++;
2582
2583 cl_kernel kernel = device_param->kernel_amp;
2584
2585 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2586 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 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);
2592
2593 if (rc != CL_SUCCESS)
2594 {
2595 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2596
2597 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2598 }
2599
2600 hc_clFlush (data.ocl, device_param->command_queue);
2601
2602 hc_clFinish (data.ocl, device_param->command_queue);
2603 }
2604
2605 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2606 {
2607 int rc = -1;
2608
2609 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2610 {
2611 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2612
2613 const cl_uchar zero = 0;
2614
2615 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2616 }
2617
2618 if (rc != 0)
2619 {
2620 // NOTE: clEnqueueFillBuffer () always fails with -59
2621 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2622 // How's that possible, OpenCL 1.2 support is advertised??
2623 // We need to workaround...
2624
2625 #define FILLSZ 0x100000
2626
2627 char *tmp = (char *) mymalloc (FILLSZ);
2628
2629 for (uint i = 0; i < size; i += FILLSZ)
2630 {
2631 const int left = size - i;
2632
2633 const int fillsz = MIN (FILLSZ, left);
2634
2635 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2636 }
2637
2638 myfree (tmp);
2639 }
2640 }
2641
2642 static int run_rule_engine (const int rule_len, const char *rule_buf)
2643 {
2644 if (rule_len == 0)
2645 {
2646 return 0;
2647 }
2648 else if (rule_len == 1)
2649 {
2650 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2651 }
2652
2653 return 1;
2654 }
2655
2656 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2657 {
2658 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2659 {
2660 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);
2661 }
2662 else if (data.attack_kern == ATTACK_KERN_COMBI)
2663 {
2664 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);
2665 }
2666 else if (data.attack_kern == ATTACK_KERN_BF)
2667 {
2668 const u64 off = device_param->words_off;
2669
2670 device_param->kernel_params_mp_l_buf64[3] = off;
2671
2672 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2673 }
2674 }
2675
2676 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2677 {
2678 const uint kernel_loops = device_param->kernel_loops;
2679
2680 //only useful in debug
2681 //if (data.quiet == 0)
2682 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2683
2684 // init speed timer
2685
2686 uint speed_pos = device_param->speed_pos;
2687
2688 #ifdef _POSIX
2689 if (device_param->timer_speed.tv_sec == 0)
2690 {
2691 hc_timer_set (&device_param->timer_speed);
2692 }
2693 #endif
2694
2695 #ifdef _WIN
2696 if (device_param->timer_speed.QuadPart == 0)
2697 {
2698 hc_timer_set (&device_param->timer_speed);
2699 }
2700 #endif
2701
2702 // find higest password length, this is for optimization stuff
2703
2704 uint highest_pw_len = 0;
2705
2706 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2707 {
2708 }
2709 else if (data.attack_kern == ATTACK_KERN_COMBI)
2710 {
2711 }
2712 else if (data.attack_kern == ATTACK_KERN_BF)
2713 {
2714 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2715 + device_param->kernel_params_mp_l_buf32[5];
2716 }
2717
2718 // bitslice optimization stuff
2719
2720 if (data.attack_mode == ATTACK_MODE_BF)
2721 {
2722 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2723 {
2724 run_kernel_tb (device_param, pws_cnt);
2725 }
2726 }
2727
2728 // iteration type
2729
2730 uint innerloop_step = 0;
2731 uint innerloop_cnt = 0;
2732
2733 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2734 else innerloop_step = 1;
2735
2736 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2737 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2738 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2739
2740 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2741
2742 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2743 {
2744 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2745
2746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2747
2748 if (data.devices_status == STATUS_CRACKED) break;
2749 if (data.devices_status == STATUS_ABORTED) break;
2750 if (data.devices_status == STATUS_QUIT) break;
2751 if (data.devices_status == STATUS_BYPASS) break;
2752
2753 if (data.salts_shown[salt_pos] == 1) continue;
2754
2755 salt_t *salt_buf = &data.salts_buf[salt_pos];
2756
2757 device_param->kernel_params_buf32[24] = salt_pos;
2758 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2759 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2760
2761 FILE *combs_fp = device_param->combs_fp;
2762
2763 if (data.attack_mode == ATTACK_MODE_COMBI)
2764 {
2765 rewind (combs_fp);
2766 }
2767
2768 // innerloops
2769
2770 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2771 {
2772 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2773
2774 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2775
2776 if (data.devices_status == STATUS_CRACKED) break;
2777 if (data.devices_status == STATUS_ABORTED) break;
2778 if (data.devices_status == STATUS_QUIT) break;
2779 if (data.devices_status == STATUS_BYPASS) break;
2780
2781 uint innerloop_left = innerloop_cnt - innerloop_pos;
2782
2783 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2784
2785 device_param->innerloop_pos = innerloop_pos;
2786 device_param->innerloop_left = innerloop_left;
2787
2788 device_param->kernel_params_buf32[27] = innerloop_left;
2789
2790 if (innerloop_left == 0) continue;
2791
2792 // initialize amplifiers
2793
2794 if (data.attack_mode == ATTACK_MODE_COMBI)
2795 {
2796 char line_buf[BUFSIZ] = { 0 };
2797
2798 uint i = 0;
2799
2800 while (i < innerloop_left)
2801 {
2802 if (feof (combs_fp)) break;
2803
2804 int line_len = fgetl (combs_fp, line_buf);
2805
2806 if (line_len >= PW_MAX1) continue;
2807
2808 line_len = convert_from_hex (line_buf, line_len);
2809
2810 char *line_buf_new = line_buf;
2811
2812 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2813 {
2814 char rule_buf_out[BLOCK_SIZE] = { 0 };
2815
2816 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2817
2818 if (rule_len_out < 0)
2819 {
2820 data.words_progress_rejected[salt_pos] += pw_cnt;
2821
2822 continue;
2823 }
2824
2825 line_len = rule_len_out;
2826
2827 line_buf_new = rule_buf_out;
2828 }
2829
2830 line_len = MIN (line_len, PW_DICTMAX);
2831
2832 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2833
2834 memcpy (ptr, line_buf_new, line_len);
2835
2836 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2837
2838 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2839 {
2840 uppercase (ptr, line_len);
2841 }
2842
2843 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2844 {
2845 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2846 {
2847 ptr[line_len] = 0x80;
2848 }
2849
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 ptr[line_len] = 0x01;
2853 }
2854 }
2855
2856 device_param->combs_buf[i].pw_len = line_len;
2857
2858 i++;
2859 }
2860
2861 for (uint j = i; j < innerloop_left; j++)
2862 {
2863 device_param->combs_buf[j].i[0] = 0;
2864 device_param->combs_buf[j].i[1] = 0;
2865 device_param->combs_buf[j].i[2] = 0;
2866 device_param->combs_buf[j].i[3] = 0;
2867 device_param->combs_buf[j].i[4] = 0;
2868 device_param->combs_buf[j].i[5] = 0;
2869 device_param->combs_buf[j].i[6] = 0;
2870 device_param->combs_buf[j].i[7] = 0;
2871
2872 device_param->combs_buf[j].pw_len = 0;
2873 }
2874
2875 innerloop_left = i;
2876 }
2877 else if (data.attack_mode == ATTACK_MODE_BF)
2878 {
2879 u64 off = innerloop_pos;
2880
2881 device_param->kernel_params_mp_r_buf64[3] = off;
2882
2883 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2884 }
2885 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2886 {
2887 u64 off = innerloop_pos;
2888
2889 device_param->kernel_params_mp_buf64[3] = off;
2890
2891 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2892 }
2893 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2894 {
2895 u64 off = innerloop_pos;
2896
2897 device_param->kernel_params_mp_buf64[3] = off;
2898
2899 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2900 }
2901
2902 // copy amplifiers
2903
2904 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2905 {
2906 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);
2907 }
2908 else if (data.attack_mode == ATTACK_MODE_COMBI)
2909 {
2910 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);
2911 }
2912 else if (data.attack_mode == ATTACK_MODE_BF)
2913 {
2914 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);
2915 }
2916 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2917 {
2918 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);
2919 }
2920 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2921 {
2922 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);
2923 }
2924
2925 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2926 {
2927 if (data.attack_mode == ATTACK_MODE_BF)
2928 {
2929 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2930 {
2931 const uint size_tm = 32 * sizeof (bs_word_t);
2932
2933 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2934
2935 run_kernel_tm (device_param);
2936
2937 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);
2938 }
2939 }
2940
2941 if (highest_pw_len < 16)
2942 {
2943 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2944 }
2945 else if (highest_pw_len < 32)
2946 {
2947 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2948 }
2949 else
2950 {
2951 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2952 }
2953 }
2954 else
2955 {
2956 run_kernel_amp (device_param, pws_cnt);
2957
2958 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2959
2960 if (data.opts_type & OPTS_TYPE_HOOK12)
2961 {
2962 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2963 }
2964
2965 uint iter = salt_buf->salt_iter;
2966
2967 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2968 {
2969 uint loop_left = iter - loop_pos;
2970
2971 loop_left = MIN (loop_left, kernel_loops);
2972
2973 device_param->kernel_params_buf32[25] = loop_pos;
2974 device_param->kernel_params_buf32[26] = loop_left;
2975
2976 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2977
2978 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2979
2980 if (data.devices_status == STATUS_CRACKED) break;
2981 if (data.devices_status == STATUS_ABORTED) break;
2982 if (data.devices_status == STATUS_QUIT) break;
2983 }
2984
2985 if (data.opts_type & OPTS_TYPE_HOOK23)
2986 {
2987 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2988
2989 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);
2990
2991 // do something with data
2992
2993 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);
2994 }
2995
2996 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2997 }
2998
2999 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3000
3001 if (data.devices_status == STATUS_CRACKED) break;
3002 if (data.devices_status == STATUS_ABORTED) break;
3003 if (data.devices_status == STATUS_QUIT) break;
3004
3005 /**
3006 * result
3007 */
3008
3009 hc_thread_mutex_lock (mux_display);
3010
3011 check_cracked (device_param, salt_pos);
3012
3013 hc_thread_mutex_unlock (mux_display);
3014
3015 /**
3016 * progress
3017 */
3018
3019 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3020
3021 hc_thread_mutex_lock (mux_counter);
3022
3023 data.words_progress_done[salt_pos] += perf_sum_all;
3024
3025 hc_thread_mutex_unlock (mux_counter);
3026
3027 /**
3028 * speed
3029 */
3030
3031 float speed_ms;
3032
3033 hc_timer_get (device_param->timer_speed, speed_ms);
3034
3035 hc_timer_set (&device_param->timer_speed);
3036
3037 hc_thread_mutex_lock (mux_display);
3038
3039 device_param->speed_cnt[speed_pos] = perf_sum_all;
3040
3041 device_param->speed_ms[speed_pos] = speed_ms;
3042
3043 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3044
3045 hc_thread_mutex_unlock (mux_display);
3046
3047 speed_pos++;
3048
3049 if (speed_pos == SPEED_CACHE)
3050 {
3051 speed_pos = 0;
3052 }
3053 }
3054 }
3055
3056 device_param->speed_pos = speed_pos;
3057 }
3058
3059 static void load_segment (wl_data_t *wl_data, FILE *fd)
3060 {
3061 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3062
3063 wl_data->pos = 0;
3064
3065 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3066
3067 wl_data->buf[wl_data->cnt] = 0;
3068
3069 if (wl_data->cnt == 0) return;
3070
3071 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3072
3073 while (!feof (fd))
3074 {
3075 if (wl_data->cnt == wl_data->avail)
3076 {
3077 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3078
3079 wl_data->avail += wl_data->incr;
3080 }
3081
3082 const int c = fgetc (fd);
3083
3084 if (c == EOF) break;
3085
3086 wl_data->buf[wl_data->cnt] = (char) c;
3087
3088 wl_data->cnt++;
3089
3090 if (c == '\n') break;
3091 }
3092
3093 // ensure stream ends with a newline
3094
3095 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3096 {
3097 wl_data->cnt++;
3098
3099 wl_data->buf[wl_data->cnt - 1] = '\n';
3100 }
3101
3102 return;
3103 }
3104
3105 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3106 {
3107 char *ptr = buf;
3108
3109 for (u32 i = 0; i < sz; i++, ptr++)
3110 {
3111 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3112
3113 if (i == 7)
3114 {
3115 *off = i;
3116 *len = i;
3117
3118 return;
3119 }
3120
3121 if (*ptr != '\n') continue;
3122
3123 *off = i + 1;
3124
3125 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3126
3127 *len = i;
3128
3129 return;
3130 }
3131
3132 *off = sz;
3133 *len = sz;
3134 }
3135
3136 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3137 {
3138 char *ptr = buf;
3139
3140 for (u32 i = 0; i < sz; i++, ptr++)
3141 {
3142 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3143
3144 if (*ptr != '\n') continue;
3145
3146 *off = i + 1;
3147
3148 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3149
3150 *len = i;
3151
3152 return;
3153 }
3154
3155 *off = sz;
3156 *len = sz;
3157 }
3158
3159 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3160 {
3161 char *ptr = buf;
3162
3163 for (u32 i = 0; i < sz; i++, ptr++)
3164 {
3165 if (*ptr != '\n') continue;
3166
3167 *off = i + 1;
3168
3169 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3170
3171 *len = i;
3172
3173 return;
3174 }
3175
3176 *off = sz;
3177 *len = sz;
3178 }
3179
3180 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3181 {
3182 while (wl_data->pos < wl_data->cnt)
3183 {
3184 uint off;
3185 uint len;
3186
3187 char *ptr = wl_data->buf + wl_data->pos;
3188
3189 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3190
3191 wl_data->pos += off;
3192
3193 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3194 {
3195 char rule_buf_out[BLOCK_SIZE] = { 0 };
3196
3197 int rule_len_out = -1;
3198
3199 if (len < BLOCK_SIZE)
3200 {
3201 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3202 }
3203
3204 if (rule_len_out < 0)
3205 {
3206 continue;
3207 }
3208
3209 if (rule_len_out > PW_MAX)
3210 {
3211 continue;
3212 }
3213 }
3214 else
3215 {
3216 if (len > PW_MAX)
3217 {
3218 continue;
3219 }
3220 }
3221
3222 *out_buf = ptr;
3223 *out_len = len;
3224
3225 return;
3226 }
3227
3228 if (feof (fd))
3229 {
3230 fprintf (stderr, "bug!!\n");
3231
3232 return;
3233 }
3234
3235 load_segment (wl_data, fd);
3236
3237 get_next_word (wl_data, fd, out_buf, out_len);
3238 }
3239
3240 #ifdef _POSIX
3241 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3242 #endif
3243
3244 #ifdef _WIN
3245 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3246 #endif
3247 {
3248 hc_signal (NULL);
3249
3250 dictstat_t d;
3251
3252 d.cnt = 0;
3253
3254 #ifdef _POSIX
3255 fstat (fileno (fd), &d.stat);
3256 #endif
3257
3258 #ifdef _WIN
3259 _fstat64 (fileno (fd), &d.stat);
3260 #endif
3261
3262 d.stat.st_mode = 0;
3263 d.stat.st_nlink = 0;
3264 d.stat.st_uid = 0;
3265 d.stat.st_gid = 0;
3266 d.stat.st_rdev = 0;
3267 d.stat.st_atime = 0;
3268
3269 #ifdef _POSIX
3270 d.stat.st_blksize = 0;
3271 d.stat.st_blocks = 0;
3272 #endif
3273
3274 if (d.stat.st_size == 0) return 0;
3275
3276 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3277
3278 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3279 {
3280 if (d_cache)
3281 {
3282 u64 cnt = d_cache->cnt;
3283
3284 u64 keyspace = cnt;
3285
3286 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3287 {
3288 keyspace *= data.kernel_rules_cnt;
3289 }
3290 else if (data.attack_kern == ATTACK_KERN_COMBI)
3291 {
3292 keyspace *= data.combs_cnt;
3293 }
3294
3295 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);
3296 if (data.quiet == 0) log_info ("");
3297
3298 hc_signal (sigHandler_default);
3299
3300 return (keyspace);
3301 }
3302 }
3303
3304 time_t now = 0;
3305 time_t prev = 0;
3306
3307 u64 comp = 0;
3308 u64 cnt = 0;
3309 u64 cnt2 = 0;
3310
3311 while (!feof (fd))
3312 {
3313 load_segment (wl_data, fd);
3314
3315 comp += wl_data->cnt;
3316
3317 u32 i = 0;
3318
3319 while (i < wl_data->cnt)
3320 {
3321 u32 len;
3322 u32 off;
3323
3324 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3325
3326 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3327 {
3328 char rule_buf_out[BLOCK_SIZE] = { 0 };
3329
3330 int rule_len_out = -1;
3331
3332 if (len < BLOCK_SIZE)
3333 {
3334 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3335 }
3336
3337 if (rule_len_out < 0)
3338 {
3339 len = PW_MAX1;
3340 }
3341 else
3342 {
3343 len = rule_len_out;
3344 }
3345 }
3346
3347 if (len < PW_MAX1)
3348 {
3349 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3350 {
3351 cnt += data.kernel_rules_cnt;
3352 }
3353 else if (data.attack_kern == ATTACK_KERN_COMBI)
3354 {
3355 cnt += data.combs_cnt;
3356 }
3357
3358 d.cnt++;
3359 }
3360
3361 i += off;
3362
3363 cnt2++;
3364 }
3365
3366 time (&now);
3367
3368 if ((now - prev) == 0) continue;
3369
3370 float percent = (float) comp / (float) d.stat.st_size;
3371
3372 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);
3373
3374 time (&prev);
3375 }
3376
3377 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);
3378 if (data.quiet == 0) log_info ("");
3379
3380 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3381
3382 hc_signal (sigHandler_default);
3383
3384 return (cnt);
3385 }
3386
3387 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3388 {
3389 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3390 }
3391
3392 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3393 {
3394 if (data.devices_status == STATUS_BYPASS) return 0;
3395
3396 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3397
3398 uint cache_cnt = pw_cache->cnt;
3399
3400 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3401
3402 memcpy (pw_hc1, pw_buf, pw_len);
3403
3404 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3405
3406 uint pws_cnt = device_param->pws_cnt;
3407
3408 cache_cnt++;
3409
3410 pw_t *pw = device_param->pws_buf + pws_cnt;
3411
3412 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3413
3414 pw->pw_len = pw_len;
3415
3416 pws_cnt++;
3417
3418 device_param->pws_cnt = pws_cnt;
3419 device_param->pw_cnt = pws_cnt * 1;
3420
3421 cache_cnt = 0;
3422
3423 pw_cache->cnt = cache_cnt;
3424
3425 return pws_cnt;
3426 }
3427
3428 static void *thread_monitor (void *p)
3429 {
3430 uint runtime_check = 0;
3431 uint remove_check = 0;
3432 uint status_check = 0;
3433 uint restore_check = 0;
3434
3435 uint restore_left = data.restore_timer;
3436 uint remove_left = data.remove_timer;
3437 uint status_left = data.status_timer;
3438
3439 #ifdef HAVE_HWMON
3440 uint hwmon_check = 0;
3441
3442 // these variables are mainly used for fan control (AMD only)
3443
3444 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3445
3446 // temperature controller "loopback" values
3447
3448 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3449 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3450
3451 #ifdef HAVE_ADL
3452 int temp_threshold = 1; // degrees celcius
3453
3454 int fan_speed_min = 15; // in percentage
3455 int fan_speed_max = 100;
3456 #endif // HAVE_ADL
3457
3458 time_t last_temp_check_time;
3459 #endif // HAVE_HWMON
3460
3461 uint sleep_time = 1;
3462
3463 if (data.runtime)
3464 {
3465 runtime_check = 1;
3466 }
3467
3468 if (data.restore_timer)
3469 {
3470 restore_check = 1;
3471 }
3472
3473 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3474 {
3475 remove_check = 1;
3476 }
3477
3478 if (data.status == 1)
3479 {
3480 status_check = 1;
3481 }
3482
3483 #ifdef HAVE_HWMON
3484 if (data.gpu_temp_disable == 0)
3485 {
3486 time (&last_temp_check_time);
3487
3488 hwmon_check = 1;
3489 }
3490 #endif
3491
3492 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3493 {
3494 #ifdef HAVE_HWMON
3495 if (hwmon_check == 0)
3496 #endif
3497 return (p);
3498 }
3499
3500 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3501 {
3502 hc_sleep (sleep_time);
3503
3504 if (data.devices_status != STATUS_RUNNING) continue;
3505
3506 #ifdef HAVE_HWMON
3507 if (hwmon_check == 1)
3508 {
3509 hc_thread_mutex_lock (mux_adl);
3510
3511 time_t temp_check_time;
3512
3513 time (&temp_check_time);
3514
3515 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3516
3517 if (Ta == 0) Ta = 1;
3518
3519 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3520 {
3521 hc_device_param_t *device_param = &data.devices_param[device_id];
3522
3523 if (device_param->skipped) continue;
3524
3525 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3526
3527 const int temperature = hm_get_temperature_with_device_id (device_id);
3528
3529 if (temperature > (int) data.gpu_temp_abort)
3530 {
3531 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3532
3533 if (data.devices_status != STATUS_QUIT) myabort ();
3534
3535 break;
3536 }
3537
3538 #ifdef HAVE_ADL
3539 const int gpu_temp_retain = data.gpu_temp_retain;
3540
3541 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3542 {
3543 if (data.hm_device[device_id].fan_supported == 1)
3544 {
3545 int temp_cur = temperature;
3546
3547 int temp_diff_new = gpu_temp_retain - temp_cur;
3548
3549 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3550
3551 // calculate Ta value (time difference in seconds between the last check and this check)
3552
3553 last_temp_check_time = temp_check_time;
3554
3555 float Kp = 1.8;
3556 float Ki = 0.005;
3557 float Kd = 6;
3558
3559 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3560
3561 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);
3562
3563 if (abs (fan_diff_required) >= temp_threshold)
3564 {
3565 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3566
3567 int fan_speed_level = fan_speed_cur;
3568
3569 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3570
3571 int fan_speed_new = fan_speed_level - fan_diff_required;
3572
3573 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3574 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3575
3576 if (fan_speed_new != fan_speed_cur)
3577 {
3578 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3579 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3580
3581 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3582 {
3583 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3584
3585 fan_speed_chgd[device_id] = 1;
3586 }
3587
3588 temp_diff_old[device_id] = temp_diff_new;
3589 }
3590 }
3591 }
3592 }
3593 #endif // HAVE_ADL
3594 }
3595
3596 hc_thread_mutex_unlock (mux_adl);
3597 }
3598 #endif // HAVE_HWMON
3599
3600 if (restore_check == 1)
3601 {
3602 restore_left--;
3603
3604 if (restore_left == 0)
3605 {
3606 if (data.restore_disable == 0) cycle_restore ();
3607
3608 restore_left = data.restore_timer;
3609 }
3610 }
3611
3612 if ((runtime_check == 1) && (data.runtime_start > 0))
3613 {
3614 time_t runtime_cur;
3615
3616 time (&runtime_cur);
3617
3618 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3619
3620 if (runtime_left <= 0)
3621 {
3622 if (data.benchmark == 0)
3623 {
3624 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3625 }
3626
3627 if (data.devices_status != STATUS_QUIT) myabort ();
3628 }
3629 }
3630
3631 if (remove_check == 1)
3632 {
3633 remove_left--;
3634
3635 if (remove_left == 0)
3636 {
3637 if (data.digests_saved != data.digests_done)
3638 {
3639 data.digests_saved = data.digests_done;
3640
3641 save_hash ();
3642 }
3643
3644 remove_left = data.remove_timer;
3645 }
3646 }
3647
3648 if (status_check == 1)
3649 {
3650 status_left--;
3651
3652 if (status_left == 0)
3653 {
3654 hc_thread_mutex_lock (mux_display);
3655
3656 if (data.quiet == 0) clear_prompt ();
3657
3658 if (data.quiet == 0) log_info ("");
3659
3660 status_display ();
3661
3662 if (data.quiet == 0) log_info ("");
3663
3664 hc_thread_mutex_unlock (mux_display);
3665
3666 status_left = data.status_timer;
3667 }
3668 }
3669 }
3670
3671 #ifdef HAVE_HWMON
3672 myfree (fan_speed_chgd);
3673
3674 myfree (temp_diff_old);
3675 myfree (temp_diff_sum);
3676 #endif
3677
3678 p = NULL;
3679
3680 return (p);
3681 }
3682
3683 static void *thread_outfile_remove (void *p)
3684 {
3685 // some hash-dependent constants
3686 char *outfile_dir = data.outfile_check_directory;
3687 uint dgst_size = data.dgst_size;
3688 uint isSalted = data.isSalted;
3689 uint esalt_size = data.esalt_size;
3690 uint hash_mode = data.hash_mode;
3691
3692 uint outfile_check_timer = data.outfile_check_timer;
3693
3694 char separator = data.separator;
3695
3696 // some hash-dependent functions
3697 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3698 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3699
3700 // buffers
3701 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3702
3703 hash_buf.digest = mymalloc (dgst_size);
3704
3705 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3706
3707 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3708
3709 uint digest_buf[64] = { 0 };
3710
3711 outfile_data_t *out_info = NULL;
3712
3713 char **out_files = NULL;
3714
3715 time_t folder_mtime = 0;
3716
3717 int out_cnt = 0;
3718
3719 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3720
3721 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3722 {
3723 hc_sleep (1);
3724
3725 if (data.devices_status != STATUS_RUNNING) continue;
3726
3727 check_left--;
3728
3729 if (check_left == 0)
3730 {
3731 struct stat outfile_check_stat;
3732
3733 if (stat (outfile_dir, &outfile_check_stat) == 0)
3734 {
3735 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3736
3737 if (is_dir == 1)
3738 {
3739 if (outfile_check_stat.st_mtime > folder_mtime)
3740 {
3741 char **out_files_new = scan_directory (outfile_dir);
3742
3743 int out_cnt_new = count_dictionaries (out_files_new);
3744
3745 outfile_data_t *out_info_new = NULL;
3746
3747 if (out_cnt_new > 0)
3748 {
3749 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3750
3751 for (int i = 0; i < out_cnt_new; i++)
3752 {
3753 out_info_new[i].file_name = out_files_new[i];
3754
3755 // check if there are files that we have seen/checked before (and not changed)
3756
3757 for (int j = 0; j < out_cnt; j++)
3758 {
3759 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3760 {
3761 struct stat outfile_stat;
3762
3763 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3764 {
3765 if (outfile_stat.st_ctime == out_info[j].ctime)
3766 {
3767 out_info_new[i].ctime = out_info[j].ctime;
3768 out_info_new[i].seek = out_info[j].seek;
3769 }
3770 }
3771 }
3772 }
3773 }
3774 }
3775
3776 local_free (out_info);
3777 local_free (out_files);
3778
3779 out_files = out_files_new;
3780 out_cnt = out_cnt_new;
3781 out_info = out_info_new;
3782
3783 folder_mtime = outfile_check_stat.st_mtime;
3784 }
3785
3786 for (int j = 0; j < out_cnt; j++)
3787 {
3788 FILE *fp = fopen (out_info[j].file_name, "rb");
3789
3790 if (fp != NULL)
3791 {
3792 //hc_thread_mutex_lock (mux_display);
3793
3794 #ifdef _POSIX
3795 struct stat outfile_stat;
3796
3797 fstat (fileno (fp), &outfile_stat);
3798 #endif
3799
3800 #ifdef _WIN
3801 struct stat64 outfile_stat;
3802
3803 _fstat64 (fileno (fp), &outfile_stat);
3804 #endif
3805
3806 if (outfile_stat.st_ctime > out_info[j].ctime)
3807 {
3808 out_info[j].ctime = outfile_stat.st_ctime;
3809 out_info[j].seek = 0;
3810 }
3811
3812 fseek (fp, out_info[j].seek, SEEK_SET);
3813
3814 while (!feof (fp))
3815 {
3816 char line_buf[BUFSIZ] = { 0 };
3817
3818 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3819
3820 if (ptr == NULL) break;
3821
3822 int line_len = strlen (line_buf);
3823
3824 if (line_len <= 0) continue;
3825
3826 int iter = MAX_CUT_TRIES;
3827
3828 for (uint i = line_len - 1; i && iter; i--, line_len--)
3829 {
3830 if (line_buf[i] != separator) continue;
3831
3832 int parser_status = PARSER_OK;
3833
3834 if ((hash_mode != 2500) && (hash_mode != 6800))
3835 {
3836 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3837 }
3838
3839 uint found = 0;
3840
3841 if (parser_status == PARSER_OK)
3842 {
3843 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3844 {
3845 if (data.salts_shown[salt_pos] == 1) continue;
3846
3847 salt_t *salt_buf = &data.salts_buf[salt_pos];
3848
3849 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3850 {
3851 uint idx = salt_buf->digests_offset + digest_pos;
3852
3853 if (data.digests_shown[idx] == 1) continue;
3854
3855 uint cracked = 0;
3856
3857 if (hash_mode == 6800)
3858 {
3859 if (i == salt_buf->salt_len)
3860 {
3861 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3862 }
3863 }
3864 else if (hash_mode == 2500)
3865 {
3866 // BSSID : MAC1 : MAC2 (:plain)
3867 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3868 {
3869 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3870
3871 if (!cracked) continue;
3872
3873 // now compare MAC1 and MAC2 too, since we have this additional info
3874 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3875 char *mac2_pos = mac1_pos + 12 + 1;
3876
3877 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3878 wpa_t *wpa = &wpas[salt_pos];
3879
3880 uint pke[25] = { 0 };
3881
3882 char *pke_ptr = (char *) pke;
3883
3884 for (uint i = 0; i < 25; i++)
3885 {
3886 pke[i] = byte_swap_32 (wpa->pke[i]);
3887 }
3888
3889 u8 mac1[6] = { 0 };
3890 u8 mac2[6] = { 0 };
3891
3892 memcpy (mac1, pke_ptr + 23, 6);
3893 memcpy (mac2, pke_ptr + 29, 6);
3894
3895 // compare hex string(s) vs binary MAC address(es)
3896
3897 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3898 {
3899 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3900 {
3901 cracked = 0;
3902 break;
3903 }
3904 }
3905
3906 // early skip ;)
3907 if (!cracked) continue;
3908
3909 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3910 {
3911 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3912 {
3913 cracked = 0;
3914 break;
3915 }
3916 }
3917 }
3918 }
3919 else
3920 {
3921 char *digests_buf_ptr = (char *) data.digests_buf;
3922
3923 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3924
3925 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3926 }
3927
3928 if (cracked == 1)
3929 {
3930 found = 1;
3931
3932 data.digests_shown[idx] = 1;
3933
3934 data.digests_done++;
3935
3936 salt_buf->digests_done++;
3937
3938 if (salt_buf->digests_done == salt_buf->digests_cnt)
3939 {
3940 data.salts_shown[salt_pos] = 1;
3941
3942 data.salts_done++;
3943
3944 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3945 }
3946 }
3947 }
3948
3949 if (data.devices_status == STATUS_CRACKED) break;
3950 }
3951 }
3952
3953 if (found) break;
3954
3955 if (data.devices_status == STATUS_CRACKED) break;
3956
3957 iter--;
3958 }
3959
3960 if (data.devices_status == STATUS_CRACKED) break;
3961 }
3962
3963 out_info[j].seek = ftell (fp);
3964
3965 //hc_thread_mutex_unlock (mux_display);
3966
3967 fclose (fp);
3968 }
3969 }
3970 }
3971 }
3972
3973 check_left = outfile_check_timer;
3974 }
3975 }
3976
3977 if (esalt_size) local_free (hash_buf.esalt);
3978
3979 if (isSalted) local_free (hash_buf.salt);
3980
3981 local_free (hash_buf.digest);
3982
3983 local_free (out_info);
3984
3985 local_free (out_files);
3986
3987 p = NULL;
3988
3989 return (p);
3990 }
3991
3992 static uint get_work (hc_device_param_t *device_param, const u64 max)
3993 {
3994 hc_thread_mutex_lock (mux_dispatcher);
3995
3996 const u64 words_cur = data.words_cur;
3997 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3998
3999 device_param->words_off = words_cur;
4000
4001 const u64 words_left = words_base - words_cur;
4002
4003 if (data.kernel_blocks_all > words_left)
4004 {
4005 if (data.kernel_blocks_div == 0)
4006 {
4007 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4008 }
4009 }
4010
4011 if (data.kernel_blocks_div)
4012 {
4013 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4014 {
4015 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4016 const u32 kernel_power_new = kernel_blocks_new;
4017
4018 if (kernel_blocks_new < device_param->kernel_blocks)
4019 {
4020 device_param->kernel_blocks = kernel_blocks_new;
4021 device_param->kernel_power = kernel_power_new;
4022 }
4023 }
4024 }
4025
4026 const uint kernel_blocks = device_param->kernel_blocks;
4027
4028 uint work = MIN (words_left, kernel_blocks);
4029
4030 work = MIN (work, max);
4031
4032 data.words_cur += work;
4033
4034 hc_thread_mutex_unlock (mux_dispatcher);
4035
4036 return work;
4037 }
4038
4039 static void *thread_calc_stdin (void *p)
4040 {
4041 hc_device_param_t *device_param = (hc_device_param_t *) p;
4042
4043 if (device_param->skipped) return NULL;
4044
4045 const uint attack_kern = data.attack_kern;
4046
4047 const uint kernel_blocks = device_param->kernel_blocks;
4048
4049 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4050 {
4051 hc_thread_mutex_lock (mux_dispatcher);
4052
4053 if (feof (stdin) != 0)
4054 {
4055 hc_thread_mutex_unlock (mux_dispatcher);
4056
4057 break;
4058 }
4059
4060 uint words_cur = 0;
4061
4062 while (words_cur < kernel_blocks)
4063 {
4064 char buf[BUFSIZ] = { 0 };
4065
4066 char *line_buf = fgets (buf, sizeof (buf), stdin);
4067
4068 if (line_buf == NULL) break;
4069
4070 uint line_len = in_superchop (line_buf);
4071
4072 line_len = convert_from_hex (line_buf, line_len);
4073
4074 // post-process rule engine
4075
4076 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4077 {
4078 char rule_buf_out[BLOCK_SIZE] = { 0 };
4079
4080 int rule_len_out = -1;
4081
4082 if (line_len < BLOCK_SIZE)
4083 {
4084 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4085 }
4086
4087 if (rule_len_out < 0) continue;
4088
4089 line_buf = rule_buf_out;
4090 line_len = rule_len_out;
4091 }
4092
4093 if (line_len > PW_MAX)
4094 {
4095 continue;
4096 }
4097
4098 if (attack_kern == ATTACK_KERN_STRAIGHT)
4099 {
4100 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4101 {
4102 hc_thread_mutex_lock (mux_counter);
4103
4104 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4105 {
4106 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4107 }
4108
4109 hc_thread_mutex_unlock (mux_counter);
4110
4111 continue;
4112 }
4113 }
4114 else if (attack_kern == ATTACK_KERN_COMBI)
4115 {
4116 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4117 // since we still need to combine the plains
4118
4119 if (line_len > data.pw_max)
4120 {
4121 hc_thread_mutex_lock (mux_counter);
4122
4123 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4124 {
4125 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4126 }
4127
4128 hc_thread_mutex_unlock (mux_counter);
4129
4130 continue;
4131 }
4132 }
4133
4134 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4135
4136 words_cur++;
4137
4138 if (data.devices_status == STATUS_CRACKED) break;
4139 if (data.devices_status == STATUS_ABORTED) break;
4140 if (data.devices_status == STATUS_QUIT) break;
4141 if (data.devices_status == STATUS_BYPASS) break;
4142 }
4143
4144 hc_thread_mutex_unlock (mux_dispatcher);
4145
4146 if (data.devices_status == STATUS_CRACKED) break;
4147 if (data.devices_status == STATUS_ABORTED) break;
4148 if (data.devices_status == STATUS_QUIT) break;
4149 if (data.devices_status == STATUS_BYPASS) break;
4150
4151 // we need 2 flushing because we have two independant caches and it can occur
4152 // that one buffer is already at threshold plus for that length also exists
4153 // more data in the 2nd buffer so it would overflow
4154
4155 // flush session 1
4156
4157 {
4158 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4159 {
4160 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4161
4162 const uint pw_cache_cnt = pw_cache->cnt;
4163
4164 if (pw_cache_cnt == 0) continue;
4165
4166 pw_cache->cnt = 0;
4167
4168 uint pws_cnt = device_param->pws_cnt;
4169
4170 pw_t *pw = device_param->pws_buf + pws_cnt;
4171
4172 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4173
4174 pw->pw_len = pw_len;
4175
4176 uint pw_cnt = device_param->pw_cnt;
4177
4178 pw_cnt += pw_cache_cnt;
4179
4180 device_param->pw_cnt = pw_cnt;
4181
4182 pws_cnt++;
4183
4184 device_param->pws_cnt = pws_cnt;
4185
4186 if (pws_cnt == device_param->kernel_power_user) break;
4187 }
4188
4189 const uint pw_cnt = device_param->pw_cnt;
4190 const uint pws_cnt = device_param->pws_cnt;
4191
4192 if (pws_cnt)
4193 {
4194 run_copy (device_param, pws_cnt);
4195
4196 run_cracker (device_param, pw_cnt, pws_cnt);
4197
4198 device_param->pw_cnt = 0;
4199 device_param->pws_cnt = 0;
4200 }
4201 }
4202
4203 // flush session 2
4204
4205 {
4206 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4207 {
4208 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4209
4210 const uint pw_cache_cnt = pw_cache->cnt;
4211
4212 if (pw_cache_cnt == 0) continue;
4213
4214 pw_cache->cnt = 0;
4215
4216 uint pws_cnt = device_param->pws_cnt;
4217
4218 pw_t *pw = device_param->pws_buf + pws_cnt;
4219
4220 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4221
4222 pw->pw_len = pw_len;
4223
4224 uint pw_cnt = device_param->pw_cnt;
4225
4226 pw_cnt += pw_cache_cnt;
4227
4228 device_param->pw_cnt = pw_cnt;
4229
4230 pws_cnt++;
4231
4232 device_param->pws_cnt = pws_cnt;
4233 }
4234
4235 const uint pw_cnt = device_param->pw_cnt;
4236 const uint pws_cnt = device_param->pws_cnt;
4237
4238 if (pws_cnt)
4239 {
4240 run_copy (device_param, pws_cnt);
4241
4242 run_cracker (device_param, pw_cnt, pws_cnt);
4243
4244 device_param->pw_cnt = 0;
4245 device_param->pws_cnt = 0;
4246 }
4247 }
4248 }
4249
4250 return NULL;
4251 }
4252
4253 static void *thread_calc (void *p)
4254 {
4255 hc_device_param_t *device_param = (hc_device_param_t *) p;
4256
4257 if (device_param->skipped) return NULL;
4258
4259 const uint attack_mode = data.attack_mode;
4260 const uint attack_kern = data.attack_kern;
4261
4262 if (attack_mode == ATTACK_MODE_BF)
4263 {
4264 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4265 {
4266 const uint work = get_work (device_param, -1);
4267
4268 if (work == 0) break;
4269
4270 const u64 words_off = device_param->words_off;
4271 const u64 words_fin = words_off + work;
4272
4273 const uint pw_cnt = work;
4274 const uint pws_cnt = work;
4275
4276 device_param->pw_cnt = pw_cnt;
4277 device_param->pws_cnt = pws_cnt;
4278
4279 if (pws_cnt)
4280 {
4281 run_copy (device_param, pws_cnt);
4282
4283 run_cracker (device_param, pw_cnt, pws_cnt);
4284
4285 device_param->pw_cnt = 0;
4286 device_param->pws_cnt = 0;
4287 }
4288
4289 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4290
4291 if (data.devices_status == STATUS_CRACKED) break;
4292 if (data.devices_status == STATUS_ABORTED) break;
4293 if (data.devices_status == STATUS_QUIT) break;
4294 if (data.devices_status == STATUS_BYPASS) break;
4295
4296 device_param->words_done = words_fin;
4297 }
4298 }
4299 else
4300 {
4301 const uint segment_size = data.segment_size;
4302
4303 char *dictfile = data.dictfile;
4304
4305 if (attack_mode == ATTACK_MODE_COMBI)
4306 {
4307 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4308 {
4309 dictfile = data.dictfile2;
4310 }
4311 }
4312
4313 FILE *fd = fopen (dictfile, "rb");
4314
4315 if (fd == NULL)
4316 {
4317 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4318
4319 return NULL;
4320 }
4321
4322 if (attack_mode == ATTACK_MODE_COMBI)
4323 {
4324 const uint combs_mode = data.combs_mode;
4325
4326 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4327 {
4328 const char *dictfilec = data.dictfile2;
4329
4330 FILE *combs_fp = fopen (dictfilec, "rb");
4331
4332 if (combs_fp == NULL)
4333 {
4334 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4335
4336 fclose (fd);
4337
4338 return NULL;
4339 }
4340
4341 device_param->combs_fp = combs_fp;
4342 }
4343 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4344 {
4345 const char *dictfilec = data.dictfile;
4346
4347 FILE *combs_fp = fopen (dictfilec, "rb");
4348
4349 if (combs_fp == NULL)
4350 {
4351 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4352
4353 fclose (fd);
4354
4355 return NULL;
4356 }
4357
4358 device_param->combs_fp = combs_fp;
4359 }
4360 }
4361
4362 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4363
4364 wl_data->buf = (char *) mymalloc (segment_size);
4365 wl_data->avail = segment_size;
4366 wl_data->incr = segment_size;
4367 wl_data->cnt = 0;
4368 wl_data->pos = 0;
4369
4370 u64 words_cur = 0;
4371
4372 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4373 {
4374 u64 words_off = 0;
4375 u64 words_fin = 0;
4376
4377 u64 max = -1;
4378
4379 while (max)
4380 {
4381 const uint work = get_work (device_param, max);
4382
4383 if (work == 0) break;
4384
4385 words_off = device_param->words_off;
4386 words_fin = words_off + work;
4387
4388 char *line_buf;
4389 uint line_len;
4390
4391 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4392
4393 max = 0;
4394
4395 for ( ; words_cur < words_fin; words_cur++)
4396 {
4397 get_next_word (wl_data, fd, &line_buf, &line_len);
4398
4399 line_len = convert_from_hex (line_buf, line_len);
4400
4401 // post-process rule engine
4402
4403 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4404 {
4405 char rule_buf_out[BLOCK_SIZE] = { 0 };
4406
4407 int rule_len_out = -1;
4408
4409 if (line_len < BLOCK_SIZE)
4410 {
4411 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4412 }
4413
4414 if (rule_len_out < 0) continue;
4415
4416 line_buf = rule_buf_out;
4417 line_len = rule_len_out;
4418 }
4419
4420 if (attack_kern == ATTACK_KERN_STRAIGHT)
4421 {
4422 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4423 {
4424 max++;
4425
4426 hc_thread_mutex_lock (mux_counter);
4427
4428 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4429 {
4430 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4431 }
4432
4433 hc_thread_mutex_unlock (mux_counter);
4434
4435 continue;
4436 }
4437 }
4438 else if (attack_kern == ATTACK_KERN_COMBI)
4439 {
4440 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4441 // since we still need to combine the plains
4442
4443 if (line_len > data.pw_max)
4444 {
4445 max++;
4446
4447 hc_thread_mutex_lock (mux_counter);
4448
4449 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4450 {
4451 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4452 }
4453
4454 hc_thread_mutex_unlock (mux_counter);
4455
4456 continue;
4457 }
4458 }
4459
4460 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4461
4462 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4463
4464 if (data.devices_status == STATUS_CRACKED) break;
4465 if (data.devices_status == STATUS_ABORTED) break;
4466 if (data.devices_status == STATUS_QUIT) break;
4467 if (data.devices_status == STATUS_BYPASS) break;
4468 }
4469
4470 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4471
4472 if (data.devices_status == STATUS_CRACKED) break;
4473 if (data.devices_status == STATUS_ABORTED) break;
4474 if (data.devices_status == STATUS_QUIT) break;
4475 if (data.devices_status == STATUS_BYPASS) break;
4476 }
4477
4478 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4479
4480 if (data.devices_status == STATUS_CRACKED) break;
4481 if (data.devices_status == STATUS_ABORTED) break;
4482 if (data.devices_status == STATUS_QUIT) break;
4483 if (data.devices_status == STATUS_BYPASS) break;
4484
4485 // we need 2 flushing because we have two independant caches and it can occur
4486 // that one buffer is already at threshold plus for that length also exists
4487 // more data in the 2nd buffer so it would overflow
4488
4489 //
4490 // flush session 1
4491 //
4492
4493 {
4494 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4495 {
4496 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4497
4498 const uint pw_cache_cnt = pw_cache->cnt;
4499
4500 if (pw_cache_cnt == 0) continue;
4501
4502 pw_cache->cnt = 0;
4503
4504 uint pws_cnt = device_param->pws_cnt;
4505
4506 pw_t *pw = device_param->pws_buf + pws_cnt;
4507
4508 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4509
4510 pw->pw_len = pw_len;
4511
4512 uint pw_cnt = device_param->pw_cnt;
4513
4514 pw_cnt += pw_cache_cnt;
4515
4516 device_param->pw_cnt = pw_cnt;
4517
4518 pws_cnt++;
4519
4520 device_param->pws_cnt = pws_cnt;
4521
4522 if (pws_cnt == device_param->kernel_power_user) break;
4523 }
4524
4525 const uint pw_cnt = device_param->pw_cnt;
4526 const uint pws_cnt = device_param->pws_cnt;
4527
4528 if (pws_cnt)
4529 {
4530 run_copy (device_param, pws_cnt);
4531
4532 run_cracker (device_param, pw_cnt, pws_cnt);
4533
4534 device_param->pw_cnt = 0;
4535 device_param->pws_cnt = 0;
4536 }
4537
4538 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4539
4540 if (data.devices_status == STATUS_CRACKED) break;
4541 if (data.devices_status == STATUS_ABORTED) break;
4542 if (data.devices_status == STATUS_QUIT) break;
4543 if (data.devices_status == STATUS_BYPASS) break;
4544 }
4545
4546 //
4547 // flush session 2
4548 //
4549
4550 {
4551 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4552 {
4553 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4554
4555 const uint pw_cache_cnt = pw_cache->cnt;
4556
4557 if (pw_cache_cnt == 0) continue;
4558
4559 pw_cache->cnt = 0;
4560
4561 uint pws_cnt = device_param->pws_cnt;
4562
4563 pw_t *pw = device_param->pws_buf + pws_cnt;
4564
4565 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4566
4567 pw->pw_len = pw_len;
4568
4569 uint pw_cnt = device_param->pw_cnt;
4570
4571 pw_cnt += pw_cache_cnt;
4572
4573 device_param->pw_cnt = pw_cnt;
4574
4575 pws_cnt++;
4576
4577 device_param->pws_cnt = pws_cnt;
4578 }
4579
4580 const uint pw_cnt = device_param->pw_cnt;
4581 const uint pws_cnt = device_param->pws_cnt;
4582
4583 if (pws_cnt)
4584 {
4585 run_copy (device_param, pws_cnt);
4586
4587 run_cracker (device_param, pw_cnt, pws_cnt);
4588
4589 device_param->pw_cnt = 0;
4590 device_param->pws_cnt = 0;
4591 }
4592
4593 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4594
4595 if (data.devices_status == STATUS_CRACKED) break;
4596 if (data.devices_status == STATUS_ABORTED) break;
4597 if (data.devices_status == STATUS_QUIT) break;
4598 if (data.devices_status == STATUS_BYPASS) break;
4599 }
4600
4601 if (words_fin == 0) break;
4602
4603 device_param->words_done = words_fin;
4604 }
4605
4606 if (attack_mode == ATTACK_MODE_COMBI)
4607 {
4608 fclose (device_param->combs_fp);
4609 }
4610
4611 free (wl_data->buf);
4612 free (wl_data);
4613
4614 fclose (fd);
4615 }
4616
4617 return NULL;
4618 }
4619
4620 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4621 {
4622 if (!device_param)
4623 {
4624 log_error ("ERROR: %s : Invalid argument", __func__);
4625
4626 exit (-1);
4627 }
4628
4629 salt_t *salt_buf = &data.salts_buf[salt_pos];
4630
4631 device_param->kernel_params_buf32[24] = salt_pos;
4632 device_param->kernel_params_buf32[27] = 1;
4633 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4634 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4635 device_param->kernel_params_buf32[30] = 0;
4636 device_param->kernel_params_buf32[31] = 1;
4637
4638 char *dictfile_old = data.dictfile;
4639
4640 const char *weak_hash_check = "weak-hash-check";
4641
4642 data.dictfile = (char *) weak_hash_check;
4643
4644 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4645
4646 data.kernel_rules_buf[0].cmds[0] = 0;
4647
4648 /**
4649 * run the kernel
4650 */
4651
4652 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4653 {
4654 run_kernel (KERN_RUN_1, device_param, 1);
4655 }
4656 else
4657 {
4658 run_kernel (KERN_RUN_1, device_param, 1);
4659
4660 const uint iter = salt_buf->salt_iter;
4661
4662 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4663 {
4664 uint loop_left = iter - loop_pos;
4665
4666 loop_left = MIN (loop_left, kernel_loops);
4667
4668 device_param->kernel_params_buf32[25] = loop_pos;
4669 device_param->kernel_params_buf32[26] = loop_left;
4670
4671 run_kernel (KERN_RUN_2, device_param, 1);
4672 }
4673
4674 run_kernel (KERN_RUN_3, device_param, 1);
4675 }
4676
4677 /**
4678 * result
4679 */
4680
4681 check_cracked (device_param, salt_pos);
4682
4683 /**
4684 * cleanup
4685 */
4686
4687 device_param->kernel_params_buf32[24] = 0;
4688 device_param->kernel_params_buf32[25] = 0;
4689 device_param->kernel_params_buf32[26] = 0;
4690 device_param->kernel_params_buf32[27] = 0;
4691 device_param->kernel_params_buf32[28] = 0;
4692 device_param->kernel_params_buf32[29] = 0;
4693 device_param->kernel_params_buf32[30] = 0;
4694 device_param->kernel_params_buf32[31] = 0;
4695
4696 data.dictfile = dictfile_old;
4697
4698 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4699 }
4700
4701 // hlfmt hashcat
4702
4703 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4704 {
4705 if (data.username == 0)
4706 {
4707 *hashbuf_pos = line_buf;
4708 *hashbuf_len = line_len;
4709 }
4710 else
4711 {
4712 char *pos = line_buf;
4713 int len = line_len;
4714
4715 for (int i = 0; i < line_len; i++, pos++, len--)
4716 {
4717 if (line_buf[i] == data.separator)
4718 {
4719 pos++;
4720
4721 len--;
4722
4723 break;
4724 }
4725 }
4726
4727 *hashbuf_pos = pos;
4728 *hashbuf_len = len;
4729 }
4730 }
4731
4732 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4733 {
4734 char *pos = NULL;
4735 int len = 0;
4736
4737 int sep_cnt = 0;
4738
4739 for (int i = 0; i < line_len; i++)
4740 {
4741 if (line_buf[i] == data.separator)
4742 {
4743 sep_cnt++;
4744
4745 continue;
4746 }
4747
4748 if (sep_cnt == 0)
4749 {
4750 if (pos == NULL) pos = line_buf + i;
4751
4752 len++;
4753 }
4754 }
4755
4756 *userbuf_pos = pos;
4757 *userbuf_len = len;
4758 }
4759
4760 // hlfmt pwdump
4761
4762 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4763 {
4764 int sep_cnt = 0;
4765
4766 int sep2_len = 0;
4767 int sep3_len = 0;
4768
4769 for (int i = 0; i < line_len; i++)
4770 {
4771 if (line_buf[i] == ':')
4772 {
4773 sep_cnt++;
4774
4775 continue;
4776 }
4777
4778 if (sep_cnt == 2) sep2_len++;
4779 if (sep_cnt == 3) sep3_len++;
4780 }
4781
4782 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4783
4784 return 0;
4785 }
4786
4787 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4788 {
4789 char *pos = NULL;
4790 int len = 0;
4791
4792 int sep_cnt = 0;
4793
4794 for (int i = 0; i < line_len; i++)
4795 {
4796 if (line_buf[i] == ':')
4797 {
4798 sep_cnt++;
4799
4800 continue;
4801 }
4802
4803 if (data.hash_mode == 1000)
4804 {
4805 if (sep_cnt == 3)
4806 {
4807 if (pos == NULL) pos = line_buf + i;
4808
4809 len++;
4810 }
4811 }
4812 else if (data.hash_mode == 3000)
4813 {
4814 if (sep_cnt == 2)
4815 {
4816 if (pos == NULL) pos = line_buf + i;
4817
4818 len++;
4819 }
4820 }
4821 }
4822
4823 *hashbuf_pos = pos;
4824 *hashbuf_len = len;
4825 }
4826
4827 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4828 {
4829 char *pos = NULL;
4830 int len = 0;
4831
4832 int sep_cnt = 0;
4833
4834 for (int i = 0; i < line_len; i++)
4835 {
4836 if (line_buf[i] == ':')
4837 {
4838 sep_cnt++;
4839
4840 continue;
4841 }
4842
4843 if (sep_cnt == 0)
4844 {
4845 if (pos == NULL) pos = line_buf + i;
4846
4847 len++;
4848 }
4849 }
4850
4851 *userbuf_pos = pos;
4852 *userbuf_len = len;
4853 }
4854
4855 // hlfmt passwd
4856
4857 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4858 {
4859 int sep_cnt = 0;
4860
4861 char sep5_first = 0;
4862 char sep6_first = 0;
4863
4864 for (int i = 0; i < line_len; i++)
4865 {
4866 if (line_buf[i] == ':')
4867 {
4868 sep_cnt++;
4869
4870 continue;
4871 }
4872
4873 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4874 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4875 }
4876
4877 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4878
4879 return 0;
4880 }
4881
4882 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4883 {
4884 char *pos = NULL;
4885 int len = 0;
4886
4887 int sep_cnt = 0;
4888
4889 for (int i = 0; i < line_len; i++)
4890 {
4891 if (line_buf[i] == ':')
4892 {
4893 sep_cnt++;
4894
4895 continue;
4896 }
4897
4898 if (sep_cnt == 1)
4899 {
4900 if (pos == NULL) pos = line_buf + i;
4901
4902 len++;
4903 }
4904 }
4905
4906 *hashbuf_pos = pos;
4907 *hashbuf_len = len;
4908 }
4909
4910 static void hlfmt_user_passwd (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 shadow
4939
4940 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4941 {
4942 int sep_cnt = 0;
4943
4944 for (int i = 0; i < line_len; i++)
4945 {
4946 if (line_buf[i] == ':') sep_cnt++;
4947 }
4948
4949 if (sep_cnt == 8) return 1;
4950
4951 return 0;
4952 }
4953
4954 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4955 {
4956 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4957 }
4958
4959 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4960 {
4961 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4962 }
4963
4964 // hlfmt main
4965
4966 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4967 {
4968 switch (hashfile_format)
4969 {
4970 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4971 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4972 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4973 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4974 }
4975 }
4976
4977 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4978 {
4979 switch (hashfile_format)
4980 {
4981 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4982 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4983 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4984 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4985 }
4986 }
4987
4988 static uint hlfmt_detect (FILE *fp, uint max_check)
4989 {
4990 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4991
4992 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4993 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4994
4995 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4996
4997 uint num_check = 0;
4998
4999 while (!feof (fp))
5000 {
5001 char line_buf[BUFSIZ] = { 0 };
5002
5003 int line_len = fgetl (fp, line_buf);
5004
5005 if (line_len == 0) continue;
5006
5007 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5008 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5009 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5010
5011 if (num_check == max_check) break;
5012
5013 num_check++;
5014 }
5015
5016 uint hashlist_format = HLFMT_HASHCAT;
5017
5018 for (int i = 1; i < HLFMTS_CNT; i++)
5019 {
5020 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5021
5022 hashlist_format = i;
5023 }
5024
5025 free (formats_cnt);
5026
5027 return hashlist_format;
5028 }
5029
5030 /**
5031 * some further helper function
5032 */
5033
5034 // wrapper around mymalloc for ADL
5035
5036 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5037 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5038 {
5039 return mymalloc (iSize);
5040 }
5041 #endif
5042
5043 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)
5044 {
5045 u64 collisions = 0;
5046
5047 const uint dgst_pos0 = data.dgst_pos0;
5048 const uint dgst_pos1 = data.dgst_pos1;
5049 const uint dgst_pos2 = data.dgst_pos2;
5050 const uint dgst_pos3 = data.dgst_pos3;
5051
5052 memset (bitmap_a, 0, bitmap_size);
5053 memset (bitmap_b, 0, bitmap_size);
5054 memset (bitmap_c, 0, bitmap_size);
5055 memset (bitmap_d, 0, bitmap_size);
5056
5057 for (uint i = 0; i < digests_cnt; i++)
5058 {
5059 uint *digest_ptr = (uint *) digests_buf_ptr;
5060
5061 digests_buf_ptr += dgst_size;
5062
5063 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5064 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5065 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5066 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5067
5068 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5069 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5070 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5071 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5072
5073 if (bitmap_a[idx0] & val0) collisions++;
5074 if (bitmap_b[idx1] & val1) collisions++;
5075 if (bitmap_c[idx2] & val2) collisions++;
5076 if (bitmap_d[idx3] & val3) collisions++;
5077
5078 bitmap_a[idx0] |= val0;
5079 bitmap_b[idx1] |= val1;
5080 bitmap_c[idx2] |= val2;
5081 bitmap_d[idx3] |= val3;
5082
5083 if (collisions >= collisions_max) return 0x7fffffff;
5084 }
5085
5086 return collisions;
5087 }
5088
5089 /**
5090 * main
5091 */
5092
5093 int main (int argc, char **argv)
5094 {
5095 /**
5096 * To help users a bit
5097 */
5098
5099 char *compute = getenv ("COMPUTE");
5100
5101 if (compute)
5102 {
5103 static char display[100];
5104
5105 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5106
5107 putenv (display);
5108 }
5109 else
5110 {
5111 if (getenv ("DISPLAY") == NULL)
5112 putenv ((char *) "DISPLAY=:0");
5113 }
5114
5115 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5116 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5117
5118 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5119 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5120
5121 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5122 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5123
5124 /**
5125 * Real init
5126 */
5127
5128 memset (&data, 0, sizeof (hc_global_data_t));
5129
5130 time_t proc_start;
5131
5132 time (&proc_start);
5133
5134 data.proc_start = proc_start;
5135
5136 int myargc = argc;
5137 char **myargv = argv;
5138
5139 hc_thread_mutex_init (mux_dispatcher);
5140 hc_thread_mutex_init (mux_counter);
5141 hc_thread_mutex_init (mux_display);
5142 hc_thread_mutex_init (mux_adl);
5143
5144 /**
5145 * commandline parameters
5146 */
5147
5148 uint usage = USAGE;
5149 uint version = VERSION;
5150 uint quiet = QUIET;
5151 uint benchmark = BENCHMARK;
5152 uint benchmark_mode = BENCHMARK_MODE;
5153 uint show = SHOW;
5154 uint left = LEFT;
5155 uint username = USERNAME;
5156 uint remove = REMOVE;
5157 uint remove_timer = REMOVE_TIMER;
5158 u64 skip = SKIP;
5159 u64 limit = LIMIT;
5160 uint keyspace = KEYSPACE;
5161 uint potfile_disable = POTFILE_DISABLE;
5162 uint debug_mode = DEBUG_MODE;
5163 char *debug_file = NULL;
5164 char *induction_dir = NULL;
5165 char *outfile_check_dir = NULL;
5166 uint force = FORCE;
5167 uint runtime = RUNTIME;
5168 uint hash_mode = HASH_MODE;
5169 uint attack_mode = ATTACK_MODE;
5170 uint markov_disable = MARKOV_DISABLE;
5171 uint markov_classic = MARKOV_CLASSIC;
5172 uint markov_threshold = MARKOV_THRESHOLD;
5173 char *markov_hcstat = NULL;
5174 char *outfile = NULL;
5175 uint outfile_format = OUTFILE_FORMAT;
5176 uint outfile_autohex = OUTFILE_AUTOHEX;
5177 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5178 uint restore = RESTORE;
5179 uint restore_timer = RESTORE_TIMER;
5180 uint restore_disable = RESTORE_DISABLE;
5181 uint status = STATUS;
5182 uint status_timer = STATUS_TIMER;
5183 uint status_automat = STATUS_AUTOMAT;
5184 uint loopback = LOOPBACK;
5185 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5186 char *session = NULL;
5187 uint hex_charset = HEX_CHARSET;
5188 uint hex_salt = HEX_SALT;
5189 uint hex_wordlist = HEX_WORDLIST;
5190 uint rp_gen = RP_GEN;
5191 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5192 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5193 uint rp_gen_seed = RP_GEN_SEED;
5194 char *rule_buf_l = (char *) RULE_BUF_L;
5195 char *rule_buf_r = (char *) RULE_BUF_R;
5196 uint increment = INCREMENT;
5197 uint increment_min = INCREMENT_MIN;
5198 uint increment_max = INCREMENT_MAX;
5199 #ifndef OSX
5200 char *cpu_affinity = NULL;
5201 #endif
5202 OCL_PTR *ocl = NULL;
5203 char *opencl_devices = NULL;
5204 char *opencl_platforms = NULL;
5205 char *opencl_device_types = NULL;
5206 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5207 char *truecrypt_keyfiles = NULL;
5208 uint workload_profile = WORKLOAD_PROFILE;
5209 uint kernel_accel = KERNEL_ACCEL;
5210 uint kernel_loops = KERNEL_LOOPS;
5211 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5212 #ifdef HAVE_HWMON
5213 uint gpu_temp_abort = GPU_TEMP_ABORT;
5214 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5215 #ifdef HAVE_ADL
5216 uint powertune_enable = POWERTUNE_ENABLE;
5217 #endif
5218 #endif
5219 uint logfile_disable = LOGFILE_DISABLE;
5220 uint segment_size = SEGMENT_SIZE;
5221 uint scrypt_tmto = SCRYPT_TMTO;
5222 char separator = SEPARATOR;
5223 uint bitmap_min = BITMAP_MIN;
5224 uint bitmap_max = BITMAP_MAX;
5225 char *custom_charset_1 = NULL;
5226 char *custom_charset_2 = NULL;
5227 char *custom_charset_3 = NULL;
5228 char *custom_charset_4 = NULL;
5229
5230 #define IDX_HELP 'h'
5231 #define IDX_VERSION 'V'
5232 #define IDX_VERSION_LOWER 'v'
5233 #define IDX_QUIET 0xff02
5234 #define IDX_SHOW 0xff03
5235 #define IDX_LEFT 0xff04
5236 #define IDX_REMOVE 0xff05
5237 #define IDX_REMOVE_TIMER 0xff37
5238 #define IDX_SKIP 's'
5239 #define IDX_LIMIT 'l'
5240 #define IDX_KEYSPACE 0xff35
5241 #define IDX_POTFILE_DISABLE 0xff06
5242 #define IDX_DEBUG_MODE 0xff43
5243 #define IDX_DEBUG_FILE 0xff44
5244 #define IDX_INDUCTION_DIR 0xff46
5245 #define IDX_OUTFILE_CHECK_DIR 0xff47
5246 #define IDX_USERNAME 0xff07
5247 #define IDX_FORCE 0xff08
5248 #define IDX_RUNTIME 0xff09
5249 #define IDX_BENCHMARK 'b'
5250 #define IDX_BENCHMARK_MODE 0xff32
5251 #define IDX_HASH_MODE 'm'
5252 #define IDX_ATTACK_MODE 'a'
5253 #define IDX_RP_FILE 'r'
5254 #define IDX_RP_GEN 'g'
5255 #define IDX_RP_GEN_FUNC_MIN 0xff10
5256 #define IDX_RP_GEN_FUNC_MAX 0xff11
5257 #define IDX_RP_GEN_SEED 0xff34
5258 #define IDX_RULE_BUF_L 'j'
5259 #define IDX_RULE_BUF_R 'k'
5260 #define IDX_INCREMENT 'i'
5261 #define IDX_INCREMENT_MIN 0xff12
5262 #define IDX_INCREMENT_MAX 0xff13
5263 #define IDX_OUTFILE 'o'
5264 #define IDX_OUTFILE_FORMAT 0xff14
5265 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5266 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5267 #define IDX_RESTORE 0xff15
5268 #define IDX_RESTORE_DISABLE 0xff27
5269 #define IDX_STATUS 0xff17
5270 #define IDX_STATUS_TIMER 0xff18
5271 #define IDX_STATUS_AUTOMAT 0xff50
5272 #define IDX_LOOPBACK 0xff38
5273 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5274 #define IDX_SESSION 0xff19
5275 #define IDX_HEX_CHARSET 0xff20
5276 #define IDX_HEX_SALT 0xff21
5277 #define IDX_HEX_WORDLIST 0xff40
5278 #define IDX_MARKOV_DISABLE 0xff22
5279 #define IDX_MARKOV_CLASSIC 0xff23
5280 #define IDX_MARKOV_THRESHOLD 't'
5281 #define IDX_MARKOV_HCSTAT 0xff24
5282 #define IDX_CPU_AFFINITY 0xff25
5283 #define IDX_OPENCL_DEVICES 'd'
5284 #define IDX_OPENCL_PLATFORMS 0xff72
5285 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5286 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5287 #define IDX_WORKLOAD_PROFILE 'w'
5288 #define IDX_KERNEL_ACCEL 'n'
5289 #define IDX_KERNEL_LOOPS 'u'
5290 #define IDX_GPU_TEMP_DISABLE 0xff29
5291 #define IDX_GPU_TEMP_ABORT 0xff30
5292 #define IDX_GPU_TEMP_RETAIN 0xff31
5293 #define IDX_POWERTUNE_ENABLE 0xff41
5294 #define IDX_LOGFILE_DISABLE 0xff51
5295 #define IDX_TRUECRYPT_KEYFILES 0xff52
5296 #define IDX_SCRYPT_TMTO 0xff61
5297 #define IDX_SEGMENT_SIZE 'c'
5298 #define IDX_SEPARATOR 'p'
5299 #define IDX_BITMAP_MIN 0xff70
5300 #define IDX_BITMAP_MAX 0xff71
5301 #define IDX_CUSTOM_CHARSET_1 '1'
5302 #define IDX_CUSTOM_CHARSET_2 '2'
5303 #define IDX_CUSTOM_CHARSET_3 '3'
5304 #define IDX_CUSTOM_CHARSET_4 '4'
5305
5306 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5307
5308 struct option long_options[] =
5309 {
5310 {"help", no_argument, 0, IDX_HELP},
5311 {"version", no_argument, 0, IDX_VERSION},
5312 {"quiet", no_argument, 0, IDX_QUIET},
5313 {"show", no_argument, 0, IDX_SHOW},
5314 {"left", no_argument, 0, IDX_LEFT},
5315 {"username", no_argument, 0, IDX_USERNAME},
5316 {"remove", no_argument, 0, IDX_REMOVE},
5317 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5318 {"skip", required_argument, 0, IDX_SKIP},
5319 {"limit", required_argument, 0, IDX_LIMIT},
5320 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5321 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5322 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5323 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5324 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5325 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5326 {"force", no_argument, 0, IDX_FORCE},
5327 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5328 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5329 {"restore", no_argument, 0, IDX_RESTORE},
5330 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5331 {"status", no_argument, 0, IDX_STATUS},
5332 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5333 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5334 {"loopback", no_argument, 0, IDX_LOOPBACK},
5335 {"weak-hash-threshold",
5336 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5337 {"session", required_argument, 0, IDX_SESSION},
5338 {"runtime", required_argument, 0, IDX_RUNTIME},
5339 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5340 {"generate-rules-func-min",
5341 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5342 {"generate-rules-func-max",
5343 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5344 {"generate-rules-seed",
5345 required_argument, 0, IDX_RP_GEN_SEED},
5346 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5347 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5348 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5349 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5350 {"rules-file", required_argument, 0, IDX_RP_FILE},
5351 {"outfile", required_argument, 0, IDX_OUTFILE},
5352 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5353 {"outfile-autohex-disable",
5354 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5355 {"outfile-check-timer",
5356 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5357 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5358 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5359 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5360 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5361 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5362 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5363 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5364 #ifndef OSX
5365 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5366 #endif
5367 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5368 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5369 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5370 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5371 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5372 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5373 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5374 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5375 #ifdef HAVE_HWMON
5376 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5377 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5378 #ifdef HAVE_ADL
5379 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5380 #endif
5381 #endif // HAVE_HWMON
5382 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5383 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5384 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5385 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5386 // deprecated
5387 {"seperator", required_argument, 0, IDX_SEPARATOR},
5388 {"separator", required_argument, 0, IDX_SEPARATOR},
5389 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5390 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5391 {"increment", no_argument, 0, IDX_INCREMENT},
5392 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5393 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5394 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5395 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5396 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5397 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5398
5399 {0, 0, 0, 0}
5400 };
5401
5402 uint rp_files_cnt = 0;
5403
5404 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5405
5406 int option_index = 0;
5407 int c = -1;
5408
5409 optind = 1;
5410 optopt = 0;
5411
5412 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5413 {
5414 switch (c)
5415 {
5416 case IDX_HELP: usage = 1; break;
5417 case IDX_VERSION:
5418 case IDX_VERSION_LOWER: version = 1; break;
5419 case IDX_RESTORE: restore = 1; break;
5420 case IDX_SESSION: session = optarg; break;
5421 case IDX_SHOW: show = 1; break;
5422 case IDX_LEFT: left = 1; break;
5423 case '?': return (-1);
5424 }
5425 }
5426
5427 if (optopt != 0)
5428 {
5429 log_error ("ERROR: Invalid argument specified");
5430
5431 return (-1);
5432 }
5433
5434 /**
5435 * exit functions
5436 */
5437
5438 if (version)
5439 {
5440 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5441
5442 return (0);
5443 }
5444
5445 if (usage)
5446 {
5447 usage_big_print (PROGNAME);
5448
5449 return (0);
5450 }
5451
5452 /**
5453 * session needs to be set, always!
5454 */
5455
5456 if (session == NULL) session = (char *) PROGNAME;
5457
5458 /**
5459 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5460 */
5461
5462 char *exec_path = get_exec_path ();
5463
5464 #ifdef LINUX
5465
5466 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5467 char *resolved_exec_path = realpath (exec_path, NULL);
5468
5469 char *install_dir = get_install_dir (resolved_exec_path);
5470 char *profile_dir = NULL;
5471 char *session_dir = NULL;
5472 char *shared_dir = NULL;
5473
5474 if (strcmp (install_dir, resolved_install_folder) == 0)
5475 {
5476 struct passwd *pw = getpwuid (getuid ());
5477
5478 const char *homedir = pw->pw_dir;
5479
5480 profile_dir = get_profile_dir (homedir);
5481 session_dir = get_session_dir (profile_dir);
5482 shared_dir = strdup (SHARED_FOLDER);
5483
5484 mkdir (profile_dir, 0700);
5485 mkdir (session_dir, 0700);
5486 }
5487 else
5488 {
5489 profile_dir = install_dir;
5490 session_dir = install_dir;
5491 shared_dir = install_dir;
5492 }
5493
5494 myfree (resolved_install_folder);
5495 myfree (resolved_exec_path);
5496
5497 #else
5498
5499 char *install_dir = get_install_dir (exec_path);
5500 char *profile_dir = install_dir;
5501 char *session_dir = install_dir;
5502 char *shared_dir = install_dir;
5503
5504 #endif
5505
5506 data.install_dir = install_dir;
5507 data.profile_dir = profile_dir;
5508 data.session_dir = session_dir;
5509 data.shared_dir = shared_dir;
5510
5511 myfree (exec_path);
5512
5513 /**
5514 * kernel cache, we need to make sure folder exist
5515 */
5516
5517 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5518
5519 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5520
5521 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5522
5523 mkdir (kernels_folder, 0700);
5524
5525 myfree (kernels_folder);
5526
5527 /**
5528 * session
5529 */
5530
5531 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5532
5533 data.session = session;
5534
5535 char *eff_restore_file = (char *) mymalloc (session_size);
5536 char *new_restore_file = (char *) mymalloc (session_size);
5537
5538 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5539 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5540
5541 data.eff_restore_file = eff_restore_file;
5542 data.new_restore_file = new_restore_file;
5543
5544 if (((show == 1) || (left == 1)) && (restore == 1))
5545 {
5546 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5547 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5548
5549 return (-1);
5550 }
5551
5552 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5553 if ((show == 1) || (left == 1))
5554 {
5555 restore_disable = 1;
5556
5557 restore = 0;
5558 }
5559
5560 data.restore_disable = restore_disable;
5561
5562 restore_data_t *rd = init_restore (argc, argv);
5563
5564 data.rd = rd;
5565
5566 /**
5567 * restore file
5568 */
5569
5570 if (restore == 1)
5571 {
5572 read_restore (eff_restore_file, rd);
5573
5574 if (rd->version_bin < RESTORE_MIN)
5575 {
5576 log_error ("ERROR: Incompatible restore-file version");
5577
5578 return (-1);
5579 }
5580
5581 myargc = rd->argc;
5582 myargv = rd->argv;
5583
5584 #ifdef _POSIX
5585 rd->pid = getpid ();
5586 #elif _WIN
5587 rd->pid = GetCurrentProcessId ();
5588 #endif
5589 }
5590
5591 uint hash_mode_chgd = 0;
5592 uint runtime_chgd = 0;
5593 uint kernel_loops_chgd = 0;
5594 uint kernel_accel_chgd = 0;
5595 uint attack_mode_chgd = 0;
5596 uint outfile_format_chgd = 0;
5597 uint rp_gen_seed_chgd = 0;
5598 uint remove_timer_chgd = 0;
5599 uint increment_min_chgd = 0;
5600 uint increment_max_chgd = 0;
5601 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5602 uint gpu_temp_retain_chgd = 0;
5603 uint gpu_temp_abort_chgd = 0;
5604 #endif
5605
5606 optind = 1;
5607 optopt = 0;
5608 option_index = 0;
5609
5610 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5611 {
5612 switch (c)
5613 {
5614 //case IDX_HELP: usage = 1; break;
5615 //case IDX_VERSION: version = 1; break;
5616 //case IDX_RESTORE: restore = 1; break;
5617 case IDX_QUIET: quiet = 1; break;
5618 //case IDX_SHOW: show = 1; break;
5619 case IDX_SHOW: break;
5620 //case IDX_LEFT: left = 1; break;
5621 case IDX_LEFT: break;
5622 case IDX_USERNAME: username = 1; break;
5623 case IDX_REMOVE: remove = 1; break;
5624 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5625 remove_timer_chgd = 1; break;
5626 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5627 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5628 case IDX_DEBUG_FILE: debug_file = optarg; break;
5629 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5630 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5631 case IDX_FORCE: force = 1; break;
5632 case IDX_SKIP: skip = atoll (optarg); break;
5633 case IDX_LIMIT: limit = atoll (optarg); break;
5634 case IDX_KEYSPACE: keyspace = 1; break;
5635 case IDX_BENCHMARK: benchmark = 1; break;
5636 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5637 case IDX_RESTORE: break;
5638 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5639 case IDX_STATUS: status = 1; break;
5640 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5641 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5642 case IDX_LOOPBACK: loopback = 1; break;
5643 case IDX_WEAK_HASH_THRESHOLD:
5644 weak_hash_threshold = atoi (optarg); break;
5645 //case IDX_SESSION: session = optarg; break;
5646 case IDX_SESSION: break;
5647 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5648 hash_mode_chgd = 1; break;
5649 case IDX_RUNTIME: runtime = atoi (optarg);
5650 runtime_chgd = 1; break;
5651 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5652 attack_mode_chgd = 1; break;
5653 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5654 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5655 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5656 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5657 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5658 rp_gen_seed_chgd = 1; break;
5659 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5660 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5661 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5662 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5663 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5664 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5665 case IDX_OUTFILE: outfile = optarg; break;
5666 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5667 outfile_format_chgd = 1; break;
5668 case IDX_OUTFILE_AUTOHEX_DISABLE:
5669 outfile_autohex = 0; break;
5670 case IDX_OUTFILE_CHECK_TIMER:
5671 outfile_check_timer = atoi (optarg); break;
5672 case IDX_HEX_CHARSET: hex_charset = 1; break;
5673 case IDX_HEX_SALT: hex_salt = 1; break;
5674 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5675 #ifndef OSX
5676 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5677 #endif
5678 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5679 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5680 case IDX_OPENCL_DEVICE_TYPES:
5681 opencl_device_types = optarg; break;
5682 case IDX_OPENCL_VECTOR_WIDTH:
5683 opencl_vector_width = atoi (optarg); break;
5684 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5685 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5686 kernel_accel_chgd = 1; break;
5687 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5688 kernel_loops_chgd = 1; break;
5689 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5690 #ifdef HAVE_HWMON
5691 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5692 #ifdef HAVE_ADL
5693 gpu_temp_abort_chgd = 1;
5694 #endif
5695 break;
5696 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5697 #ifdef HAVE_ADL
5698 gpu_temp_retain_chgd = 1;
5699 #endif
5700 break;
5701 #ifdef HAVE_ADL
5702 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5703 #endif
5704 #endif // HAVE_HWMON
5705 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5706 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5707 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5708 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5709 case IDX_SEPARATOR: separator = optarg[0]; break;
5710 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5711 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5712 case IDX_INCREMENT: increment = 1; break;
5713 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5714 increment_min_chgd = 1; break;
5715 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5716 increment_max_chgd = 1; break;
5717 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5718 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5719 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5720 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5721
5722 default:
5723 log_error ("ERROR: Invalid argument specified");
5724 return (-1);
5725 }
5726 }
5727
5728 if (optopt != 0)
5729 {
5730 log_error ("ERROR: Invalid argument specified");
5731
5732 return (-1);
5733 }
5734
5735 /**
5736 * Inform user things getting started,
5737 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5738 * - we do not need to check algorithm_pos
5739 */
5740
5741 if (quiet == 0)
5742 {
5743 if (benchmark == 1)
5744 {
5745 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5746
5747 log_info ("");
5748 }
5749 else if (restore == 1)
5750 {
5751 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5752
5753 log_info ("");
5754 }
5755 else
5756 {
5757 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5758
5759 log_info ("");
5760 }
5761 }
5762
5763 /**
5764 * sanity check
5765 */
5766
5767 if (attack_mode > 7)
5768 {
5769 log_error ("ERROR: Invalid attack-mode specified");
5770
5771 return (-1);
5772 }
5773
5774 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5775 {
5776 log_error ("ERROR: Invalid runtime specified");
5777
5778 return (-1);
5779 }
5780
5781 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5782 {
5783 log_error ("ERROR: Invalid hash-type specified");
5784
5785 return (-1);
5786 }
5787
5788 // renamed hash modes
5789
5790 if (hash_mode_chgd)
5791 {
5792 int n = -1;
5793
5794 switch (hash_mode)
5795 {
5796 case 123: n = 124;
5797 break;
5798 }
5799
5800 if (n >= 0)
5801 {
5802 log_error ("Old -m specified, use -m %d instead", n);
5803
5804 return (-1);
5805 }
5806 }
5807
5808 if (username == 1)
5809 {
5810 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5811 {
5812 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5813
5814 return (-1);
5815 }
5816 }
5817
5818 if (outfile_format > 16)
5819 {
5820 log_error ("ERROR: Invalid outfile-format specified");
5821
5822 return (-1);
5823 }
5824
5825 if (left == 1)
5826 {
5827 if (outfile_format_chgd == 1)
5828 {
5829 if (outfile_format > 1)
5830 {
5831 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5832
5833 return (-1);
5834 }
5835 }
5836 else
5837 {
5838 outfile_format = OUTFILE_FMT_HASH;
5839 }
5840 }
5841
5842 if (show == 1)
5843 {
5844 if (outfile_format_chgd == 1)
5845 {
5846 if ((outfile_format > 7) && (outfile_format < 16))
5847 {
5848 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5849
5850 return (-1);
5851 }
5852 }
5853 }
5854
5855 if (increment_min < INCREMENT_MIN)
5856 {
5857 log_error ("ERROR: Invalid increment-min specified");
5858
5859 return (-1);
5860 }
5861
5862 if (increment_max > INCREMENT_MAX)
5863 {
5864 log_error ("ERROR: Invalid increment-max specified");
5865
5866 return (-1);
5867 }
5868
5869 if (increment_min > increment_max)
5870 {
5871 log_error ("ERROR: Invalid increment-min specified");
5872
5873 return (-1);
5874 }
5875
5876 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5877 {
5878 log_error ("ERROR: increment is not allowed in attack-mode 0");
5879
5880 return (-1);
5881 }
5882
5883 if ((increment == 0) && (increment_min_chgd == 1))
5884 {
5885 log_error ("ERROR: increment-min is only supported together with increment switch");
5886
5887 return (-1);
5888 }
5889
5890 if ((increment == 0) && (increment_max_chgd == 1))
5891 {
5892 log_error ("ERROR: increment-max is only supported together with increment switch");
5893
5894 return (-1);
5895 }
5896
5897 if (rp_files_cnt && rp_gen)
5898 {
5899 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5900
5901 return (-1);
5902 }
5903
5904 if (rp_files_cnt || rp_gen)
5905 {
5906 if (attack_mode != ATTACK_MODE_STRAIGHT)
5907 {
5908 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5909
5910 return (-1);
5911 }
5912 }
5913
5914 if (rp_gen_func_min > rp_gen_func_max)
5915 {
5916 log_error ("ERROR: Invalid rp-gen-func-min specified");
5917
5918 return (-1);
5919 }
5920
5921 if (kernel_accel_chgd == 1)
5922 {
5923 if (workload_profile != WORKLOAD_PROFILE)
5924 {
5925 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5926
5927 return (-1);
5928 }
5929
5930 if (kernel_accel < 1)
5931 {
5932 log_error ("ERROR: Invalid kernel-accel specified");
5933
5934 return (-1);
5935 }
5936
5937 if (kernel_accel > 800)
5938 {
5939 log_error ("ERROR: Invalid kernel-accel specified");
5940
5941 return (-1);
5942 }
5943 }
5944
5945 if (kernel_loops_chgd == 1)
5946 {
5947 if (workload_profile != WORKLOAD_PROFILE)
5948 {
5949 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5950
5951 return (-1);
5952 }
5953
5954 if (kernel_loops < 1)
5955 {
5956 log_error ("ERROR: Invalid kernel-loops specified");
5957
5958 return (-1);
5959 }
5960
5961 if (kernel_loops > 1024)
5962 {
5963 log_error ("ERROR: Invalid kernel-loops specified");
5964
5965 return (-1);
5966 }
5967 }
5968
5969 if (benchmark == 1)
5970 {
5971 if (workload_profile != WORKLOAD_PROFILE)
5972 {
5973 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5974
5975 return (-1);
5976 }
5977 }
5978
5979 if ((workload_profile < 1) || (workload_profile > 3))
5980 {
5981 log_error ("ERROR: workload-profile %i not available", workload_profile);
5982
5983 return (-1);
5984 }
5985
5986 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5987 {
5988 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5989
5990 return (-1);
5991 }
5992
5993 if (show == 1 || left == 1)
5994 {
5995 attack_mode = ATTACK_MODE_NONE;
5996
5997 if (remove == 1)
5998 {
5999 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6000
6001 return (-1);
6002 }
6003
6004 if (potfile_disable == 1)
6005 {
6006 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6007
6008 return (-1);
6009 }
6010 }
6011
6012 uint attack_kern = ATTACK_KERN_NONE;
6013
6014 switch (attack_mode)
6015 {
6016 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6017 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6018 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6019 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6020 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6021 }
6022
6023 if (benchmark == 0)
6024 {
6025 if (keyspace == 1)
6026 {
6027 int num_additional_params = 1;
6028
6029 if (attack_kern == ATTACK_KERN_COMBI)
6030 {
6031 num_additional_params = 2;
6032 }
6033
6034 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6035
6036 if (keyspace_wordlist_specified == 0) optind--;
6037 }
6038
6039 if (attack_kern == ATTACK_KERN_NONE)
6040 {
6041 if ((optind + 1) != myargc)
6042 {
6043 usage_mini_print (myargv[0]);
6044
6045 return (-1);
6046 }
6047 }
6048 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6049 {
6050 if ((optind + 1) > myargc)
6051 {
6052 usage_mini_print (myargv[0]);
6053
6054 return (-1);
6055 }
6056 }
6057 else if (attack_kern == ATTACK_KERN_COMBI)
6058 {
6059 if ((optind + 3) != myargc)
6060 {
6061 usage_mini_print (myargv[0]);
6062
6063 return (-1);
6064 }
6065 }
6066 else if (attack_kern == ATTACK_KERN_BF)
6067 {
6068 if ((optind + 1) > myargc)
6069 {
6070 usage_mini_print (myargv[0]);
6071
6072 return (-1);
6073 }
6074 }
6075 else
6076 {
6077 usage_mini_print (myargv[0]);
6078
6079 return (-1);
6080 }
6081 }
6082 else
6083 {
6084 if (myargv[optind] != 0)
6085 {
6086 log_error ("ERROR: Invalid argument for benchmark mode specified");
6087
6088 return (-1);
6089 }
6090
6091 if (attack_mode_chgd == 1)
6092 {
6093 if (attack_mode != ATTACK_MODE_BF)
6094 {
6095 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6096
6097 return (-1);
6098 }
6099 }
6100
6101 if (benchmark_mode == 0)
6102 {
6103 // nothing to do
6104 }
6105 else if (benchmark_mode == 1)
6106 {
6107 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6108 {
6109 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6110
6111 return (-1);
6112 }
6113 }
6114 else
6115 {
6116 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6117
6118 return (-1);
6119 }
6120 }
6121
6122 if (skip != 0 && limit != 0)
6123 {
6124 limit += skip;
6125 }
6126
6127 if (keyspace == 1)
6128 {
6129 if (show == 1)
6130 {
6131 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6132
6133 return (-1);
6134 }
6135 else if (left == 1)
6136 {
6137 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6138
6139 return (-1);
6140 }
6141
6142 potfile_disable = 1;
6143
6144 restore_disable = 1;
6145
6146 restore = 0;
6147
6148 weak_hash_threshold = 0;
6149
6150 quiet = 1;
6151 }
6152
6153 if (remove_timer_chgd == 1)
6154 {
6155 if (remove == 0)
6156 {
6157 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6158
6159 return (-1);
6160 }
6161
6162 if (remove_timer < 1)
6163 {
6164 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6165
6166 return (-1);
6167 }
6168 }
6169
6170 if (loopback == 1)
6171 {
6172 if (attack_mode == ATTACK_MODE_BF)
6173 {
6174 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6175
6176 return (-1);
6177 }
6178 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6179 {
6180 if ((rp_files_cnt == 0) && (rp_gen == 0))
6181 {
6182 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6183
6184 return (-1);
6185 }
6186 }
6187 }
6188
6189 if (debug_mode > 0)
6190 {
6191 if (attack_mode != ATTACK_MODE_STRAIGHT)
6192 {
6193 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6194
6195 return (-1);
6196 }
6197
6198 if ((rp_files_cnt == 0) && (rp_gen == 0))
6199 {
6200 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6201
6202 return (-1);
6203 }
6204 }
6205
6206 if (debug_mode > 4)
6207 {
6208 log_error ("ERROR: Invalid debug-mode specified");
6209
6210 return (-1);
6211 }
6212
6213 if (debug_file != NULL)
6214 {
6215 if (debug_mode < 1)
6216 {
6217 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6218
6219 return (-1);
6220 }
6221 }
6222
6223 if (induction_dir != NULL)
6224 {
6225 if (attack_mode == ATTACK_MODE_BF)
6226 {
6227 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6228
6229 return (-1);
6230 }
6231 }
6232
6233 if (attack_mode != ATTACK_MODE_STRAIGHT)
6234 {
6235 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6236 {
6237 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6238
6239 return (-1);
6240 }
6241
6242 weak_hash_threshold = 0;
6243 }
6244
6245 /**
6246 * induction directory
6247 */
6248
6249 char *induction_directory = NULL;
6250
6251 if (attack_mode != ATTACK_MODE_BF)
6252 {
6253 if (induction_dir == NULL)
6254 {
6255 induction_directory = (char *) mymalloc (session_size);
6256
6257 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6258
6259 // create induction folder if it does not already exist
6260
6261 if (keyspace == 0)
6262 {
6263 if (rmdir (induction_directory) == -1)
6264 {
6265 if (errno == ENOENT)
6266 {
6267 // good, we can ignore
6268 }
6269 else if (errno == ENOTEMPTY)
6270 {
6271 char *induction_directory_mv = (char *) mymalloc (session_size);
6272
6273 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6274
6275 if (rename (induction_directory, induction_directory_mv) != 0)
6276 {
6277 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6278
6279 return (-1);
6280 }
6281 }
6282 else
6283 {
6284 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6285
6286 return (-1);
6287 }
6288 }
6289
6290 if (mkdir (induction_directory, 0700) == -1)
6291 {
6292 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6293
6294 return (-1);
6295 }
6296 }
6297 }
6298 else
6299 {
6300 induction_directory = induction_dir;
6301 }
6302 }
6303
6304 data.induction_directory = induction_directory;
6305
6306 /**
6307 * loopback
6308 */
6309
6310 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6311
6312 char *loopback_file = (char *) mymalloc (loopback_size);
6313
6314 /**
6315 * outfile-check directory
6316 */
6317
6318 char *outfile_check_directory = NULL;
6319
6320 if (outfile_check_dir == NULL)
6321 {
6322 outfile_check_directory = (char *) mymalloc (session_size);
6323
6324 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6325 }
6326 else
6327 {
6328 outfile_check_directory = outfile_check_dir;
6329 }
6330
6331 data.outfile_check_directory = outfile_check_directory;
6332
6333 if (keyspace == 0)
6334 {
6335 struct stat outfile_check_stat;
6336
6337 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6338 {
6339 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6340
6341 if (is_dir == 0)
6342 {
6343 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6344
6345 return (-1);
6346 }
6347 }
6348 else if (outfile_check_dir == NULL)
6349 {
6350 if (mkdir (outfile_check_directory, 0700) == -1)
6351 {
6352 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6353
6354 return (-1);
6355 }
6356 }
6357 }
6358
6359 /**
6360 * special other stuff
6361 */
6362
6363 if (hash_mode == 9710)
6364 {
6365 outfile_format = 5;
6366 outfile_format_chgd = 1;
6367 }
6368
6369 if (hash_mode == 9810)
6370 {
6371 outfile_format = 5;
6372 outfile_format_chgd = 1;
6373 }
6374
6375 if (hash_mode == 10410)
6376 {
6377 outfile_format = 5;
6378 outfile_format_chgd = 1;
6379 }
6380
6381 /**
6382 * store stuff
6383 */
6384
6385 data.hash_mode = hash_mode;
6386 data.restore = restore;
6387 data.restore_timer = restore_timer;
6388 data.restore_disable = restore_disable;
6389 data.status = status;
6390 data.status_timer = status_timer;
6391 data.status_automat = status_automat;
6392 data.loopback = loopback;
6393 data.runtime = runtime;
6394 data.remove = remove;
6395 data.remove_timer = remove_timer;
6396 data.debug_mode = debug_mode;
6397 data.debug_file = debug_file;
6398 data.username = username;
6399 data.quiet = quiet;
6400 data.outfile = outfile;
6401 data.outfile_format = outfile_format;
6402 data.outfile_autohex = outfile_autohex;
6403 data.hex_charset = hex_charset;
6404 data.hex_salt = hex_salt;
6405 data.hex_wordlist = hex_wordlist;
6406 data.separator = separator;
6407 data.rp_files = rp_files;
6408 data.rp_files_cnt = rp_files_cnt;
6409 data.rp_gen = rp_gen;
6410 data.rp_gen_seed = rp_gen_seed;
6411 data.force = force;
6412 data.benchmark = benchmark;
6413 data.skip = skip;
6414 data.limit = limit;
6415 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6416 data.powertune_enable = powertune_enable;
6417 #endif
6418 data.logfile_disable = logfile_disable;
6419 data.truecrypt_keyfiles = truecrypt_keyfiles;
6420 data.scrypt_tmto = scrypt_tmto;
6421
6422 /**
6423 * cpu affinity
6424 */
6425
6426 #ifndef OSX
6427 if (cpu_affinity)
6428 {
6429 set_cpu_affinity (cpu_affinity);
6430 }
6431 #endif
6432
6433 if (rp_gen_seed_chgd == 0)
6434 {
6435 srand (proc_start);
6436 }
6437 else
6438 {
6439 srand (rp_gen_seed);
6440 }
6441
6442 /**
6443 * logfile init
6444 */
6445
6446 if (logfile_disable == 0)
6447 {
6448 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6449
6450 char *logfile = (char *) mymalloc (logfile_size);
6451
6452 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6453
6454 data.logfile = logfile;
6455
6456 char *topid = logfile_generate_topid ();
6457
6458 data.topid = topid;
6459 }
6460
6461 // logfile_append() checks for logfile_disable internally to make it easier from here
6462
6463 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6464 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6465 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6466 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6467 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6468 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6469 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6470 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6471 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6472 #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));
6473
6474 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6475 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6476 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6477 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6478 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6479 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6480 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6481 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6482
6483 logfile_top_msg ("START");
6484
6485 logfile_top_uint (attack_mode);
6486 logfile_top_uint (attack_kern);
6487 logfile_top_uint (benchmark);
6488 logfile_top_uint (benchmark_mode);
6489 logfile_top_uint (bitmap_min);
6490 logfile_top_uint (bitmap_max);
6491 logfile_top_uint (debug_mode);
6492 logfile_top_uint (force);
6493 logfile_top_uint (kernel_accel);
6494 logfile_top_uint (kernel_loops);
6495 logfile_top_uint (gpu_temp_disable);
6496 #ifdef HAVE_HWMON
6497 logfile_top_uint (gpu_temp_abort);
6498 logfile_top_uint (gpu_temp_retain);
6499 #endif
6500 logfile_top_uint (hash_mode);
6501 logfile_top_uint (hex_charset);
6502 logfile_top_uint (hex_salt);
6503 logfile_top_uint (hex_wordlist);
6504 logfile_top_uint (increment);
6505 logfile_top_uint (increment_max);
6506 logfile_top_uint (increment_min);
6507 logfile_top_uint (keyspace);
6508 logfile_top_uint (left);
6509 logfile_top_uint (logfile_disable);
6510 logfile_top_uint (loopback);
6511 logfile_top_uint (markov_classic);
6512 logfile_top_uint (markov_disable);
6513 logfile_top_uint (markov_threshold);
6514 logfile_top_uint (outfile_autohex);
6515 logfile_top_uint (outfile_check_timer);
6516 logfile_top_uint (outfile_format);
6517 logfile_top_uint (potfile_disable);
6518 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6519 logfile_top_uint (powertune_enable);
6520 #endif
6521 logfile_top_uint (scrypt_tmto);
6522 logfile_top_uint (quiet);
6523 logfile_top_uint (remove);
6524 logfile_top_uint (remove_timer);
6525 logfile_top_uint (restore);
6526 logfile_top_uint (restore_disable);
6527 logfile_top_uint (restore_timer);
6528 logfile_top_uint (rp_gen);
6529 logfile_top_uint (rp_gen_func_max);
6530 logfile_top_uint (rp_gen_func_min);
6531 logfile_top_uint (rp_gen_seed);
6532 logfile_top_uint (runtime);
6533 logfile_top_uint (segment_size);
6534 logfile_top_uint (show);
6535 logfile_top_uint (status);
6536 logfile_top_uint (status_automat);
6537 logfile_top_uint (status_timer);
6538 logfile_top_uint (usage);
6539 logfile_top_uint (username);
6540 logfile_top_uint (version);
6541 logfile_top_uint (weak_hash_threshold);
6542 logfile_top_uint (workload_profile);
6543 logfile_top_uint64 (limit);
6544 logfile_top_uint64 (skip);
6545 logfile_top_char (separator);
6546 #ifndef OSX
6547 logfile_top_string (cpu_affinity);
6548 #endif
6549 logfile_top_string (custom_charset_1);
6550 logfile_top_string (custom_charset_2);
6551 logfile_top_string (custom_charset_3);
6552 logfile_top_string (custom_charset_4);
6553 logfile_top_string (debug_file);
6554 logfile_top_string (opencl_devices);
6555 logfile_top_string (opencl_platforms);
6556 logfile_top_string (opencl_device_types);
6557 logfile_top_uint (opencl_vector_width);
6558 logfile_top_string (induction_dir);
6559 logfile_top_string (markov_hcstat);
6560 logfile_top_string (outfile);
6561 logfile_top_string (outfile_check_dir);
6562 logfile_top_string (rule_buf_l);
6563 logfile_top_string (rule_buf_r);
6564 logfile_top_string (session);
6565 logfile_top_string (truecrypt_keyfiles);
6566
6567 /**
6568 * Init OpenCL library loader
6569 */
6570
6571 if (keyspace == 0)
6572 {
6573 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6574
6575 ocl_init (ocl);
6576
6577 data.ocl = ocl;
6578 }
6579
6580 /**
6581 * OpenCL platform selection
6582 */
6583
6584 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6585
6586 /**
6587 * OpenCL device selection
6588 */
6589
6590 u32 devices_filter = setup_devices_filter (opencl_devices);
6591
6592 /**
6593 * OpenCL device type selection
6594 */
6595
6596 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6597
6598 /**
6599 * benchmark
6600 */
6601
6602 if (benchmark == 1)
6603 {
6604 /**
6605 * disable useless stuff for benchmark
6606 */
6607
6608 restore_timer = 0;
6609 status_timer = 0;
6610 restore_disable = 1;
6611 potfile_disable = 1;
6612 weak_hash_threshold = 0;
6613
6614 data.restore_timer = restore_timer;
6615 data.status_timer = status_timer;
6616 data.restore_disable = restore_disable;
6617
6618 if (benchmark_mode == 1)
6619 {
6620 markov_disable = 1;
6621 }
6622
6623 /**
6624 * force attack mode to be bruteforce
6625 */
6626
6627 attack_mode = ATTACK_MODE_BF;
6628 attack_kern = ATTACK_KERN_BF;
6629
6630 if (runtime_chgd == 0)
6631 {
6632 runtime = 8;
6633
6634 if (benchmark_mode == 1) runtime = 17;
6635
6636 data.runtime = runtime;
6637 }
6638 }
6639
6640 /**
6641 * config
6642 */
6643
6644 uint hash_type = 0;
6645 uint salt_type = 0;
6646 uint attack_exec = 0;
6647 uint opts_type = 0;
6648 uint kern_type = 0;
6649 uint dgst_size = 0;
6650 uint esalt_size = 0;
6651 uint opti_type = 0;
6652 uint dgst_pos0 = -1;
6653 uint dgst_pos1 = -1;
6654 uint dgst_pos2 = -1;
6655 uint dgst_pos3 = -1;
6656
6657 int (*parse_func) (char *, uint, hash_t *);
6658 int (*sort_by_digest) (const void *, const void *);
6659
6660 uint algorithm_pos = 0;
6661 uint algorithm_max = 1;
6662
6663 uint *algorithms = default_benchmark_algorithms;
6664
6665 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6666
6667 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6668 {
6669 /*
6670 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6671 * the following algos are skipped entirely
6672 */
6673
6674 if (algorithm_pos > 0)
6675 {
6676 local_free (rd);
6677
6678 rd = init_restore (argc, argv);
6679
6680 data.rd = rd;
6681 }
6682
6683 /**
6684 * update hash_mode in case of multihash benchmark
6685 */
6686
6687 if (benchmark == 1)
6688 {
6689 if (hash_mode_chgd == 0)
6690 {
6691 hash_mode = algorithms[algorithm_pos];
6692
6693 data.hash_mode = hash_mode;
6694 }
6695
6696 quiet = 1;
6697
6698 data.quiet = quiet;
6699 }
6700
6701 switch (hash_mode)
6702 {
6703 case 0: hash_type = HASH_TYPE_MD5;
6704 salt_type = SALT_TYPE_NONE;
6705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6706 opts_type = OPTS_TYPE_PT_GENERATE_LE
6707 | OPTS_TYPE_PT_ADD80
6708 | OPTS_TYPE_PT_ADDBITS14;
6709 kern_type = KERN_TYPE_MD5;
6710 dgst_size = DGST_SIZE_4_4;
6711 parse_func = md5_parse_hash;
6712 sort_by_digest = sort_by_digest_4_4;
6713 opti_type = OPTI_TYPE_ZERO_BYTE
6714 | OPTI_TYPE_PRECOMPUTE_INIT
6715 | OPTI_TYPE_PRECOMPUTE_MERKLE
6716 | OPTI_TYPE_MEET_IN_MIDDLE
6717 | OPTI_TYPE_EARLY_SKIP
6718 | OPTI_TYPE_NOT_ITERATED
6719 | OPTI_TYPE_NOT_SALTED
6720 | OPTI_TYPE_RAW_HASH;
6721 dgst_pos0 = 0;
6722 dgst_pos1 = 3;
6723 dgst_pos2 = 2;
6724 dgst_pos3 = 1;
6725 break;
6726
6727 case 10: hash_type = HASH_TYPE_MD5;
6728 salt_type = SALT_TYPE_INTERN;
6729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6730 opts_type = OPTS_TYPE_PT_GENERATE_LE
6731 | OPTS_TYPE_ST_ADD80
6732 | OPTS_TYPE_ST_ADDBITS14;
6733 kern_type = KERN_TYPE_MD5_PWSLT;
6734 dgst_size = DGST_SIZE_4_4;
6735 parse_func = md5s_parse_hash;
6736 sort_by_digest = sort_by_digest_4_4;
6737 opti_type = OPTI_TYPE_ZERO_BYTE
6738 | OPTI_TYPE_PRECOMPUTE_INIT
6739 | OPTI_TYPE_PRECOMPUTE_MERKLE
6740 | OPTI_TYPE_MEET_IN_MIDDLE
6741 | OPTI_TYPE_EARLY_SKIP
6742 | OPTI_TYPE_NOT_ITERATED
6743 | OPTI_TYPE_APPENDED_SALT
6744 | OPTI_TYPE_RAW_HASH;
6745 dgst_pos0 = 0;
6746 dgst_pos1 = 3;
6747 dgst_pos2 = 2;
6748 dgst_pos3 = 1;
6749 break;
6750
6751 case 11: hash_type = HASH_TYPE_MD5;
6752 salt_type = SALT_TYPE_INTERN;
6753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6754 opts_type = OPTS_TYPE_PT_GENERATE_LE
6755 | OPTS_TYPE_ST_ADD80
6756 | OPTS_TYPE_ST_ADDBITS14;
6757 kern_type = KERN_TYPE_MD5_PWSLT;
6758 dgst_size = DGST_SIZE_4_4;
6759 parse_func = joomla_parse_hash;
6760 sort_by_digest = sort_by_digest_4_4;
6761 opti_type = OPTI_TYPE_ZERO_BYTE
6762 | OPTI_TYPE_PRECOMPUTE_INIT
6763 | OPTI_TYPE_PRECOMPUTE_MERKLE
6764 | OPTI_TYPE_MEET_IN_MIDDLE
6765 | OPTI_TYPE_EARLY_SKIP
6766 | OPTI_TYPE_NOT_ITERATED
6767 | OPTI_TYPE_APPENDED_SALT
6768 | OPTI_TYPE_RAW_HASH;
6769 dgst_pos0 = 0;
6770 dgst_pos1 = 3;
6771 dgst_pos2 = 2;
6772 dgst_pos3 = 1;
6773 break;
6774
6775 case 12: hash_type = HASH_TYPE_MD5;
6776 salt_type = SALT_TYPE_INTERN;
6777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6778 opts_type = OPTS_TYPE_PT_GENERATE_LE
6779 | OPTS_TYPE_ST_ADD80
6780 | OPTS_TYPE_ST_ADDBITS14;
6781 kern_type = KERN_TYPE_MD5_PWSLT;
6782 dgst_size = DGST_SIZE_4_4;
6783 parse_func = postgresql_parse_hash;
6784 sort_by_digest = sort_by_digest_4_4;
6785 opti_type = OPTI_TYPE_ZERO_BYTE
6786 | OPTI_TYPE_PRECOMPUTE_INIT
6787 | OPTI_TYPE_PRECOMPUTE_MERKLE
6788 | OPTI_TYPE_MEET_IN_MIDDLE
6789 | OPTI_TYPE_EARLY_SKIP
6790 | OPTI_TYPE_NOT_ITERATED
6791 | OPTI_TYPE_APPENDED_SALT
6792 | OPTI_TYPE_RAW_HASH;
6793 dgst_pos0 = 0;
6794 dgst_pos1 = 3;
6795 dgst_pos2 = 2;
6796 dgst_pos3 = 1;
6797 break;
6798
6799 case 20: hash_type = HASH_TYPE_MD5;
6800 salt_type = SALT_TYPE_INTERN;
6801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6802 opts_type = OPTS_TYPE_PT_GENERATE_LE
6803 | OPTS_TYPE_PT_ADD80
6804 | OPTS_TYPE_PT_ADDBITS14;
6805 kern_type = KERN_TYPE_MD5_SLTPW;
6806 dgst_size = DGST_SIZE_4_4;
6807 parse_func = md5s_parse_hash;
6808 sort_by_digest = sort_by_digest_4_4;
6809 opti_type = OPTI_TYPE_ZERO_BYTE
6810 | OPTI_TYPE_PRECOMPUTE_INIT
6811 | OPTI_TYPE_PRECOMPUTE_MERKLE
6812 | OPTI_TYPE_EARLY_SKIP
6813 | OPTI_TYPE_NOT_ITERATED
6814 | OPTI_TYPE_PREPENDED_SALT
6815 | OPTI_TYPE_RAW_HASH;
6816 dgst_pos0 = 0;
6817 dgst_pos1 = 3;
6818 dgst_pos2 = 2;
6819 dgst_pos3 = 1;
6820 break;
6821
6822 case 21: hash_type = HASH_TYPE_MD5;
6823 salt_type = SALT_TYPE_INTERN;
6824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6825 opts_type = OPTS_TYPE_PT_GENERATE_LE
6826 | OPTS_TYPE_PT_ADD80
6827 | OPTS_TYPE_PT_ADDBITS14;
6828 kern_type = KERN_TYPE_MD5_SLTPW;
6829 dgst_size = DGST_SIZE_4_4;
6830 parse_func = osc_parse_hash;
6831 sort_by_digest = sort_by_digest_4_4;
6832 opti_type = OPTI_TYPE_ZERO_BYTE
6833 | OPTI_TYPE_PRECOMPUTE_INIT
6834 | OPTI_TYPE_PRECOMPUTE_MERKLE
6835 | OPTI_TYPE_EARLY_SKIP
6836 | OPTI_TYPE_NOT_ITERATED
6837 | OPTI_TYPE_PREPENDED_SALT
6838 | OPTI_TYPE_RAW_HASH;
6839 dgst_pos0 = 0;
6840 dgst_pos1 = 3;
6841 dgst_pos2 = 2;
6842 dgst_pos3 = 1;
6843 break;
6844
6845 case 22: hash_type = HASH_TYPE_MD5;
6846 salt_type = SALT_TYPE_EMBEDDED;
6847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6848 opts_type = OPTS_TYPE_PT_GENERATE_LE
6849 | OPTS_TYPE_PT_ADD80
6850 | OPTS_TYPE_PT_ADDBITS14;
6851 kern_type = KERN_TYPE_MD5_SLTPW;
6852 dgst_size = DGST_SIZE_4_4;
6853 parse_func = netscreen_parse_hash;
6854 sort_by_digest = sort_by_digest_4_4;
6855 opti_type = OPTI_TYPE_ZERO_BYTE
6856 | OPTI_TYPE_PRECOMPUTE_INIT
6857 | OPTI_TYPE_PRECOMPUTE_MERKLE
6858 | OPTI_TYPE_EARLY_SKIP
6859 | OPTI_TYPE_NOT_ITERATED
6860 | OPTI_TYPE_PREPENDED_SALT
6861 | OPTI_TYPE_RAW_HASH;
6862 dgst_pos0 = 0;
6863 dgst_pos1 = 3;
6864 dgst_pos2 = 2;
6865 dgst_pos3 = 1;
6866 break;
6867
6868 case 23: hash_type = HASH_TYPE_MD5;
6869 salt_type = SALT_TYPE_EMBEDDED;
6870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6871 opts_type = OPTS_TYPE_PT_GENERATE_LE
6872 | OPTS_TYPE_PT_ADD80
6873 | OPTS_TYPE_PT_ADDBITS14;
6874 kern_type = KERN_TYPE_MD5_SLTPW;
6875 dgst_size = DGST_SIZE_4_4;
6876 parse_func = skype_parse_hash;
6877 sort_by_digest = sort_by_digest_4_4;
6878 opti_type = OPTI_TYPE_ZERO_BYTE
6879 | OPTI_TYPE_PRECOMPUTE_INIT
6880 | OPTI_TYPE_PRECOMPUTE_MERKLE
6881 | OPTI_TYPE_EARLY_SKIP
6882 | OPTI_TYPE_NOT_ITERATED
6883 | OPTI_TYPE_PREPENDED_SALT
6884 | OPTI_TYPE_RAW_HASH;
6885 dgst_pos0 = 0;
6886 dgst_pos1 = 3;
6887 dgst_pos2 = 2;
6888 dgst_pos3 = 1;
6889 break;
6890
6891 case 30: hash_type = HASH_TYPE_MD5;
6892 salt_type = SALT_TYPE_INTERN;
6893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6894 opts_type = OPTS_TYPE_PT_GENERATE_LE
6895 | OPTS_TYPE_PT_UNICODE
6896 | OPTS_TYPE_ST_ADD80
6897 | OPTS_TYPE_ST_ADDBITS14;
6898 kern_type = KERN_TYPE_MD5_PWUSLT;
6899 dgst_size = DGST_SIZE_4_4;
6900 parse_func = md5s_parse_hash;
6901 sort_by_digest = sort_by_digest_4_4;
6902 opti_type = OPTI_TYPE_ZERO_BYTE
6903 | OPTI_TYPE_PRECOMPUTE_INIT
6904 | OPTI_TYPE_PRECOMPUTE_MERKLE
6905 | OPTI_TYPE_MEET_IN_MIDDLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_APPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 0;
6911 dgst_pos1 = 3;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 40: hash_type = HASH_TYPE_MD5;
6917 salt_type = SALT_TYPE_INTERN;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_LE
6920 | OPTS_TYPE_PT_ADD80
6921 | OPTS_TYPE_PT_ADDBITS14
6922 | OPTS_TYPE_PT_UNICODE;
6923 kern_type = KERN_TYPE_MD5_SLTPWU;
6924 dgst_size = DGST_SIZE_4_4;
6925 parse_func = md5s_parse_hash;
6926 sort_by_digest = sort_by_digest_4_4;
6927 opti_type = OPTI_TYPE_ZERO_BYTE
6928 | OPTI_TYPE_PRECOMPUTE_INIT
6929 | OPTI_TYPE_PRECOMPUTE_MERKLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_PREPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 0;
6935 dgst_pos1 = 3;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 50: hash_type = HASH_TYPE_MD5;
6941 salt_type = SALT_TYPE_INTERN;
6942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6943 opts_type = OPTS_TYPE_PT_GENERATE_LE
6944 | OPTS_TYPE_ST_ADD80
6945 | OPTS_TYPE_ST_ADDBITS14;
6946 kern_type = KERN_TYPE_HMACMD5_PW;
6947 dgst_size = DGST_SIZE_4_4;
6948 parse_func = hmacmd5_parse_hash;
6949 sort_by_digest = sort_by_digest_4_4;
6950 opti_type = OPTI_TYPE_ZERO_BYTE
6951 | OPTI_TYPE_NOT_ITERATED;
6952 dgst_pos0 = 0;
6953 dgst_pos1 = 3;
6954 dgst_pos2 = 2;
6955 dgst_pos3 = 1;
6956 break;
6957
6958 case 60: hash_type = HASH_TYPE_MD5;
6959 salt_type = SALT_TYPE_INTERN;
6960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6961 opts_type = OPTS_TYPE_PT_GENERATE_LE
6962 | OPTS_TYPE_PT_ADD80
6963 | OPTS_TYPE_PT_ADDBITS14;
6964 kern_type = KERN_TYPE_HMACMD5_SLT;
6965 dgst_size = DGST_SIZE_4_4;
6966 parse_func = hmacmd5_parse_hash;
6967 sort_by_digest = sort_by_digest_4_4;
6968 opti_type = OPTI_TYPE_ZERO_BYTE
6969 | OPTI_TYPE_NOT_ITERATED;
6970 dgst_pos0 = 0;
6971 dgst_pos1 = 3;
6972 dgst_pos2 = 2;
6973 dgst_pos3 = 1;
6974 break;
6975
6976 case 100: hash_type = HASH_TYPE_SHA1;
6977 salt_type = SALT_TYPE_NONE;
6978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6979 opts_type = OPTS_TYPE_PT_GENERATE_BE
6980 | OPTS_TYPE_PT_ADD80
6981 | OPTS_TYPE_PT_ADDBITS15;
6982 kern_type = KERN_TYPE_SHA1;
6983 dgst_size = DGST_SIZE_4_5;
6984 parse_func = sha1_parse_hash;
6985 sort_by_digest = sort_by_digest_4_5;
6986 opti_type = OPTI_TYPE_ZERO_BYTE
6987 | OPTI_TYPE_PRECOMPUTE_INIT
6988 | OPTI_TYPE_PRECOMPUTE_MERKLE
6989 | OPTI_TYPE_EARLY_SKIP
6990 | OPTI_TYPE_NOT_ITERATED
6991 | OPTI_TYPE_NOT_SALTED
6992 | OPTI_TYPE_RAW_HASH;
6993 dgst_pos0 = 3;
6994 dgst_pos1 = 4;
6995 dgst_pos2 = 2;
6996 dgst_pos3 = 1;
6997 break;
6998
6999 case 101: hash_type = HASH_TYPE_SHA1;
7000 salt_type = SALT_TYPE_NONE;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_BE
7003 | OPTS_TYPE_PT_ADD80
7004 | OPTS_TYPE_PT_ADDBITS15;
7005 kern_type = KERN_TYPE_SHA1;
7006 dgst_size = DGST_SIZE_4_5;
7007 parse_func = sha1b64_parse_hash;
7008 sort_by_digest = sort_by_digest_4_5;
7009 opti_type = OPTI_TYPE_ZERO_BYTE
7010 | OPTI_TYPE_PRECOMPUTE_INIT
7011 | OPTI_TYPE_PRECOMPUTE_MERKLE
7012 | OPTI_TYPE_EARLY_SKIP
7013 | OPTI_TYPE_NOT_ITERATED
7014 | OPTI_TYPE_NOT_SALTED
7015 | OPTI_TYPE_RAW_HASH;
7016 dgst_pos0 = 3;
7017 dgst_pos1 = 4;
7018 dgst_pos2 = 2;
7019 dgst_pos3 = 1;
7020 break;
7021
7022 case 110: hash_type = HASH_TYPE_SHA1;
7023 salt_type = SALT_TYPE_INTERN;
7024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7025 opts_type = OPTS_TYPE_PT_GENERATE_BE
7026 | OPTS_TYPE_ST_ADD80
7027 | OPTS_TYPE_ST_ADDBITS15;
7028 kern_type = KERN_TYPE_SHA1_PWSLT;
7029 dgst_size = DGST_SIZE_4_5;
7030 parse_func = sha1s_parse_hash;
7031 sort_by_digest = sort_by_digest_4_5;
7032 opti_type = OPTI_TYPE_ZERO_BYTE
7033 | OPTI_TYPE_PRECOMPUTE_INIT
7034 | OPTI_TYPE_PRECOMPUTE_MERKLE
7035 | OPTI_TYPE_EARLY_SKIP
7036 | OPTI_TYPE_NOT_ITERATED
7037 | OPTI_TYPE_APPENDED_SALT
7038 | OPTI_TYPE_RAW_HASH;
7039 dgst_pos0 = 3;
7040 dgst_pos1 = 4;
7041 dgst_pos2 = 2;
7042 dgst_pos3 = 1;
7043 break;
7044
7045 case 111: hash_type = HASH_TYPE_SHA1;
7046 salt_type = SALT_TYPE_EMBEDDED;
7047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7048 opts_type = OPTS_TYPE_PT_GENERATE_BE
7049 | OPTS_TYPE_ST_ADD80
7050 | OPTS_TYPE_ST_ADDBITS15;
7051 kern_type = KERN_TYPE_SHA1_PWSLT;
7052 dgst_size = DGST_SIZE_4_5;
7053 parse_func = sha1b64s_parse_hash;
7054 sort_by_digest = sort_by_digest_4_5;
7055 opti_type = OPTI_TYPE_ZERO_BYTE
7056 | OPTI_TYPE_PRECOMPUTE_INIT
7057 | OPTI_TYPE_PRECOMPUTE_MERKLE
7058 | OPTI_TYPE_EARLY_SKIP
7059 | OPTI_TYPE_NOT_ITERATED
7060 | OPTI_TYPE_APPENDED_SALT
7061 | OPTI_TYPE_RAW_HASH;
7062 dgst_pos0 = 3;
7063 dgst_pos1 = 4;
7064 dgst_pos2 = 2;
7065 dgst_pos3 = 1;
7066 break;
7067
7068 case 112: hash_type = HASH_TYPE_SHA1;
7069 salt_type = SALT_TYPE_INTERN;
7070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7071 opts_type = OPTS_TYPE_PT_GENERATE_BE
7072 | OPTS_TYPE_ST_ADD80
7073 | OPTS_TYPE_ST_ADDBITS15
7074 | OPTS_TYPE_ST_HEX;
7075 kern_type = KERN_TYPE_SHA1_PWSLT;
7076 dgst_size = DGST_SIZE_4_5;
7077 parse_func = oracles_parse_hash;
7078 sort_by_digest = sort_by_digest_4_5;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_APPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 3;
7087 dgst_pos1 = 4;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 120: hash_type = HASH_TYPE_SHA1;
7093 salt_type = SALT_TYPE_INTERN;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_BE
7096 | OPTS_TYPE_PT_ADD80
7097 | OPTS_TYPE_PT_ADDBITS15;
7098 kern_type = KERN_TYPE_SHA1_SLTPW;
7099 dgst_size = DGST_SIZE_4_5;
7100 parse_func = sha1s_parse_hash;
7101 sort_by_digest = sort_by_digest_4_5;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_PRECOMPUTE_INIT
7104 | OPTI_TYPE_PRECOMPUTE_MERKLE
7105 | OPTI_TYPE_EARLY_SKIP
7106 | OPTI_TYPE_NOT_ITERATED
7107 | OPTI_TYPE_PREPENDED_SALT
7108 | OPTI_TYPE_RAW_HASH;
7109 dgst_pos0 = 3;
7110 dgst_pos1 = 4;
7111 dgst_pos2 = 2;
7112 dgst_pos3 = 1;
7113 break;
7114
7115 case 121: hash_type = HASH_TYPE_SHA1;
7116 salt_type = SALT_TYPE_INTERN;
7117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7118 opts_type = OPTS_TYPE_PT_GENERATE_BE
7119 | OPTS_TYPE_PT_ADD80
7120 | OPTS_TYPE_PT_ADDBITS15
7121 | OPTS_TYPE_ST_LOWER;
7122 kern_type = KERN_TYPE_SHA1_SLTPW;
7123 dgst_size = DGST_SIZE_4_5;
7124 parse_func = smf_parse_hash;
7125 sort_by_digest = sort_by_digest_4_5;
7126 opti_type = OPTI_TYPE_ZERO_BYTE
7127 | OPTI_TYPE_PRECOMPUTE_INIT
7128 | OPTI_TYPE_PRECOMPUTE_MERKLE
7129 | OPTI_TYPE_EARLY_SKIP
7130 | OPTI_TYPE_NOT_ITERATED
7131 | OPTI_TYPE_PREPENDED_SALT
7132 | OPTI_TYPE_RAW_HASH;
7133 dgst_pos0 = 3;
7134 dgst_pos1 = 4;
7135 dgst_pos2 = 2;
7136 dgst_pos3 = 1;
7137 break;
7138
7139 case 122: hash_type = HASH_TYPE_SHA1;
7140 salt_type = SALT_TYPE_EMBEDDED;
7141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7142 opts_type = OPTS_TYPE_PT_GENERATE_BE
7143 | OPTS_TYPE_PT_ADD80
7144 | OPTS_TYPE_PT_ADDBITS15
7145 | OPTS_TYPE_ST_HEX;
7146 kern_type = KERN_TYPE_SHA1_SLTPW;
7147 dgst_size = DGST_SIZE_4_5;
7148 parse_func = osx1_parse_hash;
7149 sort_by_digest = sort_by_digest_4_5;
7150 opti_type = OPTI_TYPE_ZERO_BYTE
7151 | OPTI_TYPE_PRECOMPUTE_INIT
7152 | OPTI_TYPE_PRECOMPUTE_MERKLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED
7155 | OPTI_TYPE_PREPENDED_SALT
7156 | OPTI_TYPE_RAW_HASH;
7157 dgst_pos0 = 3;
7158 dgst_pos1 = 4;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 124: hash_type = HASH_TYPE_SHA1;
7164 salt_type = SALT_TYPE_EMBEDDED;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_BE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS15;
7169 kern_type = KERN_TYPE_SHA1_SLTPW;
7170 dgst_size = DGST_SIZE_4_5;
7171 parse_func = djangosha1_parse_hash;
7172 sort_by_digest = sort_by_digest_4_5;
7173 opti_type = OPTI_TYPE_ZERO_BYTE
7174 | OPTI_TYPE_PRECOMPUTE_INIT
7175 | OPTI_TYPE_PRECOMPUTE_MERKLE
7176 | OPTI_TYPE_EARLY_SKIP
7177 | OPTI_TYPE_NOT_ITERATED
7178 | OPTI_TYPE_PREPENDED_SALT
7179 | OPTI_TYPE_RAW_HASH;
7180 dgst_pos0 = 3;
7181 dgst_pos1 = 4;
7182 dgst_pos2 = 2;
7183 dgst_pos3 = 1;
7184 break;
7185
7186 case 130: hash_type = HASH_TYPE_SHA1;
7187 salt_type = SALT_TYPE_INTERN;
7188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7189 opts_type = OPTS_TYPE_PT_GENERATE_BE
7190 | OPTS_TYPE_PT_UNICODE
7191 | OPTS_TYPE_ST_ADD80
7192 | OPTS_TYPE_ST_ADDBITS15;
7193 kern_type = KERN_TYPE_SHA1_PWUSLT;
7194 dgst_size = DGST_SIZE_4_5;
7195 parse_func = sha1s_parse_hash;
7196 sort_by_digest = sort_by_digest_4_5;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_PRECOMPUTE_INIT
7199 | OPTI_TYPE_PRECOMPUTE_MERKLE
7200 | OPTI_TYPE_EARLY_SKIP
7201 | OPTI_TYPE_NOT_ITERATED
7202 | OPTI_TYPE_APPENDED_SALT
7203 | OPTI_TYPE_RAW_HASH;
7204 dgst_pos0 = 3;
7205 dgst_pos1 = 4;
7206 dgst_pos2 = 2;
7207 dgst_pos3 = 1;
7208 break;
7209
7210 case 131: hash_type = HASH_TYPE_SHA1;
7211 salt_type = SALT_TYPE_EMBEDDED;
7212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7213 opts_type = OPTS_TYPE_PT_GENERATE_BE
7214 | OPTS_TYPE_PT_UNICODE
7215 | OPTS_TYPE_PT_UPPER
7216 | OPTS_TYPE_ST_ADD80
7217 | OPTS_TYPE_ST_ADDBITS15
7218 | OPTS_TYPE_ST_HEX;
7219 kern_type = KERN_TYPE_SHA1_PWUSLT;
7220 dgst_size = DGST_SIZE_4_5;
7221 parse_func = mssql2000_parse_hash;
7222 sort_by_digest = sort_by_digest_4_5;
7223 opti_type = OPTI_TYPE_ZERO_BYTE
7224 | OPTI_TYPE_PRECOMPUTE_INIT
7225 | OPTI_TYPE_PRECOMPUTE_MERKLE
7226 | OPTI_TYPE_EARLY_SKIP
7227 | OPTI_TYPE_NOT_ITERATED
7228 | OPTI_TYPE_APPENDED_SALT
7229 | OPTI_TYPE_RAW_HASH;
7230 dgst_pos0 = 3;
7231 dgst_pos1 = 4;
7232 dgst_pos2 = 2;
7233 dgst_pos3 = 1;
7234 break;
7235
7236 case 132: hash_type = HASH_TYPE_SHA1;
7237 salt_type = SALT_TYPE_EMBEDDED;
7238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7239 opts_type = OPTS_TYPE_PT_GENERATE_BE
7240 | OPTS_TYPE_PT_UNICODE
7241 | OPTS_TYPE_ST_ADD80
7242 | OPTS_TYPE_ST_ADDBITS15
7243 | OPTS_TYPE_ST_HEX;
7244 kern_type = KERN_TYPE_SHA1_PWUSLT;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = mssql2005_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_APPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 133: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_EMBEDDED;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_UNICODE
7266 | OPTS_TYPE_ST_ADD80
7267 | OPTS_TYPE_ST_ADDBITS15;
7268 kern_type = KERN_TYPE_SHA1_PWUSLT;
7269 dgst_size = DGST_SIZE_4_5;
7270 parse_func = peoplesoft_parse_hash;
7271 sort_by_digest = sort_by_digest_4_5;
7272 opti_type = OPTI_TYPE_ZERO_BYTE
7273 | OPTI_TYPE_PRECOMPUTE_INIT
7274 | OPTI_TYPE_PRECOMPUTE_MERKLE
7275 | OPTI_TYPE_EARLY_SKIP
7276 | OPTI_TYPE_NOT_ITERATED
7277 | OPTI_TYPE_APPENDED_SALT
7278 | OPTI_TYPE_RAW_HASH;
7279 dgst_pos0 = 3;
7280 dgst_pos1 = 4;
7281 dgst_pos2 = 2;
7282 dgst_pos3 = 1;
7283 break;
7284
7285 case 140: hash_type = HASH_TYPE_SHA1;
7286 salt_type = SALT_TYPE_INTERN;
7287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7288 opts_type = OPTS_TYPE_PT_GENERATE_BE
7289 | OPTS_TYPE_PT_ADD80
7290 | OPTS_TYPE_PT_ADDBITS15
7291 | OPTS_TYPE_PT_UNICODE;
7292 kern_type = KERN_TYPE_SHA1_SLTPWU;
7293 dgst_size = DGST_SIZE_4_5;
7294 parse_func = sha1s_parse_hash;
7295 sort_by_digest = sort_by_digest_4_5;
7296 opti_type = OPTI_TYPE_ZERO_BYTE
7297 | OPTI_TYPE_PRECOMPUTE_INIT
7298 | OPTI_TYPE_PRECOMPUTE_MERKLE
7299 | OPTI_TYPE_EARLY_SKIP
7300 | OPTI_TYPE_NOT_ITERATED
7301 | OPTI_TYPE_PREPENDED_SALT
7302 | OPTI_TYPE_RAW_HASH;
7303 dgst_pos0 = 3;
7304 dgst_pos1 = 4;
7305 dgst_pos2 = 2;
7306 dgst_pos3 = 1;
7307 break;
7308
7309 case 141: hash_type = HASH_TYPE_SHA1;
7310 salt_type = SALT_TYPE_EMBEDDED;
7311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7312 opts_type = OPTS_TYPE_PT_GENERATE_BE
7313 | OPTS_TYPE_PT_ADD80
7314 | OPTS_TYPE_PT_ADDBITS15
7315 | OPTS_TYPE_PT_UNICODE
7316 | OPTS_TYPE_ST_BASE64;
7317 kern_type = KERN_TYPE_SHA1_SLTPWU;
7318 dgst_size = DGST_SIZE_4_5;
7319 parse_func = episerver_parse_hash;
7320 sort_by_digest = sort_by_digest_4_5;
7321 opti_type = OPTI_TYPE_ZERO_BYTE
7322 | OPTI_TYPE_PRECOMPUTE_INIT
7323 | OPTI_TYPE_PRECOMPUTE_MERKLE
7324 | OPTI_TYPE_EARLY_SKIP
7325 | OPTI_TYPE_NOT_ITERATED
7326 | OPTI_TYPE_PREPENDED_SALT
7327 | OPTI_TYPE_RAW_HASH;
7328 dgst_pos0 = 3;
7329 dgst_pos1 = 4;
7330 dgst_pos2 = 2;
7331 dgst_pos3 = 1;
7332 break;
7333
7334 case 150: hash_type = HASH_TYPE_SHA1;
7335 salt_type = SALT_TYPE_INTERN;
7336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7337 opts_type = OPTS_TYPE_PT_GENERATE_BE
7338 | OPTS_TYPE_ST_ADD80
7339 | OPTS_TYPE_ST_ADDBITS15;
7340 kern_type = KERN_TYPE_HMACSHA1_PW;
7341 dgst_size = DGST_SIZE_4_5;
7342 parse_func = hmacsha1_parse_hash;
7343 sort_by_digest = sort_by_digest_4_5;
7344 opti_type = OPTI_TYPE_ZERO_BYTE
7345 | OPTI_TYPE_NOT_ITERATED;
7346 dgst_pos0 = 3;
7347 dgst_pos1 = 4;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 160: hash_type = HASH_TYPE_SHA1;
7353 salt_type = SALT_TYPE_INTERN;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_BE
7356 | OPTS_TYPE_PT_ADD80
7357 | OPTS_TYPE_PT_ADDBITS15;
7358 kern_type = KERN_TYPE_HMACSHA1_SLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = hmacsha1_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_NOT_ITERATED;
7364 dgst_pos0 = 3;
7365 dgst_pos1 = 4;
7366 dgst_pos2 = 2;
7367 dgst_pos3 = 1;
7368 break;
7369
7370 case 190: hash_type = HASH_TYPE_SHA1;
7371 salt_type = SALT_TYPE_NONE;
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 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7377 dgst_size = DGST_SIZE_4_5;
7378 parse_func = sha1linkedin_parse_hash;
7379 sort_by_digest = sort_by_digest_4_5;
7380 opti_type = OPTI_TYPE_ZERO_BYTE
7381 | OPTI_TYPE_PRECOMPUTE_INIT
7382 | OPTI_TYPE_EARLY_SKIP
7383 | OPTI_TYPE_NOT_ITERATED
7384 | OPTI_TYPE_NOT_SALTED;
7385 dgst_pos0 = 0;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 3;
7388 dgst_pos3 = 2;
7389 break;
7390
7391 case 200: hash_type = HASH_TYPE_MYSQL;
7392 salt_type = SALT_TYPE_NONE;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = 0;
7395 kern_type = KERN_TYPE_MYSQL;
7396 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7397 parse_func = mysql323_parse_hash;
7398 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7399 opti_type = OPTI_TYPE_ZERO_BYTE;
7400 dgst_pos0 = 0;
7401 dgst_pos1 = 1;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 3;
7404 break;
7405
7406 case 300: hash_type = HASH_TYPE_SHA1;
7407 salt_type = SALT_TYPE_NONE;
7408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_BE
7410 | OPTS_TYPE_PT_ADD80
7411 | OPTS_TYPE_PT_ADDBITS15;
7412 kern_type = KERN_TYPE_MYSQL41;
7413 dgst_size = DGST_SIZE_4_5;
7414 parse_func = sha1_parse_hash;
7415 sort_by_digest = sort_by_digest_4_5;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_EARLY_SKIP
7420 | OPTI_TYPE_NOT_ITERATED
7421 | OPTI_TYPE_NOT_SALTED;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 400: hash_type = HASH_TYPE_MD5;
7429 salt_type = SALT_TYPE_EMBEDDED;
7430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7432 kern_type = KERN_TYPE_PHPASS;
7433 dgst_size = DGST_SIZE_4_4;
7434 parse_func = phpass_parse_hash;
7435 sort_by_digest = sort_by_digest_4_4;
7436 opti_type = OPTI_TYPE_ZERO_BYTE;
7437 dgst_pos0 = 0;
7438 dgst_pos1 = 1;
7439 dgst_pos2 = 2;
7440 dgst_pos3 = 3;
7441 break;
7442
7443 case 500: hash_type = HASH_TYPE_MD5;
7444 salt_type = SALT_TYPE_EMBEDDED;
7445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7447 kern_type = KERN_TYPE_MD5CRYPT;
7448 dgst_size = DGST_SIZE_4_4;
7449 parse_func = md5crypt_parse_hash;
7450 sort_by_digest = sort_by_digest_4_4;
7451 opti_type = OPTI_TYPE_ZERO_BYTE;
7452 dgst_pos0 = 0;
7453 dgst_pos1 = 1;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 3;
7456 break;
7457
7458 case 501: hash_type = HASH_TYPE_MD5;
7459 salt_type = SALT_TYPE_EMBEDDED;
7460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_LE
7462 | OPTS_TYPE_HASH_COPY;
7463 kern_type = KERN_TYPE_MD5CRYPT;
7464 dgst_size = DGST_SIZE_4_4;
7465 parse_func = juniper_parse_hash;
7466 sort_by_digest = sort_by_digest_4_4;
7467 opti_type = OPTI_TYPE_ZERO_BYTE;
7468 dgst_pos0 = 0;
7469 dgst_pos1 = 1;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 3;
7472 break;
7473
7474 case 900: hash_type = HASH_TYPE_MD4;
7475 salt_type = SALT_TYPE_NONE;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_LE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS14;
7480 kern_type = KERN_TYPE_MD4;
7481 dgst_size = DGST_SIZE_4_4;
7482 parse_func = md4_parse_hash;
7483 sort_by_digest = sort_by_digest_4_4;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_MEET_IN_MIDDLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_NOT_SALTED
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 0;
7493 dgst_pos1 = 3;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 1000: hash_type = HASH_TYPE_MD4;
7499 salt_type = SALT_TYPE_NONE;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_LE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS14
7504 | OPTS_TYPE_PT_UNICODE;
7505 kern_type = KERN_TYPE_MD4_PWU;
7506 dgst_size = DGST_SIZE_4_4;
7507 parse_func = md4_parse_hash;
7508 sort_by_digest = sort_by_digest_4_4;
7509 opti_type = OPTI_TYPE_ZERO_BYTE
7510 | OPTI_TYPE_PRECOMPUTE_INIT
7511 | OPTI_TYPE_PRECOMPUTE_MERKLE
7512 | OPTI_TYPE_MEET_IN_MIDDLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_NOT_SALTED
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 0;
7518 dgst_pos1 = 3;
7519 dgst_pos2 = 2;
7520 dgst_pos3 = 1;
7521 break;
7522
7523 case 1100: hash_type = HASH_TYPE_MD4;
7524 salt_type = SALT_TYPE_INTERN;
7525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7526 opts_type = OPTS_TYPE_PT_GENERATE_LE
7527 | OPTS_TYPE_PT_ADD80
7528 | OPTS_TYPE_PT_ADDBITS14
7529 | OPTS_TYPE_PT_UNICODE
7530 | OPTS_TYPE_ST_ADD80
7531 | OPTS_TYPE_ST_UNICODE
7532 | OPTS_TYPE_ST_LOWER;
7533 kern_type = KERN_TYPE_MD44_PWUSLT;
7534 dgst_size = DGST_SIZE_4_4;
7535 parse_func = dcc_parse_hash;
7536 sort_by_digest = sort_by_digest_4_4;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_PRECOMPUTE_INIT
7539 | OPTI_TYPE_PRECOMPUTE_MERKLE
7540 | OPTI_TYPE_EARLY_SKIP
7541 | OPTI_TYPE_NOT_ITERATED;
7542 dgst_pos0 = 0;
7543 dgst_pos1 = 3;
7544 dgst_pos2 = 2;
7545 dgst_pos3 = 1;
7546 break;
7547
7548 case 1400: hash_type = HASH_TYPE_SHA256;
7549 salt_type = SALT_TYPE_NONE;
7550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7551 opts_type = OPTS_TYPE_PT_GENERATE_BE
7552 | OPTS_TYPE_PT_ADD80
7553 | OPTS_TYPE_PT_ADDBITS15;
7554 kern_type = KERN_TYPE_SHA256;
7555 dgst_size = DGST_SIZE_4_8;
7556 parse_func = sha256_parse_hash;
7557 sort_by_digest = sort_by_digest_4_8;
7558 opti_type = OPTI_TYPE_ZERO_BYTE
7559 | OPTI_TYPE_PRECOMPUTE_INIT
7560 | OPTI_TYPE_PRECOMPUTE_MERKLE
7561 | OPTI_TYPE_EARLY_SKIP
7562 | OPTI_TYPE_NOT_ITERATED
7563 | OPTI_TYPE_NOT_SALTED
7564 | OPTI_TYPE_RAW_HASH;
7565 dgst_pos0 = 3;
7566 dgst_pos1 = 7;
7567 dgst_pos2 = 2;
7568 dgst_pos3 = 6;
7569 break;
7570
7571 case 1410: hash_type = HASH_TYPE_SHA256;
7572 salt_type = SALT_TYPE_INTERN;
7573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7574 opts_type = OPTS_TYPE_PT_GENERATE_BE
7575 | OPTS_TYPE_ST_ADD80
7576 | OPTS_TYPE_ST_ADDBITS15;
7577 kern_type = KERN_TYPE_SHA256_PWSLT;
7578 dgst_size = DGST_SIZE_4_8;
7579 parse_func = sha256s_parse_hash;
7580 sort_by_digest = sort_by_digest_4_8;
7581 opti_type = OPTI_TYPE_ZERO_BYTE
7582 | OPTI_TYPE_PRECOMPUTE_INIT
7583 | OPTI_TYPE_PRECOMPUTE_MERKLE
7584 | OPTI_TYPE_EARLY_SKIP
7585 | OPTI_TYPE_NOT_ITERATED
7586 | OPTI_TYPE_APPENDED_SALT
7587 | OPTI_TYPE_RAW_HASH;
7588 dgst_pos0 = 3;
7589 dgst_pos1 = 7;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 6;
7592 break;
7593
7594 case 1420: hash_type = HASH_TYPE_SHA256;
7595 salt_type = SALT_TYPE_INTERN;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_BE
7598 | OPTS_TYPE_PT_ADD80
7599 | OPTS_TYPE_PT_ADDBITS15;
7600 kern_type = KERN_TYPE_SHA256_SLTPW;
7601 dgst_size = DGST_SIZE_4_8;
7602 parse_func = sha256s_parse_hash;
7603 sort_by_digest = sort_by_digest_4_8;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_PRECOMPUTE_INIT
7606 | OPTI_TYPE_PRECOMPUTE_MERKLE
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_PREPENDED_SALT
7610 | OPTI_TYPE_RAW_HASH;
7611 dgst_pos0 = 3;
7612 dgst_pos1 = 7;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 6;
7615 break;
7616
7617 case 1421: hash_type = HASH_TYPE_SHA256;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_BE
7621 | OPTS_TYPE_PT_ADD80
7622 | OPTS_TYPE_PT_ADDBITS15;
7623 kern_type = KERN_TYPE_SHA256_SLTPW;
7624 dgst_size = DGST_SIZE_4_8;
7625 parse_func = hmailserver_parse_hash;
7626 sort_by_digest = sort_by_digest_4_8;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_PREPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 3;
7635 dgst_pos1 = 7;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 6;
7638 break;
7639
7640 case 1430: hash_type = HASH_TYPE_SHA256;
7641 salt_type = SALT_TYPE_INTERN;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_BE
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA256_PWUSLT;
7648 dgst_size = DGST_SIZE_4_8;
7649 parse_func = sha256s_parse_hash;
7650 sort_by_digest = sort_by_digest_4_8;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_APPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 3;
7659 dgst_pos1 = 7;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 6;
7662 break;
7663
7664 case 1440: hash_type = HASH_TYPE_SHA256;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_BE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS15
7670 | OPTS_TYPE_PT_UNICODE;
7671 kern_type = KERN_TYPE_SHA256_SLTPWU;
7672 dgst_size = DGST_SIZE_4_8;
7673 parse_func = sha256s_parse_hash;
7674 sort_by_digest = sort_by_digest_4_8;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 7;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 6;
7686 break;
7687
7688 case 1441: hash_type = HASH_TYPE_SHA256;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15
7694 | OPTS_TYPE_PT_UNICODE
7695 | OPTS_TYPE_ST_BASE64;
7696 kern_type = KERN_TYPE_SHA256_SLTPWU;
7697 dgst_size = DGST_SIZE_4_8;
7698 parse_func = episerver4_parse_hash;
7699 sort_by_digest = sort_by_digest_4_8;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_PREPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 7;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 6;
7711 break;
7712
7713 case 1450: hash_type = HASH_TYPE_SHA256;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_ST_ADD80;
7718 kern_type = KERN_TYPE_HMACSHA256_PW;
7719 dgst_size = DGST_SIZE_4_8;
7720 parse_func = hmacsha256_parse_hash;
7721 sort_by_digest = sort_by_digest_4_8;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_NOT_ITERATED;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 7;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 6;
7728 break;
7729
7730 case 1460: hash_type = HASH_TYPE_SHA256;
7731 salt_type = SALT_TYPE_INTERN;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_HMACSHA256_SLT;
7737 dgst_size = DGST_SIZE_4_8;
7738 parse_func = hmacsha256_parse_hash;
7739 sort_by_digest = sort_by_digest_4_8;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_NOT_ITERATED;
7742 dgst_pos0 = 3;
7743 dgst_pos1 = 7;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 6;
7746 break;
7747
7748 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7749 salt_type = SALT_TYPE_EMBEDDED;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_LE
7752 | OPTS_TYPE_PT_BITSLICE;
7753 kern_type = KERN_TYPE_DESCRYPT;
7754 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7755 parse_func = descrypt_parse_hash;
7756 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7759 dgst_pos0 = 0;
7760 dgst_pos1 = 1;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 3;
7763 break;
7764
7765 case 1600: hash_type = HASH_TYPE_MD5;
7766 salt_type = SALT_TYPE_EMBEDDED;
7767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7769 kern_type = KERN_TYPE_APR1CRYPT;
7770 dgst_size = DGST_SIZE_4_4;
7771 parse_func = md5apr1_parse_hash;
7772 sort_by_digest = sort_by_digest_4_4;
7773 opti_type = OPTI_TYPE_ZERO_BYTE;
7774 dgst_pos0 = 0;
7775 dgst_pos1 = 1;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 3;
7778 break;
7779
7780 case 1700: hash_type = HASH_TYPE_SHA512;
7781 salt_type = SALT_TYPE_NONE;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_BE
7784 | OPTS_TYPE_PT_ADD80
7785 | OPTS_TYPE_PT_ADDBITS15;
7786 kern_type = KERN_TYPE_SHA512;
7787 dgst_size = DGST_SIZE_8_8;
7788 parse_func = sha512_parse_hash;
7789 sort_by_digest = sort_by_digest_8_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_NOT_SALTED
7796 | OPTI_TYPE_USES_BITS_64
7797 | OPTI_TYPE_RAW_HASH;
7798 dgst_pos0 = 14;
7799 dgst_pos1 = 15;
7800 dgst_pos2 = 6;
7801 dgst_pos3 = 7;
7802 break;
7803
7804 case 1710: hash_type = HASH_TYPE_SHA512;
7805 salt_type = SALT_TYPE_INTERN;
7806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_BE
7808 | OPTS_TYPE_ST_ADD80
7809 | OPTS_TYPE_ST_ADDBITS15;
7810 kern_type = KERN_TYPE_SHA512_PWSLT;
7811 dgst_size = DGST_SIZE_8_8;
7812 parse_func = sha512s_parse_hash;
7813 sort_by_digest = sort_by_digest_8_8;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_EARLY_SKIP
7818 | OPTI_TYPE_NOT_ITERATED
7819 | OPTI_TYPE_APPENDED_SALT
7820 | OPTI_TYPE_USES_BITS_64
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 14;
7823 dgst_pos1 = 15;
7824 dgst_pos2 = 6;
7825 dgst_pos3 = 7;
7826 break;
7827
7828 case 1711: hash_type = HASH_TYPE_SHA512;
7829 salt_type = SALT_TYPE_EMBEDDED;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_ST_ADD80
7833 | OPTS_TYPE_ST_ADDBITS15;
7834 kern_type = KERN_TYPE_SHA512_PWSLT;
7835 dgst_size = DGST_SIZE_8_8;
7836 parse_func = sha512b64s_parse_hash;
7837 sort_by_digest = sort_by_digest_8_8;
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_INIT
7840 | OPTI_TYPE_PRECOMPUTE_MERKLE
7841 | OPTI_TYPE_EARLY_SKIP
7842 | OPTI_TYPE_NOT_ITERATED
7843 | OPTI_TYPE_APPENDED_SALT
7844 | OPTI_TYPE_USES_BITS_64
7845 | OPTI_TYPE_RAW_HASH;
7846 dgst_pos0 = 14;
7847 dgst_pos1 = 15;
7848 dgst_pos2 = 6;
7849 dgst_pos3 = 7;
7850 break;
7851
7852 case 1720: hash_type = HASH_TYPE_SHA512;
7853 salt_type = SALT_TYPE_INTERN;
7854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_BE
7856 | OPTS_TYPE_PT_ADD80
7857 | OPTS_TYPE_PT_ADDBITS15;
7858 kern_type = KERN_TYPE_SHA512_SLTPW;
7859 dgst_size = DGST_SIZE_8_8;
7860 parse_func = sha512s_parse_hash;
7861 sort_by_digest = sort_by_digest_8_8;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_PREPENDED_SALT
7868 | OPTI_TYPE_USES_BITS_64
7869 | OPTI_TYPE_RAW_HASH;
7870 dgst_pos0 = 14;
7871 dgst_pos1 = 15;
7872 dgst_pos2 = 6;
7873 dgst_pos3 = 7;
7874 break;
7875
7876 case 1722: hash_type = HASH_TYPE_SHA512;
7877 salt_type = SALT_TYPE_EMBEDDED;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_PT_ADD80
7881 | OPTS_TYPE_PT_ADDBITS15
7882 | OPTS_TYPE_ST_HEX;
7883 kern_type = KERN_TYPE_SHA512_SLTPW;
7884 dgst_size = DGST_SIZE_8_8;
7885 parse_func = osx512_parse_hash;
7886 sort_by_digest = sort_by_digest_8_8;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_PRECOMPUTE_INIT
7889 | OPTI_TYPE_PRECOMPUTE_MERKLE
7890 | OPTI_TYPE_EARLY_SKIP
7891 | OPTI_TYPE_NOT_ITERATED
7892 | OPTI_TYPE_PREPENDED_SALT
7893 | OPTI_TYPE_USES_BITS_64
7894 | OPTI_TYPE_RAW_HASH;
7895 dgst_pos0 = 14;
7896 dgst_pos1 = 15;
7897 dgst_pos2 = 6;
7898 dgst_pos3 = 7;
7899 break;
7900
7901 case 1730: hash_type = HASH_TYPE_SHA512;
7902 salt_type = SALT_TYPE_INTERN;
7903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_BE
7905 | OPTS_TYPE_PT_UNICODE
7906 | OPTS_TYPE_ST_ADD80
7907 | OPTS_TYPE_ST_ADDBITS15;
7908 kern_type = KERN_TYPE_SHA512_PWSLTU;
7909 dgst_size = DGST_SIZE_8_8;
7910 parse_func = sha512s_parse_hash;
7911 sort_by_digest = sort_by_digest_8_8;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED
7917 | OPTI_TYPE_APPENDED_SALT
7918 | OPTI_TYPE_USES_BITS_64
7919 | OPTI_TYPE_RAW_HASH;
7920 dgst_pos0 = 14;
7921 dgst_pos1 = 15;
7922 dgst_pos2 = 6;
7923 dgst_pos3 = 7;
7924 break;
7925
7926 case 1731: hash_type = HASH_TYPE_SHA512;
7927 salt_type = SALT_TYPE_EMBEDDED;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_BE
7930 | OPTS_TYPE_PT_UNICODE
7931 | OPTS_TYPE_ST_ADD80
7932 | OPTS_TYPE_ST_ADDBITS15
7933 | OPTS_TYPE_ST_HEX;
7934 kern_type = KERN_TYPE_SHA512_PWSLTU;
7935 dgst_size = DGST_SIZE_8_8;
7936 parse_func = mssql2012_parse_hash;
7937 sort_by_digest = sort_by_digest_8_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_APPENDED_SALT
7944 | OPTI_TYPE_USES_BITS_64
7945 | OPTI_TYPE_RAW_HASH;
7946 dgst_pos0 = 14;
7947 dgst_pos1 = 15;
7948 dgst_pos2 = 6;
7949 dgst_pos3 = 7;
7950 break;
7951
7952 case 1740: hash_type = HASH_TYPE_SHA512;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS15
7958 | OPTS_TYPE_PT_UNICODE;
7959 kern_type = KERN_TYPE_SHA512_SLTPWU;
7960 dgst_size = DGST_SIZE_8_8;
7961 parse_func = sha512s_parse_hash;
7962 sort_by_digest = sort_by_digest_8_8;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_PREPENDED_SALT
7969 | OPTI_TYPE_USES_BITS_64
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 14;
7972 dgst_pos1 = 15;
7973 dgst_pos2 = 6;
7974 dgst_pos3 = 7;
7975 break;
7976
7977 case 1750: hash_type = HASH_TYPE_SHA512;
7978 salt_type = SALT_TYPE_INTERN;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_ST_ADD80;
7982 kern_type = KERN_TYPE_HMACSHA512_PW;
7983 dgst_size = DGST_SIZE_8_8;
7984 parse_func = hmacsha512_parse_hash;
7985 sort_by_digest = sort_by_digest_8_8;
7986 opti_type = OPTI_TYPE_ZERO_BYTE
7987 | OPTI_TYPE_USES_BITS_64
7988 | OPTI_TYPE_NOT_ITERATED;
7989 dgst_pos0 = 14;
7990 dgst_pos1 = 15;
7991 dgst_pos2 = 6;
7992 dgst_pos3 = 7;
7993 break;
7994
7995 case 1760: hash_type = HASH_TYPE_SHA512;
7996 salt_type = SALT_TYPE_INTERN;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS15;
8001 kern_type = KERN_TYPE_HMACSHA512_SLT;
8002 dgst_size = DGST_SIZE_8_8;
8003 parse_func = hmacsha512_parse_hash;
8004 sort_by_digest = sort_by_digest_8_8;
8005 opti_type = OPTI_TYPE_ZERO_BYTE
8006 | OPTI_TYPE_USES_BITS_64
8007 | OPTI_TYPE_NOT_ITERATED;
8008 dgst_pos0 = 14;
8009 dgst_pos1 = 15;
8010 dgst_pos2 = 6;
8011 dgst_pos3 = 7;
8012 break;
8013
8014 case 1800: hash_type = HASH_TYPE_SHA512;
8015 salt_type = SALT_TYPE_EMBEDDED;
8016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8017 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8018 kern_type = KERN_TYPE_SHA512CRYPT;
8019 dgst_size = DGST_SIZE_8_8;
8020 parse_func = sha512crypt_parse_hash;
8021 sort_by_digest = sort_by_digest_8_8;
8022 opti_type = OPTI_TYPE_ZERO_BYTE
8023 | OPTI_TYPE_USES_BITS_64;
8024 dgst_pos0 = 0;
8025 dgst_pos1 = 1;
8026 dgst_pos2 = 2;
8027 dgst_pos3 = 3;
8028 break;
8029
8030 case 2100: hash_type = HASH_TYPE_DCC2;
8031 salt_type = SALT_TYPE_EMBEDDED;
8032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8033 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8034 | OPTS_TYPE_ST_LOWER
8035 | OPTS_TYPE_ST_UNICODE;
8036 kern_type = KERN_TYPE_DCC2;
8037 dgst_size = DGST_SIZE_4_4;
8038 parse_func = dcc2_parse_hash;
8039 sort_by_digest = sort_by_digest_4_4;
8040 opti_type = OPTI_TYPE_ZERO_BYTE;
8041 dgst_pos0 = 0;
8042 dgst_pos1 = 1;
8043 dgst_pos2 = 2;
8044 dgst_pos3 = 3;
8045 break;
8046
8047 case 2400: hash_type = HASH_TYPE_MD5;
8048 salt_type = SALT_TYPE_NONE;
8049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8051 kern_type = KERN_TYPE_MD5PIX;
8052 dgst_size = DGST_SIZE_4_4;
8053 parse_func = md5pix_parse_hash;
8054 sort_by_digest = sort_by_digest_4_4;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_NOT_SALTED;
8061 dgst_pos0 = 0;
8062 dgst_pos1 = 3;
8063 dgst_pos2 = 2;
8064 dgst_pos3 = 1;
8065 break;
8066
8067 case 2410: hash_type = HASH_TYPE_MD5;
8068 salt_type = SALT_TYPE_INTERN;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8071 kern_type = KERN_TYPE_MD5ASA;
8072 dgst_size = DGST_SIZE_4_4;
8073 parse_func = md5asa_parse_hash;
8074 sort_by_digest = sort_by_digest_4_4;
8075 opti_type = OPTI_TYPE_ZERO_BYTE
8076 | OPTI_TYPE_PRECOMPUTE_INIT
8077 | OPTI_TYPE_PRECOMPUTE_MERKLE
8078 | OPTI_TYPE_EARLY_SKIP
8079 | OPTI_TYPE_NOT_ITERATED;
8080 dgst_pos0 = 0;
8081 dgst_pos1 = 3;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 1;
8084 break;
8085
8086 case 2500: hash_type = HASH_TYPE_WPA;
8087 salt_type = SALT_TYPE_EMBEDDED;
8088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8090 kern_type = KERN_TYPE_WPA;
8091 dgst_size = DGST_SIZE_4_4;
8092 parse_func = wpa_parse_hash;
8093 sort_by_digest = sort_by_digest_4_4;
8094 opti_type = OPTI_TYPE_ZERO_BYTE;
8095 dgst_pos0 = 0;
8096 dgst_pos1 = 1;
8097 dgst_pos2 = 2;
8098 dgst_pos3 = 3;
8099 break;
8100
8101 case 2600: hash_type = HASH_TYPE_MD5;
8102 salt_type = SALT_TYPE_VIRTUAL;
8103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_LE
8105 | OPTS_TYPE_PT_ADD80
8106 | OPTS_TYPE_PT_ADDBITS14
8107 | OPTS_TYPE_ST_ADD80;
8108 kern_type = KERN_TYPE_MD55_PWSLT1;
8109 dgst_size = DGST_SIZE_4_4;
8110 parse_func = md5md5_parse_hash;
8111 sort_by_digest = sort_by_digest_4_4;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_INIT
8114 | OPTI_TYPE_PRECOMPUTE_MERKLE
8115 | OPTI_TYPE_EARLY_SKIP;
8116 dgst_pos0 = 0;
8117 dgst_pos1 = 3;
8118 dgst_pos2 = 2;
8119 dgst_pos3 = 1;
8120 break;
8121
8122 case 2611: hash_type = HASH_TYPE_MD5;
8123 salt_type = SALT_TYPE_INTERN;
8124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8125 opts_type = OPTS_TYPE_PT_GENERATE_LE
8126 | OPTS_TYPE_PT_ADD80
8127 | OPTS_TYPE_PT_ADDBITS14
8128 | OPTS_TYPE_ST_ADD80;
8129 kern_type = KERN_TYPE_MD55_PWSLT1;
8130 dgst_size = DGST_SIZE_4_4;
8131 parse_func = vb3_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_PRECOMPUTE_INIT
8135 | OPTI_TYPE_PRECOMPUTE_MERKLE
8136 | OPTI_TYPE_EARLY_SKIP;
8137 dgst_pos0 = 0;
8138 dgst_pos1 = 3;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 1;
8141 break;
8142
8143 case 2612: hash_type = HASH_TYPE_MD5;
8144 salt_type = SALT_TYPE_EMBEDDED;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_LE
8147 | OPTS_TYPE_PT_ADD80
8148 | OPTS_TYPE_PT_ADDBITS14
8149 | OPTS_TYPE_ST_ADD80
8150 | OPTS_TYPE_ST_HEX;
8151 kern_type = KERN_TYPE_MD55_PWSLT1;
8152 dgst_size = DGST_SIZE_4_4;
8153 parse_func = phps_parse_hash;
8154 sort_by_digest = sort_by_digest_4_4;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_PRECOMPUTE_INIT
8157 | OPTI_TYPE_PRECOMPUTE_MERKLE
8158 | OPTI_TYPE_EARLY_SKIP;
8159 dgst_pos0 = 0;
8160 dgst_pos1 = 3;
8161 dgst_pos2 = 2;
8162 dgst_pos3 = 1;
8163 break;
8164
8165 case 2711: hash_type = HASH_TYPE_MD5;
8166 salt_type = SALT_TYPE_INTERN;
8167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_LE
8169 | OPTS_TYPE_PT_ADD80
8170 | OPTS_TYPE_PT_ADDBITS14
8171 | OPTS_TYPE_ST_ADD80;
8172 kern_type = KERN_TYPE_MD55_PWSLT2;
8173 dgst_size = DGST_SIZE_4_4;
8174 parse_func = vb30_parse_hash;
8175 sort_by_digest = sort_by_digest_4_4;
8176 opti_type = OPTI_TYPE_ZERO_BYTE
8177 | OPTI_TYPE_PRECOMPUTE_INIT
8178 | OPTI_TYPE_EARLY_SKIP;
8179 dgst_pos0 = 0;
8180 dgst_pos1 = 3;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 1;
8183 break;
8184
8185 case 2811: hash_type = HASH_TYPE_MD5;
8186 salt_type = SALT_TYPE_INTERN;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_LE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS14;
8191 kern_type = KERN_TYPE_MD55_SLTPW;
8192 dgst_size = DGST_SIZE_4_4;
8193 parse_func = ipb2_parse_hash;
8194 sort_by_digest = sort_by_digest_4_4;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_EARLY_SKIP;
8198 dgst_pos0 = 0;
8199 dgst_pos1 = 3;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 1;
8202 break;
8203
8204 case 3000: hash_type = HASH_TYPE_LM;
8205 salt_type = SALT_TYPE_NONE;
8206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE
8208 | OPTS_TYPE_PT_UPPER
8209 | OPTS_TYPE_PT_BITSLICE;
8210 kern_type = KERN_TYPE_LM;
8211 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8212 parse_func = lm_parse_hash;
8213 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8216 dgst_pos0 = 0;
8217 dgst_pos1 = 1;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 3;
8220 break;
8221
8222 case 3100: hash_type = HASH_TYPE_ORACLEH;
8223 salt_type = SALT_TYPE_INTERN;
8224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_LE
8226 | OPTS_TYPE_PT_UPPER
8227 | OPTS_TYPE_ST_UPPER;
8228 kern_type = KERN_TYPE_ORACLEH;
8229 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8230 parse_func = oracleh_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8232 opti_type = OPTI_TYPE_ZERO_BYTE;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 1;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 3;
8237 break;
8238
8239 case 3200: hash_type = HASH_TYPE_BCRYPT;
8240 salt_type = SALT_TYPE_EMBEDDED;
8241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_ST_GENERATE_LE;
8244 kern_type = KERN_TYPE_BCRYPT;
8245 dgst_size = DGST_SIZE_4_6;
8246 parse_func = bcrypt_parse_hash;
8247 sort_by_digest = sort_by_digest_4_6;
8248 opti_type = OPTI_TYPE_ZERO_BYTE;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 1;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 3;
8253 break;
8254
8255 case 3710: hash_type = HASH_TYPE_MD5;
8256 salt_type = SALT_TYPE_INTERN;
8257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE
8259 | OPTS_TYPE_PT_ADD80
8260 | OPTS_TYPE_PT_ADDBITS14;
8261 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = md5s_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_PRECOMPUTE_MERKLE
8268 | OPTI_TYPE_EARLY_SKIP;
8269 dgst_pos0 = 0;
8270 dgst_pos1 = 3;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 1;
8273 break;
8274
8275 case 3711: hash_type = HASH_TYPE_MD5;
8276 salt_type = SALT_TYPE_EMBEDDED;
8277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_LE
8279 | OPTS_TYPE_PT_ADD80
8280 | OPTS_TYPE_PT_ADDBITS14;
8281 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8282 dgst_size = DGST_SIZE_4_4;
8283 parse_func = mediawiki_b_parse_hash;
8284 sort_by_digest = sort_by_digest_4_4;
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_PRECOMPUTE_INIT
8287 | OPTI_TYPE_PRECOMPUTE_MERKLE
8288 | OPTI_TYPE_EARLY_SKIP;
8289 dgst_pos0 = 0;
8290 dgst_pos1 = 3;
8291 dgst_pos2 = 2;
8292 dgst_pos3 = 1;
8293 break;
8294
8295 case 3800: hash_type = HASH_TYPE_MD5;
8296 salt_type = SALT_TYPE_INTERN;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_LE
8299 | OPTS_TYPE_ST_ADDBITS14;
8300 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = md5s_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP
8308 | OPTI_TYPE_NOT_ITERATED
8309 | OPTI_TYPE_RAW_HASH;
8310 dgst_pos0 = 0;
8311 dgst_pos1 = 3;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 1;
8314 break;
8315
8316 case 4300: hash_type = HASH_TYPE_MD5;
8317 salt_type = SALT_TYPE_VIRTUAL;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_LE
8320 | OPTS_TYPE_PT_ADD80
8321 | OPTS_TYPE_PT_ADDBITS14
8322 | OPTS_TYPE_ST_ADD80;
8323 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8324 dgst_size = DGST_SIZE_4_4;
8325 parse_func = md5md5_parse_hash;
8326 sort_by_digest = sort_by_digest_4_4;
8327 opti_type = OPTI_TYPE_ZERO_BYTE
8328 | OPTI_TYPE_PRECOMPUTE_INIT
8329 | OPTI_TYPE_PRECOMPUTE_MERKLE
8330 | OPTI_TYPE_EARLY_SKIP;
8331 dgst_pos0 = 0;
8332 dgst_pos1 = 3;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 1;
8335 break;
8336
8337
8338 case 4400: hash_type = HASH_TYPE_MD5;
8339 salt_type = SALT_TYPE_NONE;
8340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8341 opts_type = OPTS_TYPE_PT_GENERATE_BE
8342 | OPTS_TYPE_PT_ADD80
8343 | OPTS_TYPE_PT_ADDBITS15;
8344 kern_type = KERN_TYPE_MD5_SHA1;
8345 dgst_size = DGST_SIZE_4_4;
8346 parse_func = md5_parse_hash;
8347 sort_by_digest = sort_by_digest_4_4;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP
8352 | OPTI_TYPE_NOT_ITERATED
8353 | OPTI_TYPE_NOT_SALTED
8354 | OPTI_TYPE_RAW_HASH;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 4500: hash_type = HASH_TYPE_SHA1;
8362 salt_type = SALT_TYPE_NONE;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_BE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS15;
8367 kern_type = KERN_TYPE_SHA11;
8368 dgst_size = DGST_SIZE_4_5;
8369 parse_func = sha1_parse_hash;
8370 sort_by_digest = sort_by_digest_4_5;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_PRECOMPUTE_MERKLE
8374 | OPTI_TYPE_EARLY_SKIP
8375 | OPTI_TYPE_NOT_SALTED;
8376 dgst_pos0 = 3;
8377 dgst_pos1 = 4;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 1;
8380 break;
8381
8382 case 4700: hash_type = HASH_TYPE_SHA1;
8383 salt_type = SALT_TYPE_NONE;
8384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE
8386 | OPTS_TYPE_PT_ADD80
8387 | OPTS_TYPE_PT_ADDBITS14;
8388 kern_type = KERN_TYPE_SHA1_MD5;
8389 dgst_size = DGST_SIZE_4_5;
8390 parse_func = sha1_parse_hash;
8391 sort_by_digest = sort_by_digest_4_5;
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_PRECOMPUTE_INIT
8394 | OPTI_TYPE_PRECOMPUTE_MERKLE
8395 | OPTI_TYPE_EARLY_SKIP
8396 | OPTI_TYPE_NOT_ITERATED
8397 | OPTI_TYPE_NOT_SALTED
8398 | OPTI_TYPE_RAW_HASH;
8399 dgst_pos0 = 3;
8400 dgst_pos1 = 4;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 1;
8403 break;
8404
8405 case 4800: hash_type = HASH_TYPE_MD5;
8406 salt_type = SALT_TYPE_EMBEDDED;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE
8409 | OPTS_TYPE_PT_ADDBITS14;
8410 kern_type = KERN_TYPE_MD5_CHAP;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = chap_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_MEET_IN_MIDDLE
8418 | OPTI_TYPE_EARLY_SKIP
8419 | OPTI_TYPE_NOT_ITERATED
8420 | OPTI_TYPE_RAW_HASH;
8421 dgst_pos0 = 0;
8422 dgst_pos1 = 3;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 1;
8425 break;
8426
8427 case 4900: hash_type = HASH_TYPE_SHA1;
8428 salt_type = SALT_TYPE_INTERN;
8429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8431 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8432 dgst_size = DGST_SIZE_4_5;
8433 parse_func = sha1s_parse_hash;
8434 sort_by_digest = sort_by_digest_4_5;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP;
8439 dgst_pos0 = 3;
8440 dgst_pos1 = 4;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 5000: hash_type = HASH_TYPE_KECCAK;
8446 salt_type = SALT_TYPE_EMBEDDED;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE
8449 | OPTS_TYPE_PT_ADD01;
8450 kern_type = KERN_TYPE_KECCAK;
8451 dgst_size = DGST_SIZE_8_25;
8452 parse_func = keccak_parse_hash;
8453 sort_by_digest = sort_by_digest_8_25;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_USES_BITS_64
8456 | OPTI_TYPE_RAW_HASH;
8457 dgst_pos0 = 2;
8458 dgst_pos1 = 3;
8459 dgst_pos2 = 4;
8460 dgst_pos3 = 5;
8461 break;
8462
8463 case 5100: hash_type = HASH_TYPE_MD5H;
8464 salt_type = SALT_TYPE_NONE;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE
8467 | OPTS_TYPE_PT_ADD80
8468 | OPTS_TYPE_PT_ADDBITS14;
8469 kern_type = KERN_TYPE_MD5H;
8470 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8471 parse_func = md5half_parse_hash;
8472 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_RAW_HASH;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 1;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 3;
8479 break;
8480
8481 case 5200: hash_type = HASH_TYPE_SHA256;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8485 kern_type = KERN_TYPE_PSAFE3;
8486 dgst_size = DGST_SIZE_4_8;
8487 parse_func = psafe3_parse_hash;
8488 sort_by_digest = sort_by_digest_4_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 1;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 3;
8494 break;
8495
8496 case 5300: hash_type = HASH_TYPE_MD5;
8497 salt_type = SALT_TYPE_EMBEDDED;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE
8500 | OPTS_TYPE_ST_ADD80;
8501 kern_type = KERN_TYPE_IKEPSK_MD5;
8502 dgst_size = DGST_SIZE_4_4;
8503 parse_func = ikepsk_md5_parse_hash;
8504 sort_by_digest = sort_by_digest_4_4;
8505 opti_type = OPTI_TYPE_ZERO_BYTE;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 5400: hash_type = HASH_TYPE_SHA1;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_BE
8516 | OPTS_TYPE_ST_ADD80;
8517 kern_type = KERN_TYPE_IKEPSK_SHA1;
8518 dgst_size = DGST_SIZE_4_5;
8519 parse_func = ikepsk_sha1_parse_hash;
8520 sort_by_digest = sort_by_digest_4_5;
8521 opti_type = OPTI_TYPE_ZERO_BYTE;
8522 dgst_pos0 = 3;
8523 dgst_pos1 = 4;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 5500: hash_type = HASH_TYPE_NETNTLM;
8529 salt_type = SALT_TYPE_EMBEDDED;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS14
8534 | OPTS_TYPE_PT_UNICODE
8535 | OPTS_TYPE_ST_HEX;
8536 kern_type = KERN_TYPE_NETNTLMv1;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = netntlmv1_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 5600: hash_type = HASH_TYPE_MD5;
8549 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_PT_UNICODE;
8555 kern_type = KERN_TYPE_NETNTLMv2;
8556 dgst_size = DGST_SIZE_4_4;
8557 parse_func = netntlmv2_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4;
8559 opti_type = OPTI_TYPE_ZERO_BYTE;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 3;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 1;
8564 break;
8565
8566 case 5700: hash_type = HASH_TYPE_SHA256;
8567 salt_type = SALT_TYPE_NONE;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_BE
8570 | OPTS_TYPE_PT_ADD80
8571 | OPTS_TYPE_PT_ADDBITS15;
8572 kern_type = KERN_TYPE_SHA256;
8573 dgst_size = DGST_SIZE_4_8;
8574 parse_func = cisco4_parse_hash;
8575 sort_by_digest = sort_by_digest_4_8;
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_INIT
8578 | OPTI_TYPE_PRECOMPUTE_MERKLE
8579 | OPTI_TYPE_EARLY_SKIP
8580 | OPTI_TYPE_NOT_ITERATED
8581 | OPTI_TYPE_NOT_SALTED
8582 | OPTI_TYPE_RAW_HASH;
8583 dgst_pos0 = 3;
8584 dgst_pos1 = 7;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 6;
8587 break;
8588
8589 case 5800: hash_type = HASH_TYPE_SHA1;
8590 salt_type = SALT_TYPE_INTERN;
8591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8593 | OPTS_TYPE_ST_ADD80;
8594 kern_type = KERN_TYPE_ANDROIDPIN;
8595 dgst_size = DGST_SIZE_4_5;
8596 parse_func = androidpin_parse_hash;
8597 sort_by_digest = sort_by_digest_4_5;
8598 opti_type = OPTI_TYPE_ZERO_BYTE;
8599 dgst_pos0 = 0;
8600 dgst_pos1 = 1;
8601 dgst_pos2 = 2;
8602 dgst_pos3 = 3;
8603 break;
8604
8605 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8606 salt_type = SALT_TYPE_NONE;
8607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8608 opts_type = OPTS_TYPE_PT_GENERATE_LE
8609 | OPTS_TYPE_PT_ADD80;
8610 kern_type = KERN_TYPE_RIPEMD160;
8611 dgst_size = DGST_SIZE_4_5;
8612 parse_func = ripemd160_parse_hash;
8613 sort_by_digest = sort_by_digest_4_5;
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8622 salt_type = SALT_TYPE_NONE;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_BE
8625 | OPTS_TYPE_PT_ADD80;
8626 kern_type = KERN_TYPE_WHIRLPOOL;
8627 dgst_size = DGST_SIZE_4_16;
8628 parse_func = whirlpool_parse_hash;
8629 sort_by_digest = sort_by_digest_4_16;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8641 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8642 dgst_size = DGST_SIZE_4_5;
8643 parse_func = truecrypt_parse_hash_2k;
8644 sort_by_digest = sort_by_digest_4_5;
8645 opti_type = OPTI_TYPE_ZERO_BYTE;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 1;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 3;
8650 break;
8651
8652 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8653 salt_type = SALT_TYPE_EMBEDDED;
8654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8656 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8657 dgst_size = DGST_SIZE_4_5;
8658 parse_func = truecrypt_parse_hash_2k;
8659 sort_by_digest = sort_by_digest_4_5;
8660 opti_type = OPTI_TYPE_ZERO_BYTE;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8671 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8672 dgst_size = DGST_SIZE_4_5;
8673 parse_func = truecrypt_parse_hash_2k;
8674 sort_by_digest = sort_by_digest_4_5;
8675 opti_type = OPTI_TYPE_ZERO_BYTE;
8676 dgst_pos0 = 0;
8677 dgst_pos1 = 1;
8678 dgst_pos2 = 2;
8679 dgst_pos3 = 3;
8680 break;
8681
8682 case 6221: hash_type = HASH_TYPE_SHA512;
8683 salt_type = SALT_TYPE_EMBEDDED;
8684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8686 kern_type = KERN_TYPE_TCSHA512_XTS512;
8687 dgst_size = DGST_SIZE_8_8;
8688 parse_func = truecrypt_parse_hash_1k;
8689 sort_by_digest = sort_by_digest_8_8;
8690 opti_type = OPTI_TYPE_ZERO_BYTE
8691 | OPTI_TYPE_USES_BITS_64;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 6222: hash_type = HASH_TYPE_SHA512;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8702 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8703 dgst_size = DGST_SIZE_8_8;
8704 parse_func = truecrypt_parse_hash_1k;
8705 sort_by_digest = sort_by_digest_8_8;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_USES_BITS_64;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 6223: hash_type = HASH_TYPE_SHA512;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8718 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8719 dgst_size = DGST_SIZE_8_8;
8720 parse_func = truecrypt_parse_hash_1k;
8721 sort_by_digest = sort_by_digest_8_8;
8722 opti_type = OPTI_TYPE_ZERO_BYTE
8723 | OPTI_TYPE_USES_BITS_64;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 1;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 3;
8728 break;
8729
8730 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8734 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8735 dgst_size = DGST_SIZE_4_8;
8736 parse_func = truecrypt_parse_hash_1k;
8737 sort_by_digest = sort_by_digest_4_8;
8738 opti_type = OPTI_TYPE_ZERO_BYTE;
8739 dgst_pos0 = 0;
8740 dgst_pos1 = 1;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 3;
8743 break;
8744
8745 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8746 salt_type = SALT_TYPE_EMBEDDED;
8747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8749 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8750 dgst_size = DGST_SIZE_4_8;
8751 parse_func = truecrypt_parse_hash_1k;
8752 sort_by_digest = sort_by_digest_4_8;
8753 opti_type = OPTI_TYPE_ZERO_BYTE;
8754 dgst_pos0 = 0;
8755 dgst_pos1 = 1;
8756 dgst_pos2 = 2;
8757 dgst_pos3 = 3;
8758 break;
8759
8760 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8761 salt_type = SALT_TYPE_EMBEDDED;
8762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8764 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8765 dgst_size = DGST_SIZE_4_8;
8766 parse_func = truecrypt_parse_hash_1k;
8767 sort_by_digest = sort_by_digest_4_8;
8768 opti_type = OPTI_TYPE_ZERO_BYTE;
8769 dgst_pos0 = 0;
8770 dgst_pos1 = 1;
8771 dgst_pos2 = 2;
8772 dgst_pos3 = 3;
8773 break;
8774
8775 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8776 salt_type = SALT_TYPE_EMBEDDED;
8777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8778 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8779 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8780 dgst_size = DGST_SIZE_4_5;
8781 parse_func = truecrypt_parse_hash_1k;
8782 sort_by_digest = sort_by_digest_4_5;
8783 opti_type = OPTI_TYPE_ZERO_BYTE;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8791 salt_type = SALT_TYPE_EMBEDDED;
8792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8794 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8795 dgst_size = DGST_SIZE_4_5;
8796 parse_func = truecrypt_parse_hash_1k;
8797 sort_by_digest = sort_by_digest_4_5;
8798 opti_type = OPTI_TYPE_ZERO_BYTE;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8809 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8810 dgst_size = DGST_SIZE_4_5;
8811 parse_func = truecrypt_parse_hash_1k;
8812 sort_by_digest = sort_by_digest_4_5;
8813 opti_type = OPTI_TYPE_ZERO_BYTE;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 6300: hash_type = HASH_TYPE_MD5;
8821 salt_type = SALT_TYPE_EMBEDDED;
8822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8824 kern_type = KERN_TYPE_MD5AIX;
8825 dgst_size = DGST_SIZE_4_4;
8826 parse_func = md5aix_parse_hash;
8827 sort_by_digest = sort_by_digest_4_4;
8828 opti_type = OPTI_TYPE_ZERO_BYTE;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 1;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 3;
8833 break;
8834
8835 case 6400: hash_type = HASH_TYPE_SHA256;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8839 kern_type = KERN_TYPE_SHA256AIX;
8840 dgst_size = DGST_SIZE_4_8;
8841 parse_func = sha256aix_parse_hash;
8842 sort_by_digest = sort_by_digest_4_8;
8843 opti_type = OPTI_TYPE_ZERO_BYTE;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6500: hash_type = HASH_TYPE_SHA512;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8854 kern_type = KERN_TYPE_SHA512AIX;
8855 dgst_size = DGST_SIZE_8_8;
8856 parse_func = sha512aix_parse_hash;
8857 sort_by_digest = sort_by_digest_8_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE
8859 | OPTI_TYPE_USES_BITS_64;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 1;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 3;
8864 break;
8865
8866 case 6600: hash_type = HASH_TYPE_AES;
8867 salt_type = SALT_TYPE_EMBEDDED;
8868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8870 kern_type = KERN_TYPE_AGILEKEY;
8871 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8872 parse_func = agilekey_parse_hash;
8873 sort_by_digest = sort_by_digest_4_5;
8874 opti_type = OPTI_TYPE_ZERO_BYTE;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 1;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 3;
8879 break;
8880
8881 case 6700: hash_type = HASH_TYPE_SHA1;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8885 kern_type = KERN_TYPE_SHA1AIX;
8886 dgst_size = DGST_SIZE_4_5;
8887 parse_func = sha1aix_parse_hash;
8888 sort_by_digest = sort_by_digest_4_5;
8889 opti_type = OPTI_TYPE_ZERO_BYTE;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 1;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 3;
8894 break;
8895
8896 case 6800: hash_type = HASH_TYPE_AES;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8900 kern_type = KERN_TYPE_LASTPASS;
8901 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8902 parse_func = lastpass_parse_hash;
8903 sort_by_digest = sort_by_digest_4_8;
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 6900: hash_type = HASH_TYPE_GOST;
8912 salt_type = SALT_TYPE_NONE;
8913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8915 kern_type = KERN_TYPE_GOST;
8916 dgst_size = DGST_SIZE_4_8;
8917 parse_func = gost_parse_hash;
8918 sort_by_digest = sort_by_digest_4_8;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 7100: hash_type = HASH_TYPE_SHA512;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8930 kern_type = KERN_TYPE_PBKDF2_SHA512;
8931 dgst_size = DGST_SIZE_8_16;
8932 parse_func = sha512osx_parse_hash;
8933 sort_by_digest = sort_by_digest_8_16;
8934 opti_type = OPTI_TYPE_ZERO_BYTE
8935 | OPTI_TYPE_USES_BITS_64;
8936 dgst_pos0 = 0;
8937 dgst_pos1 = 1;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 3;
8940 break;
8941
8942 case 7200: hash_type = HASH_TYPE_SHA512;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8946 kern_type = KERN_TYPE_PBKDF2_SHA512;
8947 dgst_size = DGST_SIZE_8_16;
8948 parse_func = sha512grub_parse_hash;
8949 sort_by_digest = sort_by_digest_8_16;
8950 opti_type = OPTI_TYPE_ZERO_BYTE
8951 | OPTI_TYPE_USES_BITS_64;
8952 dgst_pos0 = 0;
8953 dgst_pos1 = 1;
8954 dgst_pos2 = 2;
8955 dgst_pos3 = 3;
8956 break;
8957
8958 case 7300: hash_type = HASH_TYPE_SHA1;
8959 salt_type = SALT_TYPE_EMBEDDED;
8960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8961 opts_type = OPTS_TYPE_PT_GENERATE_BE
8962 | OPTS_TYPE_ST_ADD80
8963 | OPTS_TYPE_ST_ADDBITS15;
8964 kern_type = KERN_TYPE_RAKP;
8965 dgst_size = DGST_SIZE_4_5;
8966 parse_func = rakp_parse_hash;
8967 sort_by_digest = sort_by_digest_4_5;
8968 opti_type = OPTI_TYPE_ZERO_BYTE
8969 | OPTI_TYPE_NOT_ITERATED;
8970 dgst_pos0 = 3;
8971 dgst_pos1 = 4;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 1;
8974 break;
8975
8976 case 7400: hash_type = HASH_TYPE_SHA256;
8977 salt_type = SALT_TYPE_EMBEDDED;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8980 kern_type = KERN_TYPE_SHA256CRYPT;
8981 dgst_size = DGST_SIZE_4_8;
8982 parse_func = sha256crypt_parse_hash;
8983 sort_by_digest = sort_by_digest_4_8;
8984 opti_type = OPTI_TYPE_ZERO_BYTE;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 1;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 3;
8989 break;
8990
8991 case 7500: hash_type = HASH_TYPE_KRB5PA;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8995 kern_type = KERN_TYPE_KRB5PA;
8996 dgst_size = DGST_SIZE_4_4;
8997 parse_func = krb5pa_parse_hash;
8998 sort_by_digest = sort_by_digest_4_4;
8999 opti_type = OPTI_TYPE_ZERO_BYTE
9000 | OPTI_TYPE_NOT_ITERATED;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 7600: hash_type = HASH_TYPE_SHA1;
9008 salt_type = SALT_TYPE_INTERN;
9009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_BE
9011 | OPTS_TYPE_PT_ADD80
9012 | OPTS_TYPE_PT_ADDBITS15;
9013 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9014 dgst_size = DGST_SIZE_4_5;
9015 parse_func = redmine_parse_hash;
9016 sort_by_digest = sort_by_digest_4_5;
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_PRECOMPUTE_INIT
9019 | OPTI_TYPE_EARLY_SKIP
9020 | OPTI_TYPE_NOT_ITERATED
9021 | OPTI_TYPE_PREPENDED_SALT;
9022 dgst_pos0 = 3;
9023 dgst_pos1 = 4;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 1;
9026 break;
9027
9028 case 7700: hash_type = HASH_TYPE_SAPB;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE
9032 | OPTS_TYPE_PT_UPPER
9033 | OPTS_TYPE_ST_UPPER;
9034 kern_type = KERN_TYPE_SAPB;
9035 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9036 parse_func = sapb_parse_hash;
9037 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9038 opti_type = OPTI_TYPE_ZERO_BYTE
9039 | OPTI_TYPE_PRECOMPUTE_INIT
9040 | OPTI_TYPE_NOT_ITERATED;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 1;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 3;
9045 break;
9046
9047 case 7800: hash_type = HASH_TYPE_SAPG;
9048 salt_type = SALT_TYPE_EMBEDDED;
9049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_BE
9051 | OPTS_TYPE_ST_ADD80
9052 | OPTS_TYPE_ST_UPPER;
9053 kern_type = KERN_TYPE_SAPG;
9054 dgst_size = DGST_SIZE_4_5;
9055 parse_func = sapg_parse_hash;
9056 sort_by_digest = sort_by_digest_4_5;
9057 opti_type = OPTI_TYPE_ZERO_BYTE
9058 | OPTI_TYPE_PRECOMPUTE_INIT
9059 | OPTI_TYPE_NOT_ITERATED;
9060 dgst_pos0 = 3;
9061 dgst_pos1 = 4;
9062 dgst_pos2 = 2;
9063 dgst_pos3 = 1;
9064 break;
9065
9066 case 7900: hash_type = HASH_TYPE_SHA512;
9067 salt_type = SALT_TYPE_EMBEDDED;
9068 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9069 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9070 kern_type = KERN_TYPE_DRUPAL7;
9071 dgst_size = DGST_SIZE_8_8;
9072 parse_func = drupal7_parse_hash;
9073 sort_by_digest = sort_by_digest_8_8;
9074 opti_type = OPTI_TYPE_ZERO_BYTE
9075 | OPTI_TYPE_USES_BITS_64;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 8000: hash_type = HASH_TYPE_SHA256;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_BE
9086 | OPTS_TYPE_PT_UNICODE
9087 | OPTS_TYPE_ST_ADD80
9088 | OPTS_TYPE_ST_HEX;
9089 kern_type = KERN_TYPE_SYBASEASE;
9090 dgst_size = DGST_SIZE_4_8;
9091 parse_func = sybasease_parse_hash;
9092 sort_by_digest = sort_by_digest_4_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE
9094 | OPTI_TYPE_PRECOMPUTE_INIT
9095 | OPTI_TYPE_EARLY_SKIP
9096 | OPTI_TYPE_NOT_ITERATED
9097 | OPTI_TYPE_RAW_HASH;
9098 dgst_pos0 = 3;
9099 dgst_pos1 = 7;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 6;
9102 break;
9103
9104 case 8100: hash_type = HASH_TYPE_SHA1;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9108 kern_type = KERN_TYPE_NETSCALER;
9109 dgst_size = DGST_SIZE_4_5;
9110 parse_func = netscaler_parse_hash;
9111 sort_by_digest = sort_by_digest_4_5;
9112 opti_type = OPTI_TYPE_ZERO_BYTE
9113 | OPTI_TYPE_PRECOMPUTE_INIT
9114 | OPTI_TYPE_PRECOMPUTE_MERKLE
9115 | OPTI_TYPE_EARLY_SKIP
9116 | OPTI_TYPE_NOT_ITERATED
9117 | OPTI_TYPE_PREPENDED_SALT
9118 | OPTI_TYPE_RAW_HASH;
9119 dgst_pos0 = 3;
9120 dgst_pos1 = 4;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 1;
9123 break;
9124
9125 case 8200: hash_type = HASH_TYPE_SHA256;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9129 kern_type = KERN_TYPE_CLOUDKEY;
9130 dgst_size = DGST_SIZE_4_8;
9131 parse_func = cloudkey_parse_hash;
9132 sort_by_digest = sort_by_digest_4_8;
9133 opti_type = OPTI_TYPE_ZERO_BYTE;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 8300: hash_type = HASH_TYPE_SHA1;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE
9144 | OPTS_TYPE_ST_HEX
9145 | OPTS_TYPE_ST_ADD80;
9146 kern_type = KERN_TYPE_NSEC3;
9147 dgst_size = DGST_SIZE_4_5;
9148 parse_func = nsec3_parse_hash;
9149 sort_by_digest = sort_by_digest_4_5;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 3;
9152 dgst_pos1 = 4;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 1;
9155 break;
9156
9157 case 8400: hash_type = HASH_TYPE_SHA1;
9158 salt_type = SALT_TYPE_INTERN;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_BE
9161 | OPTS_TYPE_PT_ADD80
9162 | OPTS_TYPE_PT_ADDBITS15;
9163 kern_type = KERN_TYPE_WBB3;
9164 dgst_size = DGST_SIZE_4_5;
9165 parse_func = wbb3_parse_hash;
9166 sort_by_digest = sort_by_digest_4_5;
9167 opti_type = OPTI_TYPE_ZERO_BYTE
9168 | OPTI_TYPE_PRECOMPUTE_INIT
9169 | OPTI_TYPE_NOT_ITERATED;
9170 dgst_pos0 = 3;
9171 dgst_pos1 = 4;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 1;
9174 break;
9175
9176 case 8500: hash_type = HASH_TYPE_DESRACF;
9177 salt_type = SALT_TYPE_EMBEDDED;
9178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_LE
9180 | OPTS_TYPE_ST_UPPER;
9181 kern_type = KERN_TYPE_RACF;
9182 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9183 parse_func = racf_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9185 opti_type = OPTI_TYPE_ZERO_BYTE
9186 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 8600: hash_type = HASH_TYPE_LOTUS5;
9194 salt_type = SALT_TYPE_NONE;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9197 kern_type = KERN_TYPE_LOTUS5;
9198 dgst_size = DGST_SIZE_4_4;
9199 parse_func = lotus5_parse_hash;
9200 sort_by_digest = sort_by_digest_4_4;
9201 opti_type = OPTI_TYPE_EARLY_SKIP
9202 | OPTI_TYPE_NOT_ITERATED
9203 | OPTI_TYPE_NOT_SALTED
9204 | OPTI_TYPE_RAW_HASH;
9205 dgst_pos0 = 0;
9206 dgst_pos1 = 1;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 3;
9209 break;
9210
9211 case 8700: hash_type = HASH_TYPE_LOTUS6;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9215 kern_type = KERN_TYPE_LOTUS6;
9216 dgst_size = DGST_SIZE_4_4;
9217 parse_func = lotus6_parse_hash;
9218 sort_by_digest = sort_by_digest_4_4;
9219 opti_type = OPTI_TYPE_EARLY_SKIP
9220 | OPTI_TYPE_NOT_ITERATED
9221 | OPTI_TYPE_RAW_HASH;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9232 kern_type = KERN_TYPE_ANDROIDFDE;
9233 dgst_size = DGST_SIZE_4_4;
9234 parse_func = androidfde_parse_hash;
9235 sort_by_digest = sort_by_digest_4_4;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 8900: hash_type = HASH_TYPE_SCRYPT;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_SCRYPT;
9248 dgst_size = DGST_SIZE_4_8;
9249 parse_func = scrypt_parse_hash;
9250 sort_by_digest = sort_by_digest_4_8;
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 9000: hash_type = HASH_TYPE_SHA1;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE
9262 | OPTS_TYPE_ST_GENERATE_LE;
9263 kern_type = KERN_TYPE_PSAFE2;
9264 dgst_size = DGST_SIZE_4_5;
9265 parse_func = psafe2_parse_hash;
9266 sort_by_digest = sort_by_digest_4_5;
9267 opti_type = OPTI_TYPE_ZERO_BYTE;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 9100: hash_type = HASH_TYPE_LOTUS8;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9278 kern_type = KERN_TYPE_LOTUS8;
9279 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9280 parse_func = lotus8_parse_hash;
9281 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 9200: hash_type = HASH_TYPE_SHA256;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9293 kern_type = KERN_TYPE_PBKDF2_SHA256;
9294 dgst_size = DGST_SIZE_4_32;
9295 parse_func = cisco8_parse_hash;
9296 sort_by_digest = sort_by_digest_4_32;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 9300: hash_type = HASH_TYPE_SCRYPT;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9308 kern_type = KERN_TYPE_SCRYPT;
9309 dgst_size = DGST_SIZE_4_8;
9310 parse_func = cisco9_parse_hash;
9311 sort_by_digest = sort_by_digest_4_8;
9312 opti_type = OPTI_TYPE_ZERO_BYTE;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9323 kern_type = KERN_TYPE_OFFICE2007;
9324 dgst_size = DGST_SIZE_4_4;
9325 parse_func = office2007_parse_hash;
9326 sort_by_digest = sort_by_digest_4_4;
9327 opti_type = OPTI_TYPE_ZERO_BYTE;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9338 kern_type = KERN_TYPE_OFFICE2010;
9339 dgst_size = DGST_SIZE_4_4;
9340 parse_func = office2010_parse_hash;
9341 sort_by_digest = sort_by_digest_4_4;
9342 opti_type = OPTI_TYPE_ZERO_BYTE;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9353 kern_type = KERN_TYPE_OFFICE2013;
9354 dgst_size = DGST_SIZE_4_4;
9355 parse_func = office2013_parse_hash;
9356 sort_by_digest = sort_by_digest_4_4;
9357 opti_type = OPTI_TYPE_ZERO_BYTE;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE
9368 | OPTS_TYPE_PT_ADD80
9369 | OPTS_TYPE_PT_UNICODE;
9370 kern_type = KERN_TYPE_OLDOFFICE01;
9371 dgst_size = DGST_SIZE_4_4;
9372 parse_func = oldoffice01_parse_hash;
9373 sort_by_digest = sort_by_digest_4_4;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_INIT
9376 | OPTI_TYPE_NOT_ITERATED;
9377 dgst_pos0 = 0;
9378 dgst_pos1 = 1;
9379 dgst_pos2 = 2;
9380 dgst_pos3 = 3;
9381 break;
9382
9383 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9384 salt_type = SALT_TYPE_EMBEDDED;
9385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9386 opts_type = OPTS_TYPE_PT_GENERATE_LE
9387 | OPTS_TYPE_PT_ADD80;
9388 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9389 dgst_size = DGST_SIZE_4_4;
9390 parse_func = oldoffice01cm1_parse_hash;
9391 sort_by_digest = sort_by_digest_4_4;
9392 opti_type = OPTI_TYPE_ZERO_BYTE
9393 | OPTI_TYPE_PRECOMPUTE_INIT
9394 | OPTI_TYPE_NOT_ITERATED;
9395 dgst_pos0 = 0;
9396 dgst_pos1 = 1;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 3;
9399 break;
9400
9401 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE
9405 | OPTS_TYPE_PT_ADD80
9406 | OPTS_TYPE_PT_UNICODE
9407 | OPTS_TYPE_PT_NEVERCRACK;
9408 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = oldoffice01cm2_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_ZERO_BYTE
9413 | OPTI_TYPE_PRECOMPUTE_INIT
9414 | OPTI_TYPE_NOT_ITERATED;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_BE
9425 | OPTS_TYPE_PT_ADD80
9426 | OPTS_TYPE_PT_UNICODE;
9427 kern_type = KERN_TYPE_OLDOFFICE34;
9428 dgst_size = DGST_SIZE_4_4;
9429 parse_func = oldoffice34_parse_hash;
9430 sort_by_digest = sort_by_digest_4_4;
9431 opti_type = OPTI_TYPE_ZERO_BYTE
9432 | OPTI_TYPE_PRECOMPUTE_INIT
9433 | OPTI_TYPE_NOT_ITERATED;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9444 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9445 dgst_size = DGST_SIZE_4_4;
9446 parse_func = oldoffice34cm1_parse_hash;
9447 sort_by_digest = sort_by_digest_4_4;
9448 opti_type = OPTI_TYPE_ZERO_BYTE
9449 | OPTI_TYPE_PRECOMPUTE_INIT
9450 | OPTI_TYPE_NOT_ITERATED;
9451 dgst_pos0 = 0;
9452 dgst_pos1 = 1;
9453 dgst_pos2 = 2;
9454 dgst_pos3 = 3;
9455 break;
9456
9457 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9458 salt_type = SALT_TYPE_EMBEDDED;
9459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9460 opts_type = OPTS_TYPE_PT_GENERATE_BE
9461 | OPTS_TYPE_PT_ADD80
9462 | OPTS_TYPE_PT_UNICODE
9463 | OPTS_TYPE_PT_NEVERCRACK;
9464 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9465 dgst_size = DGST_SIZE_4_4;
9466 parse_func = oldoffice34cm2_parse_hash;
9467 sort_by_digest = sort_by_digest_4_4;
9468 opti_type = OPTI_TYPE_ZERO_BYTE
9469 | OPTI_TYPE_PRECOMPUTE_INIT
9470 | OPTI_TYPE_NOT_ITERATED;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 9900: hash_type = HASH_TYPE_MD5;
9478 salt_type = SALT_TYPE_NONE;
9479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9481 kern_type = KERN_TYPE_RADMIN2;
9482 dgst_size = DGST_SIZE_4_4;
9483 parse_func = radmin2_parse_hash;
9484 sort_by_digest = sort_by_digest_4_4;
9485 opti_type = OPTI_TYPE_ZERO_BYTE
9486 | OPTI_TYPE_PRECOMPUTE_INIT
9487 | OPTI_TYPE_EARLY_SKIP
9488 | OPTI_TYPE_NOT_ITERATED
9489 | OPTI_TYPE_NOT_SALTED;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 3;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 1;
9494 break;
9495
9496 case 10000: hash_type = HASH_TYPE_SHA256;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9500 kern_type = KERN_TYPE_PBKDF2_SHA256;
9501 dgst_size = DGST_SIZE_4_32;
9502 parse_func = djangopbkdf2_parse_hash;
9503 sort_by_digest = sort_by_digest_4_32;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 10100: hash_type = HASH_TYPE_SIPHASH;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_SIPHASH;
9516 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9517 parse_func = siphash_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9519 opti_type = OPTI_TYPE_ZERO_BYTE
9520 | OPTI_TYPE_NOT_ITERATED
9521 | OPTI_TYPE_RAW_HASH;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 10200: hash_type = HASH_TYPE_MD5;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE
9532 | OPTS_TYPE_ST_ADD80
9533 | OPTS_TYPE_ST_ADDBITS14;
9534 kern_type = KERN_TYPE_HMACMD5_PW;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = crammd5_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_NOT_ITERATED;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 3;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 1;
9544 break;
9545
9546 case 10300: hash_type = HASH_TYPE_SHA1;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9550 kern_type = KERN_TYPE_SAPH_SHA1;
9551 dgst_size = DGST_SIZE_4_5;
9552 parse_func = saph_sha1_parse_hash;
9553 sort_by_digest = sort_by_digest_4_5;
9554 opti_type = OPTI_TYPE_ZERO_BYTE;
9555 dgst_pos0 = 0;
9556 dgst_pos1 = 1;
9557 dgst_pos2 = 2;
9558 dgst_pos3 = 3;
9559 break;
9560
9561 case 10400: hash_type = HASH_TYPE_PDFU16;
9562 salt_type = SALT_TYPE_EMBEDDED;
9563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9565 kern_type = KERN_TYPE_PDF11;
9566 dgst_size = DGST_SIZE_4_4;
9567 parse_func = pdf11_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4;
9569 opti_type = OPTI_TYPE_ZERO_BYTE
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 10410: hash_type = HASH_TYPE_PDFU16;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_PDF11CM1;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = pdf11cm1_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_ZERO_BYTE
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 10420: hash_type = HASH_TYPE_PDFU16;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9597 kern_type = KERN_TYPE_PDF11CM2;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = pdf11cm2_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE
9602 | OPTI_TYPE_NOT_ITERATED;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 10500: hash_type = HASH_TYPE_PDFU16;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9613 kern_type = KERN_TYPE_PDF14;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = pdf14_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_NOT_ITERATED;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 10600: hash_type = HASH_TYPE_SHA256;
9626 salt_type = SALT_TYPE_EMBEDDED;
9627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_BE
9629 | OPTS_TYPE_ST_ADD80
9630 | OPTS_TYPE_ST_ADDBITS15
9631 | OPTS_TYPE_HASH_COPY;
9632 kern_type = KERN_TYPE_SHA256_PWSLT;
9633 dgst_size = DGST_SIZE_4_8;
9634 parse_func = pdf17l3_parse_hash;
9635 sort_by_digest = sort_by_digest_4_8;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_PRECOMPUTE_INIT
9638 | OPTI_TYPE_PRECOMPUTE_MERKLE
9639 | OPTI_TYPE_EARLY_SKIP
9640 | OPTI_TYPE_NOT_ITERATED
9641 | OPTI_TYPE_APPENDED_SALT
9642 | OPTI_TYPE_RAW_HASH;
9643 dgst_pos0 = 3;
9644 dgst_pos1 = 7;
9645 dgst_pos2 = 2;
9646 dgst_pos3 = 6;
9647 break;
9648
9649 case 10700: hash_type = HASH_TYPE_PDFU32;
9650 salt_type = SALT_TYPE_EMBEDDED;
9651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9652 opts_type = OPTS_TYPE_PT_GENERATE_LE
9653 | OPTS_TYPE_HASH_COPY;
9654 kern_type = KERN_TYPE_PDF17L8;
9655 dgst_size = DGST_SIZE_4_8;
9656 parse_func = pdf17l8_parse_hash;
9657 sort_by_digest = sort_by_digest_4_8;
9658 opti_type = OPTI_TYPE_ZERO_BYTE
9659 | OPTI_TYPE_NOT_ITERATED;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 10800: hash_type = HASH_TYPE_SHA384;
9667 salt_type = SALT_TYPE_NONE;
9668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_BE
9670 | OPTS_TYPE_PT_ADD80
9671 | OPTS_TYPE_PT_ADDBITS15;
9672 kern_type = KERN_TYPE_SHA384;
9673 dgst_size = DGST_SIZE_8_8;
9674 parse_func = sha384_parse_hash;
9675 sort_by_digest = sort_by_digest_8_8;
9676 opti_type = OPTI_TYPE_ZERO_BYTE
9677 | OPTI_TYPE_PRECOMPUTE_INIT
9678 | OPTI_TYPE_PRECOMPUTE_MERKLE
9679 | OPTI_TYPE_EARLY_SKIP
9680 | OPTI_TYPE_NOT_ITERATED
9681 | OPTI_TYPE_NOT_SALTED
9682 | OPTI_TYPE_USES_BITS_64
9683 | OPTI_TYPE_RAW_HASH;
9684 dgst_pos0 = 6;
9685 dgst_pos1 = 7;
9686 dgst_pos2 = 4;
9687 dgst_pos3 = 5;
9688 break;
9689
9690 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_ST_BASE64
9695 | OPTS_TYPE_HASH_COPY;
9696 kern_type = KERN_TYPE_PBKDF2_SHA256;
9697 dgst_size = DGST_SIZE_4_32;
9698 parse_func = pbkdf2_sha256_parse_hash;
9699 sort_by_digest = sort_by_digest_4_32;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 11000: hash_type = HASH_TYPE_MD5;
9708 salt_type = SALT_TYPE_INTERN;
9709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE
9711 | OPTS_TYPE_PT_ADD80;
9712 kern_type = KERN_TYPE_PRESTASHOP;
9713 dgst_size = DGST_SIZE_4_4;
9714 parse_func = prestashop_parse_hash;
9715 sort_by_digest = sort_by_digest_4_4;
9716 opti_type = OPTI_TYPE_ZERO_BYTE
9717 | OPTI_TYPE_PRECOMPUTE_INIT
9718 | OPTI_TYPE_NOT_ITERATED
9719 | OPTI_TYPE_PREPENDED_SALT;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 3;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 1;
9724 break;
9725
9726 case 11100: hash_type = HASH_TYPE_MD5;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE
9730 | OPTS_TYPE_ST_ADD80;
9731 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9732 dgst_size = DGST_SIZE_4_4;
9733 parse_func = postgresql_auth_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_PRECOMPUTE_INIT
9737 | OPTI_TYPE_PRECOMPUTE_MERKLE
9738 | OPTI_TYPE_EARLY_SKIP;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 3;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 1;
9743 break;
9744
9745 case 11200: hash_type = HASH_TYPE_SHA1;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_BE
9749 | OPTS_TYPE_PT_ADD80
9750 | OPTS_TYPE_ST_HEX;
9751 kern_type = KERN_TYPE_MYSQL_AUTH;
9752 dgst_size = DGST_SIZE_4_5;
9753 parse_func = mysql_auth_parse_hash;
9754 sort_by_digest = sort_by_digest_4_5;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_EARLY_SKIP;
9757 dgst_pos0 = 3;
9758 dgst_pos1 = 4;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 1;
9761 break;
9762
9763 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE
9767 | OPTS_TYPE_ST_HEX
9768 | OPTS_TYPE_ST_ADD80;
9769 kern_type = KERN_TYPE_BITCOIN_WALLET;
9770 dgst_size = DGST_SIZE_4_4;
9771 parse_func = bitcoin_wallet_parse_hash;
9772 sort_by_digest = sort_by_digest_4_4;
9773 opti_type = OPTI_TYPE_ZERO_BYTE;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 1;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 3;
9778 break;
9779
9780 case 11400: hash_type = HASH_TYPE_MD5;
9781 salt_type = SALT_TYPE_EMBEDDED;
9782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_LE
9784 | OPTS_TYPE_PT_ADD80
9785 | OPTS_TYPE_HASH_COPY;
9786 kern_type = KERN_TYPE_SIP_AUTH;
9787 dgst_size = DGST_SIZE_4_4;
9788 parse_func = sip_auth_parse_hash;
9789 sort_by_digest = sort_by_digest_4_4;
9790 opti_type = OPTI_TYPE_ZERO_BYTE;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 3;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 1;
9795 break;
9796
9797 case 11500: hash_type = HASH_TYPE_CRC32;
9798 salt_type = SALT_TYPE_INTERN;
9799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE
9801 | OPTS_TYPE_ST_GENERATE_LE
9802 | OPTS_TYPE_ST_HEX;
9803 kern_type = KERN_TYPE_CRC32;
9804 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9805 parse_func = crc32_parse_hash;
9806 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9807 opti_type = OPTI_TYPE_ZERO_BYTE;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 11600: hash_type = HASH_TYPE_AES;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_LE
9818 | OPTS_TYPE_PT_NEVERCRACK;
9819 kern_type = KERN_TYPE_SEVEN_ZIP;
9820 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9821 parse_func = seven_zip_parse_hash;
9822 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9823 opti_type = OPTI_TYPE_ZERO_BYTE;
9824 dgst_pos0 = 0;
9825 dgst_pos1 = 1;
9826 dgst_pos2 = 2;
9827 dgst_pos3 = 3;
9828 break;
9829
9830 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9831 salt_type = SALT_TYPE_NONE;
9832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_LE
9834 | OPTS_TYPE_PT_ADD01;
9835 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9836 dgst_size = DGST_SIZE_4_8;
9837 parse_func = gost2012sbog_256_parse_hash;
9838 sort_by_digest = sort_by_digest_4_8;
9839 opti_type = OPTI_TYPE_ZERO_BYTE;
9840 dgst_pos0 = 0;
9841 dgst_pos1 = 1;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 3;
9844 break;
9845
9846 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9847 salt_type = SALT_TYPE_NONE;
9848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE
9850 | OPTS_TYPE_PT_ADD01;
9851 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9852 dgst_size = DGST_SIZE_4_16;
9853 parse_func = gost2012sbog_512_parse_hash;
9854 sort_by_digest = sort_by_digest_4_16;
9855 opti_type = OPTI_TYPE_ZERO_BYTE;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9863 salt_type = SALT_TYPE_EMBEDDED;
9864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE
9866 | OPTS_TYPE_ST_BASE64
9867 | OPTS_TYPE_HASH_COPY;
9868 kern_type = KERN_TYPE_PBKDF2_MD5;
9869 dgst_size = DGST_SIZE_4_32;
9870 parse_func = pbkdf2_md5_parse_hash;
9871 sort_by_digest = sort_by_digest_4_32;
9872 opti_type = OPTI_TYPE_ZERO_BYTE;
9873 dgst_pos0 = 0;
9874 dgst_pos1 = 1;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 3;
9877 break;
9878
9879 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE
9883 | OPTS_TYPE_ST_BASE64
9884 | OPTS_TYPE_HASH_COPY;
9885 kern_type = KERN_TYPE_PBKDF2_SHA1;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = pbkdf2_sha1_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE;
9890 dgst_pos0 = 0;
9891 dgst_pos1 = 1;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 3;
9894 break;
9895
9896 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9897 salt_type = SALT_TYPE_EMBEDDED;
9898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE
9900 | OPTS_TYPE_ST_BASE64
9901 | OPTS_TYPE_HASH_COPY;
9902 kern_type = KERN_TYPE_PBKDF2_SHA512;
9903 dgst_size = DGST_SIZE_8_16;
9904 parse_func = pbkdf2_sha512_parse_hash;
9905 sort_by_digest = sort_by_digest_8_16;
9906 opti_type = OPTI_TYPE_ZERO_BYTE
9907 | OPTI_TYPE_USES_BITS_64;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9918 kern_type = KERN_TYPE_ECRYPTFS;
9919 dgst_size = DGST_SIZE_8_8;
9920 parse_func = ecryptfs_parse_hash;
9921 sort_by_digest = sort_by_digest_8_8;
9922 opti_type = OPTI_TYPE_ZERO_BYTE
9923 | OPTI_TYPE_USES_BITS_64;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 1;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 3;
9928 break;
9929
9930 case 12300: hash_type = HASH_TYPE_ORACLET;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9934 kern_type = KERN_TYPE_ORACLET;
9935 dgst_size = DGST_SIZE_8_16;
9936 parse_func = oraclet_parse_hash;
9937 sort_by_digest = sort_by_digest_8_16;
9938 opti_type = OPTI_TYPE_ZERO_BYTE
9939 | OPTI_TYPE_USES_BITS_64;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9950 kern_type = KERN_TYPE_BSDICRYPT;
9951 dgst_size = DGST_SIZE_4_4;
9952 parse_func = bsdicrypt_parse_hash;
9953 sort_by_digest = sort_by_digest_4_4;
9954 opti_type = OPTI_TYPE_ZERO_BYTE
9955 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9956 dgst_pos0 = 0;
9957 dgst_pos1 = 1;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 3;
9960 break;
9961
9962 case 12500: hash_type = HASH_TYPE_RAR3HP;
9963 salt_type = SALT_TYPE_EMBEDDED;
9964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9966 kern_type = KERN_TYPE_RAR3;
9967 dgst_size = DGST_SIZE_4_4;
9968 parse_func = rar3hp_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4;
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 12600: hash_type = HASH_TYPE_SHA256;
9978 salt_type = SALT_TYPE_INTERN;
9979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_BE
9981 | OPTS_TYPE_PT_ADD80;
9982 kern_type = KERN_TYPE_CF10;
9983 dgst_size = DGST_SIZE_4_8;
9984 parse_func = cf10_parse_hash;
9985 sort_by_digest = sort_by_digest_4_8;
9986 opti_type = OPTI_TYPE_ZERO_BYTE
9987 | OPTI_TYPE_PRECOMPUTE_INIT
9988 | OPTI_TYPE_EARLY_SKIP
9989 | OPTI_TYPE_NOT_ITERATED;
9990 dgst_pos0 = 3;
9991 dgst_pos1 = 7;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 6;
9994 break;
9995
9996 case 12700: hash_type = HASH_TYPE_AES;
9997 salt_type = SALT_TYPE_EMBEDDED;
9998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE
10000 | OPTS_TYPE_HASH_COPY;
10001 kern_type = KERN_TYPE_MYWALLET;
10002 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10003 parse_func = mywallet_parse_hash;
10004 sort_by_digest = sort_by_digest_4_5;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10016 kern_type = KERN_TYPE_MS_DRSR;
10017 dgst_size = DGST_SIZE_4_8;
10018 parse_func = ms_drsr_parse_hash;
10019 sort_by_digest = sort_by_digest_4_8;
10020 opti_type = OPTI_TYPE_ZERO_BYTE;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10028 salt_type = SALT_TYPE_EMBEDDED;
10029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10031 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10032 dgst_size = DGST_SIZE_4_8;
10033 parse_func = androidfde_samsung_parse_hash;
10034 sort_by_digest = sort_by_digest_4_8;
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10046 kern_type = KERN_TYPE_RAR5;
10047 dgst_size = DGST_SIZE_4_4;
10048 parse_func = rar5_parse_hash;
10049 sort_by_digest = sort_by_digest_4_4;
10050 opti_type = OPTI_TYPE_ZERO_BYTE;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 default: usage_mini_print (PROGNAME); return (-1);
10058 }
10059
10060 /**
10061 * transpose
10062 */
10063
10064 data.parse_func = parse_func;
10065
10066 /**
10067 * misc stuff
10068 */
10069
10070 if (hex_salt)
10071 {
10072 if (salt_type == SALT_TYPE_INTERN)
10073 {
10074 opts_type |= OPTS_TYPE_ST_HEX;
10075 }
10076 else
10077 {
10078 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10079
10080 return (-1);
10081 }
10082 }
10083
10084 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10085 | (salt_type == SALT_TYPE_EXTERN)
10086 | (salt_type == SALT_TYPE_EMBEDDED)
10087 | (salt_type == SALT_TYPE_VIRTUAL));
10088
10089 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10090
10091 data.hash_type = hash_type;
10092 data.attack_mode = attack_mode;
10093 data.attack_kern = attack_kern;
10094 data.attack_exec = attack_exec;
10095 data.kern_type = kern_type;
10096 data.opts_type = opts_type;
10097 data.dgst_size = dgst_size;
10098 data.salt_type = salt_type;
10099 data.isSalted = isSalted;
10100 data.sort_by_digest = sort_by_digest;
10101 data.dgst_pos0 = dgst_pos0;
10102 data.dgst_pos1 = dgst_pos1;
10103 data.dgst_pos2 = dgst_pos2;
10104 data.dgst_pos3 = dgst_pos3;
10105
10106 esalt_size = 0;
10107
10108 switch (hash_mode)
10109 {
10110 case 2500: esalt_size = sizeof (wpa_t); break;
10111 case 5300: esalt_size = sizeof (ikepsk_t); break;
10112 case 5400: esalt_size = sizeof (ikepsk_t); break;
10113 case 5500: esalt_size = sizeof (netntlm_t); break;
10114 case 5600: esalt_size = sizeof (netntlm_t); break;
10115 case 6211:
10116 case 6212:
10117 case 6213:
10118 case 6221:
10119 case 6222:
10120 case 6223:
10121 case 6231:
10122 case 6232:
10123 case 6233:
10124 case 6241:
10125 case 6242:
10126 case 6243: esalt_size = sizeof (tc_t); break;
10127 case 6600: esalt_size = sizeof (agilekey_t); break;
10128 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10129 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10130 case 7300: esalt_size = sizeof (rakp_t); break;
10131 case 7500: esalt_size = sizeof (krb5pa_t); break;
10132 case 8200: esalt_size = sizeof (cloudkey_t); break;
10133 case 8800: esalt_size = sizeof (androidfde_t); break;
10134 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10135 case 9400: esalt_size = sizeof (office2007_t); break;
10136 case 9500: esalt_size = sizeof (office2010_t); break;
10137 case 9600: esalt_size = sizeof (office2013_t); break;
10138 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10139 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10140 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10141 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10142 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10143 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10144 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10145 case 10200: esalt_size = sizeof (cram_md5_t); break;
10146 case 10400: esalt_size = sizeof (pdf_t); break;
10147 case 10410: esalt_size = sizeof (pdf_t); break;
10148 case 10420: esalt_size = sizeof (pdf_t); break;
10149 case 10500: esalt_size = sizeof (pdf_t); break;
10150 case 10600: esalt_size = sizeof (pdf_t); break;
10151 case 10700: esalt_size = sizeof (pdf_t); break;
10152 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10153 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10154 case 11400: esalt_size = sizeof (sip_t); break;
10155 case 11600: esalt_size = sizeof (seven_zip_t); break;
10156 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10157 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10158 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10159 case 13000: esalt_size = sizeof (rar5_t); break;
10160 }
10161
10162 data.esalt_size = esalt_size;
10163
10164 /**
10165 * choose dictionary parser
10166 */
10167
10168 if (hash_type == HASH_TYPE_LM)
10169 {
10170 get_next_word_func = get_next_word_lm;
10171 }
10172 else if (opts_type & OPTS_TYPE_PT_UPPER)
10173 {
10174 get_next_word_func = get_next_word_uc;
10175 }
10176 else
10177 {
10178 get_next_word_func = get_next_word_std;
10179 }
10180
10181 /**
10182 * dictstat
10183 */
10184
10185 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10186
10187 #ifdef _POSIX
10188 size_t dictstat_nmemb = 0;
10189 #endif
10190
10191 #ifdef _WIN
10192 uint dictstat_nmemb = 0;
10193 #endif
10194
10195 char dictstat[256] = { 0 };
10196
10197 FILE *dictstat_fp = NULL;
10198
10199 if (keyspace == 0)
10200 {
10201 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10202
10203 dictstat_fp = fopen (dictstat, "rb");
10204
10205 if (dictstat_fp)
10206 {
10207 #ifdef _POSIX
10208 struct stat tmpstat;
10209
10210 fstat (fileno (dictstat_fp), &tmpstat);
10211 #endif
10212
10213 #ifdef _WIN
10214 struct stat64 tmpstat;
10215
10216 _fstat64 (fileno (dictstat_fp), &tmpstat);
10217 #endif
10218
10219 if (tmpstat.st_mtime < COMPTIME)
10220 {
10221 /* with v0.15 the format changed so we have to ensure user is using a good version
10222 since there is no version-header in the dictstat file */
10223
10224 fclose (dictstat_fp);
10225
10226 unlink (dictstat);
10227 }
10228 else
10229 {
10230 while (!feof (dictstat_fp))
10231 {
10232 dictstat_t d;
10233
10234 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10235
10236 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10237
10238 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10239 {
10240 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10241
10242 return -1;
10243 }
10244 }
10245
10246 fclose (dictstat_fp);
10247 }
10248 }
10249 }
10250
10251 /**
10252 * potfile
10253 */
10254
10255 char potfile[256] = { 0 };
10256
10257 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10258
10259 data.pot_fp = NULL;
10260
10261 FILE *out_fp = NULL;
10262 FILE *pot_fp = NULL;
10263
10264 if (show == 1 || left == 1)
10265 {
10266 pot_fp = fopen (potfile, "rb");
10267
10268 if (pot_fp == NULL)
10269 {
10270 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10271
10272 return (-1);
10273 }
10274
10275 if (outfile != NULL)
10276 {
10277 if ((out_fp = fopen (outfile, "ab")) == NULL)
10278 {
10279 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10280
10281 fclose (pot_fp);
10282
10283 return (-1);
10284 }
10285 }
10286 else
10287 {
10288 out_fp = stdout;
10289 }
10290 }
10291 else
10292 {
10293 if (potfile_disable == 0)
10294 {
10295 pot_fp = fopen (potfile, "ab");
10296
10297 if (pot_fp == NULL)
10298 {
10299 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10300
10301 return (-1);
10302 }
10303
10304 data.pot_fp = pot_fp;
10305 }
10306 }
10307
10308 pot_t *pot = NULL;
10309
10310 uint pot_cnt = 0;
10311 uint pot_avail = 0;
10312
10313 if (show == 1 || left == 1)
10314 {
10315 SUPPRESS_OUTPUT = 1;
10316
10317 pot_avail = count_lines (pot_fp);
10318
10319 rewind (pot_fp);
10320
10321 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10322
10323 uint pot_hashes_avail = 0;
10324
10325 uint line_num = 0;
10326
10327 while (!feof (pot_fp))
10328 {
10329 line_num++;
10330
10331 char line_buf[BUFSIZ] = { 0 };
10332
10333 int line_len = fgetl (pot_fp, line_buf);
10334
10335 if (line_len == 0) continue;
10336
10337 char *plain_buf = line_buf + line_len;
10338
10339 pot_t *pot_ptr = &pot[pot_cnt];
10340
10341 hash_t *hashes_buf = &pot_ptr->hash;
10342
10343 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10344 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10345
10346 if (pot_cnt == pot_hashes_avail)
10347 {
10348 uint pos = 0;
10349
10350 for (pos = 0; pos < INCR_POT; pos++)
10351 {
10352 if ((pot_cnt + pos) >= pot_avail) break;
10353
10354 pot_t *tmp_pot = &pot[pot_cnt + pos];
10355
10356 hash_t *tmp_hash = &tmp_pot->hash;
10357
10358 tmp_hash->digest = mymalloc (dgst_size);
10359
10360 if (isSalted)
10361 {
10362 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10363 }
10364
10365 if (esalt_size)
10366 {
10367 tmp_hash->esalt = mymalloc (esalt_size);
10368 }
10369
10370 pot_hashes_avail++;
10371 }
10372 }
10373
10374 int plain_len = 0;
10375
10376 int parser_status;
10377
10378 int iter = MAX_CUT_TRIES;
10379
10380 do
10381 {
10382 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10383 {
10384 if (line_buf[i] == ':')
10385 {
10386 line_len--;
10387
10388 break;
10389 }
10390 }
10391
10392 if (data.hash_mode != 2500)
10393 {
10394 parser_status = parse_func (line_buf, line_len, hashes_buf);
10395 }
10396 else
10397 {
10398 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10399
10400 if (line_len > max_salt_size)
10401 {
10402 parser_status = PARSER_GLOBAL_LENGTH;
10403 }
10404 else
10405 {
10406 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10407
10408 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10409
10410 hashes_buf->salt->salt_len = line_len;
10411
10412 parser_status = PARSER_OK;
10413 }
10414 }
10415
10416 // if NOT parsed without error, we add the ":" to the plain
10417
10418 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10419 {
10420 plain_len++;
10421 plain_buf--;
10422 }
10423
10424 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10425
10426 if (parser_status < PARSER_GLOBAL_ZERO)
10427 {
10428 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10429
10430 continue;
10431 }
10432
10433 if (plain_len >= 255) continue;
10434
10435 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10436
10437 pot_ptr->plain_len = plain_len;
10438
10439 pot_cnt++;
10440 }
10441
10442 fclose (pot_fp);
10443
10444 SUPPRESS_OUTPUT = 0;
10445
10446 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10447 }
10448
10449 /**
10450 * word len
10451 */
10452
10453 uint pw_min = PW_MIN;
10454 uint pw_max = PW_MAX;
10455
10456 switch (hash_mode)
10457 {
10458 case 400: if (pw_max > 40) pw_max = 40;
10459 break;
10460 case 500: if (pw_max > 16) pw_max = 16;
10461 break;
10462 case 1500: if (pw_max > 8) pw_max = 8;
10463 break;
10464 case 1600: if (pw_max > 16) pw_max = 16;
10465 break;
10466 case 1800: if (pw_max > 16) pw_max = 16;
10467 break;
10468 case 2100: if (pw_max > 16) pw_max = 16;
10469 break;
10470 case 2500: if (pw_min < 8) pw_min = 8;
10471 break;
10472 case 3000: if (pw_max > 7) pw_max = 7;
10473 break;
10474 case 5200: if (pw_max > 24) pw_max = 24;
10475 break;
10476 case 5800: if (pw_max > 16) pw_max = 16;
10477 break;
10478 case 6300: if (pw_max > 16) pw_max = 16;
10479 break;
10480 case 7400: if (pw_max > 16) pw_max = 16;
10481 break;
10482 case 7900: if (pw_max > 48) pw_max = 48;
10483 break;
10484 case 8500: if (pw_max > 8) pw_max = 8;
10485 break;
10486 case 8600: if (pw_max > 16) pw_max = 16;
10487 break;
10488 case 9710: pw_min = 5;
10489 pw_max = 5;
10490 break;
10491 case 9810: pw_min = 5;
10492 pw_max = 5;
10493 break;
10494 case 10410: pw_min = 5;
10495 pw_max = 5;
10496 break;
10497 case 10300: if (pw_max < 3) pw_min = 3;
10498 if (pw_max > 40) pw_max = 40;
10499 break;
10500 case 10500: if (pw_max < 3) pw_min = 3;
10501 if (pw_max > 40) pw_max = 40;
10502 break;
10503 case 10700: if (pw_max > 16) pw_max = 16;
10504 break;
10505 case 11300: if (pw_max > 40) pw_max = 40;
10506 break;
10507 case 12500: if (pw_max > 20) pw_max = 20;
10508 break;
10509 case 12800: if (pw_max > 24) pw_max = 24;
10510 break;
10511 }
10512
10513 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10514 {
10515 switch (attack_kern)
10516 {
10517 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10518 break;
10519 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10520 break;
10521 }
10522 }
10523
10524 /**
10525 * charsets : keep them together for more easy maintainnce
10526 */
10527
10528 cs_t mp_sys[6] = { { { 0 }, 0 } };
10529 cs_t mp_usr[4] = { { { 0 }, 0 } };
10530
10531 mp_setup_sys (mp_sys);
10532
10533 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10534 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10535 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10536 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10537
10538 /**
10539 * load hashes, part I: find input mode, count hashes
10540 */
10541
10542 uint hashlist_mode = 0;
10543 uint hashlist_format = HLFMT_HASHCAT;
10544
10545 uint hashes_avail = 0;
10546
10547 if (benchmark == 0)
10548 {
10549 struct stat f;
10550
10551 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10552
10553 if ((hash_mode == 2500) ||
10554 (hash_mode == 5200) ||
10555 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10556 (hash_mode == 9000))
10557 {
10558 hashlist_mode = HL_MODE_ARG;
10559
10560 char *hashfile = myargv[optind];
10561
10562 data.hashfile = hashfile;
10563
10564 logfile_top_var_string ("target", hashfile);
10565 }
10566
10567 if (hashlist_mode == HL_MODE_ARG)
10568 {
10569 if (hash_mode == 2500)
10570 {
10571 struct stat st;
10572
10573 if (stat (data.hashfile, &st) == -1)
10574 {
10575 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10576
10577 return (-1);
10578 }
10579
10580 hashes_avail = st.st_size / sizeof (hccap_t);
10581 }
10582 else
10583 {
10584 hashes_avail = 1;
10585 }
10586 }
10587 else if (hashlist_mode == HL_MODE_FILE)
10588 {
10589 char *hashfile = myargv[optind];
10590
10591 data.hashfile = hashfile;
10592
10593 logfile_top_var_string ("target", hashfile);
10594
10595 FILE *fp = NULL;
10596
10597 if ((fp = fopen (hashfile, "rb")) == NULL)
10598 {
10599 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10600
10601 return (-1);
10602 }
10603
10604 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10605
10606 hashes_avail = count_lines (fp);
10607
10608 rewind (fp);
10609
10610 if (hashes_avail == 0)
10611 {
10612 log_error ("ERROR: hashfile is empty or corrupt");
10613
10614 fclose (fp);
10615
10616 return (-1);
10617 }
10618
10619 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10620
10621 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10622 {
10623 log_error ("ERROR: remove not supported in native hashfile-format mode");
10624
10625 fclose (fp);
10626
10627 return (-1);
10628 }
10629
10630 fclose (fp);
10631 }
10632 }
10633 else
10634 {
10635 hashlist_mode = HL_MODE_ARG;
10636
10637 hashes_avail = 1;
10638 }
10639
10640 if (hash_mode == 3000) hashes_avail *= 2;
10641
10642 data.hashlist_mode = hashlist_mode;
10643 data.hashlist_format = hashlist_format;
10644
10645 logfile_top_uint (hashlist_mode);
10646 logfile_top_uint (hashlist_format);
10647
10648 /**
10649 * load hashes, part II: allocate required memory, set pointers
10650 */
10651
10652 hash_t *hashes_buf = NULL;
10653 void *digests_buf = NULL;
10654 salt_t *salts_buf = NULL;
10655 void *esalts_buf = NULL;
10656
10657 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10658
10659 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10660
10661 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10662 {
10663 u32 hash_pos;
10664
10665 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10666 {
10667 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10668
10669 hashes_buf[hash_pos].hash_info = hash_info;
10670
10671 if (username && (remove || show || left))
10672 {
10673 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10674 }
10675
10676 if (benchmark)
10677 {
10678 hash_info->orighash = (char *) mymalloc (256);
10679 }
10680 }
10681 }
10682
10683 if (isSalted)
10684 {
10685 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10686
10687 if (esalt_size)
10688 {
10689 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10690 }
10691 }
10692 else
10693 {
10694 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10695 }
10696
10697 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10698 {
10699 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10700
10701 if (isSalted)
10702 {
10703 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10704
10705 if (esalt_size)
10706 {
10707 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10708 }
10709 }
10710 else
10711 {
10712 hashes_buf[hash_pos].salt = &salts_buf[0];
10713 }
10714 }
10715
10716 /**
10717 * load hashes, part III: parse hashes or generate them if benchmark
10718 */
10719
10720 uint hashes_cnt = 0;
10721
10722 if (benchmark == 0)
10723 {
10724 if (keyspace == 1)
10725 {
10726 // useless to read hash file for keyspace, cheat a little bit w/ optind
10727 }
10728 else if (hashes_avail == 0)
10729 {
10730 }
10731 else if (hashlist_mode == HL_MODE_ARG)
10732 {
10733 char *input_buf = myargv[optind];
10734
10735 uint input_len = strlen (input_buf);
10736
10737 logfile_top_var_string ("target", input_buf);
10738
10739 char *hash_buf = NULL;
10740 int hash_len = 0;
10741
10742 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10743
10744 if (hash_len)
10745 {
10746 if (opts_type & OPTS_TYPE_HASH_COPY)
10747 {
10748 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10749
10750 hash_info_tmp->orighash = mystrdup (hash_buf);
10751 }
10752
10753 if (isSalted)
10754 {
10755 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10756 }
10757
10758 int parser_status = PARSER_OK;
10759
10760 if (hash_mode == 2500)
10761 {
10762 if (hash_len == 0)
10763 {
10764 log_error ("ERROR: hccap file not specified");
10765
10766 return (-1);
10767 }
10768
10769 hashlist_mode = HL_MODE_FILE;
10770
10771 data.hashlist_mode = hashlist_mode;
10772
10773 FILE *fp = fopen (hash_buf, "rb");
10774
10775 if (fp == NULL)
10776 {
10777 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10778
10779 return (-1);
10780 }
10781
10782 if (hashes_avail < 1)
10783 {
10784 log_error ("ERROR: hccap file is empty or corrupt");
10785
10786 fclose (fp);
10787
10788 return (-1);
10789 }
10790
10791 uint hccap_size = sizeof (hccap_t);
10792
10793 char *in = (char *) mymalloc (hccap_size);
10794
10795 while (!feof (fp))
10796 {
10797 int n = fread (in, hccap_size, 1, fp);
10798
10799 if (n != 1)
10800 {
10801 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10802
10803 break;
10804 }
10805
10806 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10807
10808 if (parser_status != PARSER_OK)
10809 {
10810 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10811
10812 continue;
10813 }
10814
10815 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10816
10817 if ((show == 1) || (left == 1))
10818 {
10819 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10820
10821 char *salt_ptr = (char *) tmp_salt->salt_buf;
10822
10823 int cur_pos = tmp_salt->salt_len;
10824 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10825
10826 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10827
10828 u8 *pke_ptr = (u8 *) wpa->pke;
10829
10830 // do the appending task
10831
10832 snprintf (salt_ptr + cur_pos,
10833 rem_len,
10834 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10835 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10836 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10837
10838
10839 // memset () the remaining part of the salt
10840
10841 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10842 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10843
10844 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10845
10846 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10847 }
10848
10849 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);
10850 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);
10851
10852 hashes_cnt++;
10853 }
10854
10855 fclose (fp);
10856
10857 myfree (in);
10858 }
10859 else if (hash_mode == 3000)
10860 {
10861 if (hash_len == 32)
10862 {
10863 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10864
10865 hash_t *lm_hash_left = NULL;
10866
10867 if (parser_status == PARSER_OK)
10868 {
10869 lm_hash_left = &hashes_buf[hashes_cnt];
10870
10871 hashes_cnt++;
10872 }
10873 else
10874 {
10875 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10876 }
10877
10878 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10879
10880 hash_t *lm_hash_right = NULL;
10881
10882 if (parser_status == PARSER_OK)
10883 {
10884 lm_hash_right = &hashes_buf[hashes_cnt];
10885
10886 hashes_cnt++;
10887 }
10888 else
10889 {
10890 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10891 }
10892
10893 // show / left
10894
10895 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10896 {
10897 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);
10898 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);
10899 }
10900 }
10901 else
10902 {
10903 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10904
10905 if (parser_status == PARSER_OK)
10906 {
10907 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10908 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10909 }
10910
10911 if (parser_status == PARSER_OK)
10912 {
10913 hashes_cnt++;
10914 }
10915 else
10916 {
10917 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10918 }
10919 }
10920 }
10921 else
10922 {
10923 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10924
10925 if (parser_status == PARSER_OK)
10926 {
10927 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10928 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10929 }
10930
10931 if (parser_status == PARSER_OK)
10932 {
10933 hashes_cnt++;
10934 }
10935 else
10936 {
10937 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10938 }
10939 }
10940 }
10941 }
10942 else if (hashlist_mode == HL_MODE_FILE)
10943 {
10944 char *hashfile = data.hashfile;
10945
10946 FILE *fp;
10947
10948 if ((fp = fopen (hashfile, "rb")) == NULL)
10949 {
10950 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10951
10952 return (-1);
10953 }
10954
10955 uint line_num = 0;
10956
10957 while (!feof (fp))
10958 {
10959 line_num++;
10960
10961 char line_buf[BUFSIZ] = { 0 };
10962
10963 int line_len = fgetl (fp, line_buf);
10964
10965 if (line_len == 0) continue;
10966
10967 char *hash_buf = NULL;
10968 int hash_len = 0;
10969
10970 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10971
10972 if (username)
10973 {
10974 char *user_buf = NULL;
10975 int user_len = 0;
10976
10977 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10978
10979 if (remove || show)
10980 {
10981 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10982
10983 *user = (user_t *) mymalloc (sizeof (user_t));
10984
10985 user_t *user_ptr = *user;
10986
10987 if (user_buf != NULL)
10988 {
10989 user_ptr->user_name = mystrdup (user_buf);
10990 }
10991 else
10992 {
10993 user_ptr->user_name = mystrdup ("");
10994 }
10995
10996 user_ptr->user_len = user_len;
10997 }
10998 }
10999
11000 if (opts_type & OPTS_TYPE_HASH_COPY)
11001 {
11002 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11003
11004 hash_info_tmp->orighash = mystrdup (hash_buf);
11005 }
11006
11007 if (isSalted)
11008 {
11009 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11010 }
11011
11012 if (hash_mode == 3000)
11013 {
11014 if (hash_len == 32)
11015 {
11016 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11017
11018 if (parser_status < PARSER_GLOBAL_ZERO)
11019 {
11020 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11021
11022 continue;
11023 }
11024
11025 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11026
11027 hashes_cnt++;
11028
11029 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11030
11031 if (parser_status < PARSER_GLOBAL_ZERO)
11032 {
11033 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11034
11035 continue;
11036 }
11037
11038 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11039
11040 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);
11041
11042 hashes_cnt++;
11043
11044 // show / left
11045
11046 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);
11047 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);
11048 }
11049 else
11050 {
11051 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11052
11053 if (parser_status < PARSER_GLOBAL_ZERO)
11054 {
11055 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11056
11057 continue;
11058 }
11059
11060 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);
11061
11062 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11063 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11064
11065 hashes_cnt++;
11066 }
11067 }
11068 else
11069 {
11070 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11071
11072 if (parser_status < PARSER_GLOBAL_ZERO)
11073 {
11074 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11075
11076 continue;
11077 }
11078
11079 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);
11080
11081 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11082 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11083
11084 hashes_cnt++;
11085 }
11086 }
11087
11088 fclose (fp);
11089
11090 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11091
11092 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11093 }
11094 }
11095 else
11096 {
11097 if (isSalted)
11098 {
11099 hashes_buf[0].salt->salt_len = 8;
11100
11101 // special salt handling
11102
11103 switch (hash_mode)
11104 {
11105 case 1500: hashes_buf[0].salt->salt_len = 2;
11106 break;
11107 case 1731: hashes_buf[0].salt->salt_len = 4;
11108 break;
11109 case 2410: hashes_buf[0].salt->salt_len = 4;
11110 break;
11111 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11112 break;
11113 case 3100: hashes_buf[0].salt->salt_len = 1;
11114 break;
11115 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11116 break;
11117 case 5800: hashes_buf[0].salt->salt_len = 16;
11118 break;
11119 case 6800: hashes_buf[0].salt->salt_len = 32;
11120 break;
11121 case 8400: hashes_buf[0].salt->salt_len = 40;
11122 break;
11123 case 8800: hashes_buf[0].salt->salt_len = 16;
11124 break;
11125 case 8900: hashes_buf[0].salt->salt_len = 16;
11126 hashes_buf[0].salt->scrypt_N = 1024;
11127 hashes_buf[0].salt->scrypt_r = 1;
11128 hashes_buf[0].salt->scrypt_p = 1;
11129 break;
11130 case 9100: hashes_buf[0].salt->salt_len = 16;
11131 break;
11132 case 9300: hashes_buf[0].salt->salt_len = 14;
11133 hashes_buf[0].salt->scrypt_N = 16384;
11134 hashes_buf[0].salt->scrypt_r = 1;
11135 hashes_buf[0].salt->scrypt_p = 1;
11136 break;
11137 case 9400: hashes_buf[0].salt->salt_len = 16;
11138 break;
11139 case 9500: hashes_buf[0].salt->salt_len = 16;
11140 break;
11141 case 9600: hashes_buf[0].salt->salt_len = 16;
11142 break;
11143 case 9700: hashes_buf[0].salt->salt_len = 16;
11144 break;
11145 case 9710: hashes_buf[0].salt->salt_len = 16;
11146 break;
11147 case 9720: hashes_buf[0].salt->salt_len = 16;
11148 break;
11149 case 9800: hashes_buf[0].salt->salt_len = 16;
11150 break;
11151 case 9810: hashes_buf[0].salt->salt_len = 16;
11152 break;
11153 case 9820: hashes_buf[0].salt->salt_len = 16;
11154 break;
11155 case 10300: hashes_buf[0].salt->salt_len = 12;
11156 break;
11157 case 11500: hashes_buf[0].salt->salt_len = 4;
11158 break;
11159 case 11600: hashes_buf[0].salt->salt_len = 4;
11160 break;
11161 case 12400: hashes_buf[0].salt->salt_len = 4;
11162 break;
11163 case 12500: hashes_buf[0].salt->salt_len = 8;
11164 break;
11165 case 12600: hashes_buf[0].salt->salt_len = 64;
11166 break;
11167 }
11168
11169 // special esalt handling
11170
11171 switch (hash_mode)
11172 {
11173 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11174 break;
11175 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11176 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11177 break;
11178 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11179 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11180 break;
11181 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11182 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11183 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11184 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11185 break;
11186 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11187 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11188 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11189 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11190 break;
11191 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11192 break;
11193 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11194 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11195 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11196 break;
11197 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11198 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11199 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11200 break;
11201 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11202 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11203 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11204 break;
11205 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11206 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11207 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11208 break;
11209 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11210 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11211 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11212 break;
11213 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11214 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11215 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11216 break;
11217 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11218 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11219 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11220 break;
11221 }
11222 }
11223
11224 // set hashfile
11225
11226 switch (hash_mode)
11227 {
11228 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11229 break;
11230 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11231 break;
11232 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11233 break;
11234 case 6211:
11235 case 6212:
11236 case 6213:
11237 case 6221:
11238 case 6222:
11239 case 6223:
11240 case 6231:
11241 case 6232:
11242 case 6233:
11243 case 6241:
11244 case 6242:
11245 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11246 break;
11247 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11248 break;
11249 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11250 break;
11251 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11252 break;
11253 }
11254
11255 // set default iterations
11256
11257 switch (hash_mode)
11258 {
11259 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11260 break;
11261 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11262 break;
11263 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11264 break;
11265 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11266 break;
11267 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11268 break;
11269 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11270 break;
11271 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11272 break;
11273 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11274 break;
11275 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11276 break;
11277 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11278 break;
11279 case 6211:
11280 case 6212:
11281 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11282 break;
11283 case 6221:
11284 case 6222:
11285 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11286 break;
11287 case 6231:
11288 case 6232:
11289 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11290 break;
11291 case 6241:
11292 case 6242:
11293 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11294 break;
11295 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11296 break;
11297 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11298 break;
11299 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11300 break;
11301 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11302 break;
11303 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11304 break;
11305 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11306 break;
11307 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11308 break;
11309 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11310 break;
11311 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11312 break;
11313 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11314 break;
11315 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11316 break;
11317 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11318 break;
11319 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11320 break;
11321 case 8900: hashes_buf[0].salt->salt_iter = 1;
11322 break;
11323 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11324 break;
11325 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11326 break;
11327 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11328 break;
11329 case 9300: hashes_buf[0].salt->salt_iter = 1;
11330 break;
11331 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11332 break;
11333 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11334 break;
11335 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11336 break;
11337 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11338 break;
11339 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11340 break;
11341 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11342 break;
11343 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11344 break;
11345 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11346 break;
11347 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11348 break;
11349 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11350 break;
11351 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11352 break;
11353 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11354 break;
11355 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11356 break;
11357 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11358 break;
11359 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11360 break;
11361 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11362 break;
11363 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11364 break;
11365 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11366 break;
11367 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11368 break;
11369 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11370 break;
11371 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11372 break;
11373 }
11374
11375 hashes_cnt = 1;
11376 }
11377
11378 if (show == 1 || left == 1)
11379 {
11380 for (uint i = 0; i < pot_cnt; i++)
11381 {
11382 pot_t *pot_ptr = &pot[i];
11383
11384 hash_t *hashes_buf = &pot_ptr->hash;
11385
11386 local_free (hashes_buf->digest);
11387
11388 if (isSalted)
11389 {
11390 local_free (hashes_buf->salt);
11391 }
11392 }
11393
11394 local_free (pot);
11395
11396 if (data.quiet == 0) log_info_nn ("");
11397
11398 return (0);
11399 }
11400
11401 if (keyspace == 0)
11402 {
11403 if (hashes_cnt == 0)
11404 {
11405 log_error ("ERROR: No hashes loaded");
11406
11407 return (-1);
11408 }
11409 }
11410
11411 /**
11412 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11413 */
11414
11415 if (data.outfile != NULL)
11416 {
11417 if (data.hashfile != NULL)
11418 {
11419 #ifdef _POSIX
11420 struct stat tmpstat_outfile;
11421 struct stat tmpstat_hashfile;
11422 #endif
11423
11424 #ifdef _WIN
11425 struct stat64 tmpstat_outfile;
11426 struct stat64 tmpstat_hashfile;
11427 #endif
11428
11429 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11430
11431 if (tmp_outfile_fp)
11432 {
11433 #ifdef _POSIX
11434 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11435 #endif
11436
11437 #ifdef _WIN
11438 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11439 #endif
11440
11441 fclose (tmp_outfile_fp);
11442 }
11443
11444 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11445
11446 if (tmp_hashfile_fp)
11447 {
11448 #ifdef _POSIX
11449 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11450 #endif
11451
11452 #ifdef _WIN
11453 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11454 #endif
11455
11456 fclose (tmp_hashfile_fp);
11457 }
11458
11459 if (tmp_outfile_fp && tmp_outfile_fp)
11460 {
11461 tmpstat_outfile.st_mode = 0;
11462 tmpstat_outfile.st_nlink = 0;
11463 tmpstat_outfile.st_uid = 0;
11464 tmpstat_outfile.st_gid = 0;
11465 tmpstat_outfile.st_rdev = 0;
11466 tmpstat_outfile.st_atime = 0;
11467
11468 tmpstat_hashfile.st_mode = 0;
11469 tmpstat_hashfile.st_nlink = 0;
11470 tmpstat_hashfile.st_uid = 0;
11471 tmpstat_hashfile.st_gid = 0;
11472 tmpstat_hashfile.st_rdev = 0;
11473 tmpstat_hashfile.st_atime = 0;
11474
11475 #ifdef _POSIX
11476 tmpstat_outfile.st_blksize = 0;
11477 tmpstat_outfile.st_blocks = 0;
11478
11479 tmpstat_hashfile.st_blksize = 0;
11480 tmpstat_hashfile.st_blocks = 0;
11481 #endif
11482
11483 #ifdef _POSIX
11484 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11485 {
11486 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11487
11488 return (-1);
11489 }
11490 #endif
11491
11492 #ifdef _WIN
11493 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11494 {
11495 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11496
11497 return (-1);
11498 }
11499 #endif
11500 }
11501 }
11502 }
11503
11504 /**
11505 * Remove duplicates
11506 */
11507
11508 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11509
11510 if (isSalted)
11511 {
11512 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11513 }
11514 else
11515 {
11516 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11517 }
11518
11519 uint hashes_cnt_orig = hashes_cnt;
11520
11521 hashes_cnt = 1;
11522
11523 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11524 {
11525 if (isSalted)
11526 {
11527 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11528 {
11529 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11530 }
11531 }
11532 else
11533 {
11534 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11535 }
11536
11537 if (hashes_pos > hashes_cnt)
11538 {
11539 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11540 }
11541
11542 hashes_cnt++;
11543 }
11544
11545 /**
11546 * Potfile removes
11547 */
11548
11549 uint potfile_remove_cracks = 0;
11550
11551 if (potfile_disable == 0)
11552 {
11553 hash_t hash_buf;
11554
11555 hash_buf.digest = mymalloc (dgst_size);
11556 hash_buf.salt = NULL;
11557 hash_buf.esalt = NULL;
11558 hash_buf.hash_info = NULL;
11559 hash_buf.cracked = 0;
11560
11561 if (isSalted)
11562 {
11563 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11564 }
11565
11566 if (esalt_size)
11567 {
11568 hash_buf.esalt = mymalloc (esalt_size);
11569 }
11570
11571 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11572
11573 // no solution for these special hash types (for instane because they use hashfile in output etc)
11574 if ((hash_mode != 5200) &&
11575 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11576 (hash_mode != 9000))
11577 {
11578 FILE *fp = fopen (potfile, "rb");
11579
11580 if (fp != NULL)
11581 {
11582 while (!feof (fp))
11583 {
11584 char line_buf[BUFSIZ] = { 0 };
11585
11586 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11587
11588 if (ptr == NULL) break;
11589
11590 int line_len = strlen (line_buf);
11591
11592 if (line_len == 0) continue;
11593
11594 int iter = MAX_CUT_TRIES;
11595
11596 for (int i = line_len - 1; i && iter; i--, line_len--)
11597 {
11598 if (line_buf[i] != ':') continue;
11599
11600 if (isSalted)
11601 {
11602 memset (hash_buf.salt, 0, sizeof (salt_t));
11603 }
11604
11605 hash_t *found = NULL;
11606
11607 if (hash_mode == 6800)
11608 {
11609 if (i < 48) // 48 = 12 * uint in salt_buf[]
11610 {
11611 // manipulate salt_buf
11612 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11613
11614 hash_buf.salt->salt_len = i;
11615
11616 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11617 }
11618 }
11619 else if (hash_mode == 2500)
11620 {
11621 if (i < 48) // 48 = 12 * uint in salt_buf[]
11622 {
11623 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11624 // manipulate salt_buf
11625
11626 // to be safe work with a copy (because of line_len loop, i etc)
11627
11628 char line_buf_cpy[BUFSIZ] = { 0 };
11629
11630 memcpy (line_buf_cpy, line_buf, i);
11631
11632 char *mac2_pos = strrchr (line_buf_cpy, ':');
11633
11634 if (mac2_pos == NULL) continue;
11635
11636 mac2_pos[0] = 0;
11637 mac2_pos++;
11638
11639 if (strlen (mac2_pos) != 12) continue;
11640
11641 char *mac1_pos = strrchr (line_buf_cpy, ':');
11642
11643 if (mac1_pos == NULL) continue;
11644
11645 mac1_pos[0] = 0;
11646 mac1_pos++;
11647
11648 if (strlen (mac1_pos) != 12) continue;
11649
11650 uint essid_length = mac1_pos - line_buf_cpy - 1;
11651
11652 // here we need the ESSID
11653 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11654
11655 hash_buf.salt->salt_len = essid_length;
11656
11657 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11658
11659 if (found)
11660 {
11661 wpa_t *wpa = (wpa_t *) found->esalt;
11662
11663 uint pke[25] = { 0 };
11664
11665 char *pke_ptr = (char *) pke;
11666
11667 for (uint i = 0; i < 25; i++)
11668 {
11669 pke[i] = byte_swap_32 (wpa->pke[i]);
11670 }
11671
11672 u8 mac1[6] = { 0 };
11673 u8 mac2[6] = { 0 };
11674
11675 memcpy (mac1, pke_ptr + 23, 6);
11676 memcpy (mac2, pke_ptr + 29, 6);
11677
11678 // compare hex string(s) vs binary MAC address(es)
11679
11680 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11681 {
11682 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11683 {
11684 found = NULL;
11685 break;
11686 }
11687 }
11688
11689 // early skip ;)
11690 if (!found) continue;
11691
11692 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11693 {
11694 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11695 {
11696 found = NULL;
11697 break;
11698 }
11699 }
11700 }
11701 }
11702 }
11703 else
11704 {
11705 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11706
11707 if (parser_status == PARSER_OK)
11708 {
11709 if (isSalted)
11710 {
11711 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11712 }
11713 else
11714 {
11715 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11716 }
11717 }
11718 }
11719
11720 if (found == NULL) continue;
11721
11722 if (!found->cracked) potfile_remove_cracks++;
11723
11724 found->cracked = 1;
11725
11726 if (found) break;
11727
11728 iter--;
11729 }
11730 }
11731
11732 fclose (fp);
11733 }
11734 }
11735
11736 if (esalt_size)
11737 {
11738 local_free (hash_buf.esalt);
11739 }
11740
11741 if (isSalted)
11742 {
11743 local_free (hash_buf.salt);
11744 }
11745
11746 local_free (hash_buf.digest);
11747 }
11748
11749 /**
11750 * Now generate all the buffers required for later
11751 */
11752
11753 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11754
11755 salt_t *salts_buf_new = NULL;
11756 void *esalts_buf_new = NULL;
11757
11758 if (isSalted)
11759 {
11760 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11761
11762 if (esalt_size)
11763 {
11764 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11765 }
11766 }
11767 else
11768 {
11769 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11770 }
11771
11772 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11773
11774 uint digests_cnt = hashes_cnt;
11775 uint digests_done = 0;
11776
11777 uint size_digests = digests_cnt * dgst_size;
11778 uint size_shown = digests_cnt * sizeof (uint);
11779
11780 uint *digests_shown = (uint *) mymalloc (size_shown);
11781 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11782
11783 uint salts_cnt = 0;
11784 uint salts_done = 0;
11785
11786 hashinfo_t **hash_info = NULL;
11787
11788 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11789 {
11790 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11791
11792 if (username && (remove || show))
11793 {
11794 uint user_pos;
11795
11796 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11797 {
11798 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11799
11800 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11801 }
11802 }
11803 }
11804
11805 uint *salts_shown = (uint *) mymalloc (size_shown);
11806
11807 salt_t *salt_buf;
11808
11809 {
11810 // copied from inner loop
11811
11812 salt_buf = &salts_buf_new[salts_cnt];
11813
11814 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11815
11816 if (esalt_size)
11817 {
11818 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11819 }
11820
11821 salt_buf->digests_cnt = 0;
11822 salt_buf->digests_done = 0;
11823 salt_buf->digests_offset = 0;
11824
11825 salts_cnt++;
11826 }
11827
11828 if (hashes_buf[0].cracked == 1)
11829 {
11830 digests_shown[0] = 1;
11831
11832 digests_done++;
11833
11834 salt_buf->digests_done++;
11835 }
11836
11837 salt_buf->digests_cnt++;
11838
11839 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11840
11841 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11842 {
11843 hash_info[0] = hashes_buf[0].hash_info;
11844 }
11845
11846 // copy from inner loop
11847
11848 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11849 {
11850 if (isSalted)
11851 {
11852 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11853 {
11854 salt_buf = &salts_buf_new[salts_cnt];
11855
11856 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11857
11858 if (esalt_size)
11859 {
11860 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11861 }
11862
11863 salt_buf->digests_cnt = 0;
11864 salt_buf->digests_done = 0;
11865 salt_buf->digests_offset = hashes_pos;
11866
11867 salts_cnt++;
11868 }
11869 }
11870
11871 if (hashes_buf[hashes_pos].cracked == 1)
11872 {
11873 digests_shown[hashes_pos] = 1;
11874
11875 digests_done++;
11876
11877 salt_buf->digests_done++;
11878 }
11879
11880 salt_buf->digests_cnt++;
11881
11882 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11883
11884 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11885 {
11886 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11887 }
11888 }
11889
11890 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11891 {
11892 salt_t *salt_buf = &salts_buf_new[salt_pos];
11893
11894 if (salt_buf->digests_done == salt_buf->digests_cnt)
11895 {
11896 salts_shown[salt_pos] = 1;
11897
11898 salts_done++;
11899 }
11900
11901 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11902 }
11903
11904 local_free (digests_buf);
11905 local_free (salts_buf);
11906 local_free (esalts_buf);
11907
11908 digests_buf = digests_buf_new;
11909 salts_buf = salts_buf_new;
11910 esalts_buf = esalts_buf_new;
11911
11912 local_free (hashes_buf);
11913
11914 /**
11915 * special modification not set from parser
11916 */
11917
11918 switch (hash_mode)
11919 {
11920 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11921 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11922 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11923 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11924 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11925 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11926 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11927 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11928 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11929 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11930 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11931 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11932 }
11933
11934 if (truecrypt_keyfiles)
11935 {
11936 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11937
11938 char *keyfiles = strdup (truecrypt_keyfiles);
11939
11940 char *keyfile = strtok (keyfiles, ",");
11941
11942 do
11943 {
11944 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
11945
11946 } while ((keyfile = strtok (NULL, ",")) != NULL);
11947
11948 free (keyfiles);
11949 }
11950
11951 data.digests_cnt = digests_cnt;
11952 data.digests_done = digests_done;
11953 data.digests_buf = digests_buf;
11954 data.digests_shown = digests_shown;
11955 data.digests_shown_tmp = digests_shown_tmp;
11956
11957 data.salts_cnt = salts_cnt;
11958 data.salts_done = salts_done;
11959 data.salts_buf = salts_buf;
11960 data.salts_shown = salts_shown;
11961
11962 data.esalts_buf = esalts_buf;
11963 data.hash_info = hash_info;
11964
11965 /**
11966 * Automatic Optimizers
11967 */
11968
11969 if (salts_cnt == 1)
11970 opti_type |= OPTI_TYPE_SINGLE_SALT;
11971
11972 if (digests_cnt == 1)
11973 opti_type |= OPTI_TYPE_SINGLE_HASH;
11974
11975 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11976 opti_type |= OPTI_TYPE_NOT_ITERATED;
11977
11978 if (attack_mode == ATTACK_MODE_BF)
11979 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11980
11981 data.opti_type = opti_type;
11982
11983 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11984 {
11985 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11986 {
11987 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11988 {
11989 if (opts_type & OPTS_TYPE_ST_ADD80)
11990 {
11991 opts_type &= ~OPTS_TYPE_ST_ADD80;
11992 opts_type |= OPTS_TYPE_PT_ADD80;
11993 }
11994
11995 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11996 {
11997 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11998 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11999 }
12000
12001 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12002 {
12003 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12004 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12005 }
12006 }
12007 }
12008 }
12009
12010 /**
12011 * Some algorithm, like descrypt, can benefit from JIT compilation
12012 */
12013
12014 int force_jit_compilation = -1;
12015
12016 if (hash_mode == 8900)
12017 {
12018 force_jit_compilation = 8900;
12019 }
12020 else if (hash_mode == 9300)
12021 {
12022 force_jit_compilation = 8900;
12023 }
12024 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12025 {
12026 force_jit_compilation = 1500;
12027 }
12028
12029 /**
12030 * generate bitmap tables
12031 */
12032
12033 const uint bitmap_shift1 = 5;
12034 const uint bitmap_shift2 = 13;
12035
12036 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12037
12038 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12039 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12040 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12041 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12042 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12043 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12044 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12045 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12046
12047 uint bitmap_bits;
12048 uint bitmap_nums;
12049 uint bitmap_mask;
12050 uint bitmap_size;
12051
12052 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12053 {
12054 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12055
12056 bitmap_nums = 1 << bitmap_bits;
12057
12058 bitmap_mask = bitmap_nums - 1;
12059
12060 bitmap_size = bitmap_nums * sizeof (uint);
12061
12062 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12063
12064 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;
12065 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;
12066
12067 break;
12068 }
12069
12070 bitmap_nums = 1 << bitmap_bits;
12071
12072 bitmap_mask = bitmap_nums - 1;
12073
12074 bitmap_size = bitmap_nums * sizeof (uint);
12075
12076 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);
12077 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);
12078
12079 /**
12080 * prepare quick rule
12081 */
12082
12083 data.rule_buf_l = rule_buf_l;
12084 data.rule_buf_r = rule_buf_r;
12085
12086 int rule_len_l = (int) strlen (rule_buf_l);
12087 int rule_len_r = (int) strlen (rule_buf_r);
12088
12089 data.rule_len_l = rule_len_l;
12090 data.rule_len_r = rule_len_r;
12091
12092 /**
12093 * load rules
12094 */
12095
12096 uint *all_kernel_rules_cnt = NULL;
12097
12098 kernel_rule_t **all_kernel_rules_buf = NULL;
12099
12100 if (rp_files_cnt)
12101 {
12102 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12103
12104 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12105 }
12106
12107 char rule_buf[BUFSIZ] = { 0 };
12108
12109 int rule_len = 0;
12110
12111 for (uint i = 0; i < rp_files_cnt; i++)
12112 {
12113 uint kernel_rules_avail = 0;
12114
12115 uint kernel_rules_cnt = 0;
12116
12117 kernel_rule_t *kernel_rules_buf = NULL;
12118
12119 char *rp_file = rp_files[i];
12120
12121 char in[BLOCK_SIZE] = { 0 };
12122 char out[BLOCK_SIZE] = { 0 };
12123
12124 FILE *fp = NULL;
12125
12126 uint rule_line = 0;
12127
12128 if ((fp = fopen (rp_file, "rb")) == NULL)
12129 {
12130 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12131
12132 return (-1);
12133 }
12134
12135 while (!feof (fp))
12136 {
12137 memset (rule_buf, 0, BUFSIZ);
12138
12139 rule_len = fgetl (fp, rule_buf);
12140
12141 rule_line++;
12142
12143 if (rule_len == 0) continue;
12144
12145 if (rule_buf[0] == '#') continue;
12146
12147 if (kernel_rules_avail == kernel_rules_cnt)
12148 {
12149 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12150
12151 kernel_rules_avail += INCR_RULES;
12152 }
12153
12154 memset (in, 0, BLOCK_SIZE);
12155 memset (out, 0, BLOCK_SIZE);
12156
12157 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12158
12159 if (result == -1)
12160 {
12161 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12162
12163 continue;
12164 }
12165
12166 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12167 {
12168 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12169
12170 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12171
12172 continue;
12173 }
12174
12175 /* its so slow
12176 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12177 {
12178 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12179
12180 continue;
12181 }
12182 */
12183
12184 kernel_rules_cnt++;
12185 }
12186
12187 fclose (fp);
12188
12189 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12190
12191 all_kernel_rules_buf[i] = kernel_rules_buf;
12192 }
12193
12194 /**
12195 * merge rules or automatic rule generator
12196 */
12197
12198 uint kernel_rules_cnt = 0;
12199
12200 kernel_rule_t *kernel_rules_buf = NULL;
12201
12202 if (attack_mode == ATTACK_MODE_STRAIGHT)
12203 {
12204 if (rp_files_cnt)
12205 {
12206 kernel_rules_cnt = 1;
12207
12208 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12209
12210 repeats[0] = kernel_rules_cnt;
12211
12212 for (uint i = 0; i < rp_files_cnt; i++)
12213 {
12214 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12215
12216 repeats[i + 1] = kernel_rules_cnt;
12217 }
12218
12219 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12220
12221 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12222
12223 for (uint i = 0; i < kernel_rules_cnt; i++)
12224 {
12225 uint out_pos = 0;
12226
12227 kernel_rule_t *out = &kernel_rules_buf[i];
12228
12229 for (uint j = 0; j < rp_files_cnt; j++)
12230 {
12231 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12232 uint in_pos;
12233
12234 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12235
12236 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12237 {
12238 if (out_pos == RULES_MAX - 1)
12239 {
12240 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12241
12242 break;
12243 }
12244
12245 out->cmds[out_pos] = in->cmds[in_pos];
12246 }
12247 }
12248 }
12249
12250 local_free (repeats);
12251 }
12252 else if (rp_gen)
12253 {
12254 uint kernel_rules_avail = 0;
12255
12256 while (kernel_rules_cnt < rp_gen)
12257 {
12258 if (kernel_rules_avail == kernel_rules_cnt)
12259 {
12260 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12261
12262 kernel_rules_avail += INCR_RULES;
12263 }
12264
12265 memset (rule_buf, 0, BLOCK_SIZE);
12266
12267 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12268
12269 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12270
12271 kernel_rules_cnt++;
12272 }
12273 }
12274 }
12275
12276 /**
12277 * generate NOP rules
12278 */
12279
12280 if (kernel_rules_cnt == 0)
12281 {
12282 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12283
12284 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12285
12286 kernel_rules_cnt++;
12287 }
12288
12289 data.kernel_rules_cnt = kernel_rules_cnt;
12290 data.kernel_rules_buf = kernel_rules_buf;
12291
12292 /**
12293 * OpenCL platforms: detect
12294 */
12295
12296 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12297 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12298
12299 cl_uint platforms_cnt = 0;
12300 cl_uint platform_devices_cnt = 0;
12301
12302 if (keyspace == 0)
12303 {
12304 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12305
12306 if (platforms_cnt == 0)
12307 {
12308 log_error ("ERROR: No OpenCL compatible platform found");
12309
12310 return (-1);
12311 }
12312 }
12313
12314 /**
12315 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12316 */
12317
12318 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12319 {
12320 cl_platform_id platform = platforms[platform_id];
12321
12322 char platform_vendor[INFOSZ] = { 0 };
12323
12324 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12325
12326 #ifdef HAVE_HWMON
12327 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12328 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12329 {
12330 // make sure that we do not directly control the fan for NVidia
12331
12332 gpu_temp_retain = 0;
12333
12334 data.gpu_temp_retain = gpu_temp_retain;
12335 }
12336 #endif // HAVE_NVML || HAVE_NVAPI
12337 #endif
12338 }
12339
12340 /**
12341 * OpenCL devices: simply push all devices from all platforms into the same device array
12342 */
12343
12344 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12345
12346 data.devices_param = devices_param;
12347
12348 uint devices_cnt = 0;
12349
12350 uint devices_active = 0;
12351
12352 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12353 {
12354 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12355
12356 cl_platform_id platform = platforms[platform_id];
12357
12358 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12359
12360 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12361 {
12362 size_t param_value_size = 0;
12363
12364 const uint device_id = devices_cnt;
12365
12366 hc_device_param_t *device_param = &data.devices_param[device_id];
12367
12368 device_param->device = platform_devices[platform_devices_id];
12369
12370 device_param->device_id = device_id;
12371
12372 device_param->platform_devices_id = platform_devices_id;
12373
12374 // device_type
12375
12376 cl_device_type device_type;
12377
12378 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12379
12380 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12381
12382 device_param->device_type = device_type;
12383
12384 // vendor_id
12385
12386 cl_uint vendor_id = 0;
12387
12388 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12389
12390 device_param->vendor_id = vendor_id;
12391
12392 // device_name
12393
12394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12395
12396 char *device_name = (char *) mymalloc (param_value_size);
12397
12398 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12399
12400 device_param->device_name = device_name;
12401
12402 // device_version
12403
12404 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12405
12406 char *device_version = (char *) mymalloc (param_value_size);
12407
12408 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12409
12410 device_param->device_version = device_version;
12411
12412 // device_opencl_version
12413
12414 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12415
12416 char *device_opencl_version = (char *) mymalloc (param_value_size);
12417
12418 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12419
12420 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12421
12422 myfree (device_opencl_version);
12423
12424 if (strstr (device_version, "pocl"))
12425 {
12426 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12427 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12428
12429 cl_uint vendor_id = VENDOR_ID_GENERIC;
12430
12431 device_param->vendor_id = vendor_id;
12432 }
12433
12434 // max_compute_units
12435
12436 cl_uint vector_width;
12437
12438 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12439 {
12440 #ifndef OSX
12441 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12442 #else
12443 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
12444 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12445 else
12446 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12447 #endif
12448
12449 int is_ti = 0;
12450
12451 const int device_name_len = strlen (device_name);
12452
12453 if (device_name[device_name_len - 2] == 't') is_ti++;
12454 if (device_name[device_name_len - 2] == 'T') is_ti++;
12455 if (device_name[device_name_len - 1] == 'i') is_ti++;
12456 if (device_name[device_name_len - 1] == 'I') is_ti++;
12457
12458 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12459 {
12460 // Yeah that's a super bad hack, but there's no other attribute we could use
12461
12462 if (vector_width < 2) vector_width *= 2;
12463 }
12464
12465 if (opti_type & OPTI_TYPE_USES_BITS_64)
12466 {
12467 if (vector_width > 1) vector_width /= 2;
12468 }
12469 }
12470 else
12471 {
12472 vector_width = opencl_vector_width;
12473 }
12474
12475 if (vector_width > 8) vector_width = 8;
12476
12477 device_param->vector_width = vector_width;
12478
12479 // max_compute_units
12480
12481 cl_uint device_processors;
12482
12483 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12484
12485 device_param->device_processors = device_processors;
12486
12487 // max_mem_alloc_size
12488
12489 cl_ulong device_maxmem_alloc;
12490
12491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12492
12493 device_param->device_maxmem_alloc = device_maxmem_alloc;
12494
12495 // max_mem_alloc_size
12496
12497 cl_ulong device_global_mem;
12498
12499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12500
12501 device_param->device_global_mem = device_global_mem;
12502
12503 // max_clock_frequency
12504
12505 cl_uint device_maxclock_frequency;
12506
12507 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12508
12509 device_param->device_maxclock_frequency = device_maxclock_frequency;
12510
12511 // skipped
12512
12513 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12514 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12515
12516 device_param->skipped = (skipped1 || skipped2);
12517
12518 // driver_version
12519 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12520
12521 char *driver_version = (char *) mymalloc (param_value_size);
12522
12523 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12524
12525 device_param->driver_version = driver_version;
12526
12527 // device_name_chksum
12528
12529 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12530
12531 #if __x86_64__
12532 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);
12533 #else
12534 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);
12535 #endif
12536
12537 uint device_name_digest[4] = { 0 };
12538
12539 md5_64 ((uint *) device_name_chksum, device_name_digest);
12540
12541 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12542
12543 device_param->device_name_chksum = device_name_chksum;
12544
12545 // device_processor_cores
12546
12547 if (device_type & CL_DEVICE_TYPE_CPU)
12548 {
12549 cl_uint device_processor_cores = 1;
12550
12551 device_param->device_processor_cores = device_processor_cores;
12552 }
12553
12554 if (device_type & CL_DEVICE_TYPE_GPU)
12555 {
12556 if (vendor_id == VENDOR_ID_AMD)
12557 {
12558 cl_uint device_processor_cores = 0;
12559
12560 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12561
12562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12563
12564 device_param->device_processor_cores = device_processor_cores;
12565 }
12566 else if (vendor_id == VENDOR_ID_NV)
12567 {
12568 cl_uint kernel_exec_timeout = 0;
12569
12570 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12571
12572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12573
12574 device_param->kernel_exec_timeout = kernel_exec_timeout;
12575
12576 cl_uint device_processor_cores = 0;
12577
12578 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12579
12580 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12581
12582 device_param->device_processor_cores = device_processor_cores;
12583
12584 cl_uint sm_minor = 0;
12585 cl_uint sm_major = 0;
12586
12587 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12588 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12589
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12591 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12592
12593 device_param->sm_minor = sm_minor;
12594 device_param->sm_major = sm_major;
12595 }
12596 else
12597 {
12598 cl_uint device_processor_cores = 1;
12599
12600 device_param->device_processor_cores = device_processor_cores;
12601 }
12602 }
12603
12604 // display results
12605
12606 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12607 {
12608 if (device_param->skipped == 0)
12609 {
12610 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12611 device_id + 1,
12612 device_name,
12613 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12614 (unsigned int) (device_global_mem / 1024 / 1024),
12615 (unsigned int) (device_maxclock_frequency),
12616 (unsigned int) device_processors);
12617 }
12618 else
12619 {
12620 log_info ("Device #%u: %s, skipped",
12621 device_id + 1,
12622 device_name);
12623 }
12624 }
12625
12626 // common driver check
12627
12628 if (device_param->skipped == 0)
12629 {
12630 if (strstr (device_version, "pocl"))
12631 {
12632 if (force == 0)
12633 {
12634 log_info ("");
12635 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12636 log_info ("You are STRONGLY encouraged not to use it");
12637 log_info ("You can use --force to override this but do not post error reports if you do so");
12638 log_info ("");
12639
12640 return (-1);
12641 }
12642 }
12643
12644 if (device_type & CL_DEVICE_TYPE_GPU)
12645 {
12646 if (vendor_id == VENDOR_ID_NV)
12647 {
12648 if (device_param->kernel_exec_timeout != 0)
12649 {
12650 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);
12651 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12652 }
12653 }
12654 else if (vendor_id == VENDOR_ID_AMD)
12655 {
12656 int catalyst_check = (force == 1) ? 0 : 1;
12657
12658 int catalyst_warn = 0;
12659
12660 int catalyst_broken = 0;
12661
12662 if (catalyst_check == 1)
12663 {
12664 catalyst_warn = 1;
12665
12666 // v14.9 and higher
12667 if (atoi (device_param->driver_version) >= 1573)
12668 {
12669 catalyst_warn = 0;
12670 }
12671
12672 catalyst_check = 0;
12673 }
12674
12675 if (catalyst_broken == 1)
12676 {
12677 log_info ("");
12678 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12679 log_info ("It will pass over cracked hashes and does not report them as cracked");
12680 log_info ("You are STRONGLY encouraged not to use it");
12681 log_info ("You can use --force to override this but do not post error reports if you do so");
12682 log_info ("");
12683
12684 return (-1);
12685 }
12686
12687 if (catalyst_warn == 1)
12688 {
12689 log_info ("");
12690 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12691 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12692 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12693 #ifdef _WIN
12694 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12695 #endif
12696 log_info ("You can use --force to override this but do not post error reports if you do so");
12697 log_info ("");
12698
12699 return (-1);
12700 }
12701 }
12702 }
12703
12704 /**
12705 * kernel accel and loops auto adjustment
12706 */
12707
12708 uint _kernel_accel = kernel_accel;
12709 uint _kernel_loops = kernel_loops;
12710
12711 #ifndef OSX
12712 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode);
12713 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode);
12714 #else
12715 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12716 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12717 #endif
12718
12719 if (workload_profile == 1)
12720 {
12721 _kernel_loops /= 8;
12722 _kernel_accel /= 4;
12723
12724 if (_kernel_loops == 0) _kernel_loops = 8;
12725 if (_kernel_accel == 0) _kernel_accel = 2;
12726 }
12727 else if (workload_profile == 3)
12728 {
12729 _kernel_loops *= 8;
12730 _kernel_accel *= 4;
12731
12732 if (_kernel_loops > 1024) _kernel_loops = 1024;
12733 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
12734 }
12735
12736 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
12737
12738 if (benchmark == 1 && benchmark_mode == 1)
12739 {
12740 _kernel_loops *= 8;
12741 _kernel_accel *= 4;
12742
12743 #ifdef OSX
12744 bool isCpu = device_param->device_type & CL_DEVICE_TYPE_CPU;
12745
12746 if (!isCpu)
12747 {
12748 if (hash_mode == 7100 || hash_mode == 8200 || hash_mode == 9600 || \
12749 hash_mode == 11300 || hash_mode == 11600 || hash_mode == 12200)
12750 {
12751 _kernel_accel = 1;
12752 }
12753 else if (hash_mode == 7200 || hash_mode == 9300 || hash_mode == 13000)
12754 {
12755 _kernel_accel = 2;
12756 }
12757 else if (hash_mode == 3200)
12758 {
12759 _kernel_loops = ROUNDS_BCRYPT / 2;
12760 }
12761 else if (hash_mode == 6231)
12762 {
12763 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12764 _kernel_accel = 1;
12765 }
12766 else if (hash_mode == 6241)
12767 {
12768 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12769 _kernel_accel = 1;
12770 }
12771 }
12772 else
12773 {
12774 if (hash_mode == 3200)
12775 {
12776 _kernel_loops = ROUNDS_BCRYPT;
12777 }
12778 else if (hash_mode == 6231)
12779 {
12780 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12781 _kernel_accel = 8;
12782 }
12783 else if (hash_mode == 6241)
12784 {
12785 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12786 _kernel_accel = 128;
12787 }
12788 }
12789 #endif
12790
12791 switch (hash_mode)
12792 {
12793 case 400: _kernel_loops = ROUNDS_PHPASS;
12794 _kernel_accel = 32;
12795 break;
12796 case 500: _kernel_loops = ROUNDS_MD5CRYPT;
12797 _kernel_accel = 32;
12798 break;
12799 case 501: _kernel_loops = ROUNDS_MD5CRYPT;
12800 _kernel_accel = 32;
12801 break;
12802 case 1600: _kernel_loops = ROUNDS_MD5CRYPT;
12803 _kernel_accel = 32;
12804 break;
12805 case 1800: _kernel_loops = ROUNDS_SHA512CRYPT;
12806 #ifndef OSX
12807 _kernel_accel = 16;
12808 #else
12809 if (isCpu) _kernel_accel = 16;
12810 #endif
12811 break;
12812 case 2100: _kernel_loops = ROUNDS_DCC2;
12813 _kernel_accel = 16;
12814 break;
12815 case 2500: _kernel_loops = ROUNDS_WPA2;
12816 #ifndef OSX
12817 _kernel_accel = 32;
12818 #else
12819 if (isCpu) _kernel_accel = 32;
12820 #endif
12821 break;
12822 case 3200: _kernel_accel = 8;
12823 #ifndef OSX
12824 _kernel_loops = ROUNDS_BCRYPT;
12825 #endif
12826 break;
12827 case 5200: _kernel_loops = ROUNDS_PSAFE3;
12828 _kernel_accel = 16;
12829 break;
12830 case 5800: _kernel_loops = ROUNDS_ANDROIDPIN;
12831 _kernel_accel = 16;
12832 break;
12833 case 6211: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12834 #ifndef OSX
12835 _kernel_accel = 64;
12836 #else
12837 if (isCpu) _kernel_accel = 64;
12838 #endif
12839 break;
12840 case 6212: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12841 _kernel_accel = 32;
12842 break;
12843 case 6213: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12844 _kernel_accel = 32;
12845 break;
12846 case 6221: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12847 _kernel_accel = 8;
12848 break;
12849 case 6222: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12850 _kernel_accel = 8;
12851 break;
12852 case 6223: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12853 _kernel_accel = 8;
12854 break;
12855 #ifndef OSX
12856 case 6231: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12857 _kernel_accel = 8;
12858 break;
12859 #endif
12860 case 6232: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12861 _kernel_accel = 8;
12862 break;
12863 case 6233: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12864 _kernel_accel = 8;
12865 break;
12866 #ifndef OSX
12867 case 6241: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12868 _kernel_accel = 128;
12869 break;
12870 #endif
12871 case 6242: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12872 _kernel_accel = 64;
12873 break;
12874 case 6243: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12875 _kernel_accel = 64;
12876 break;
12877 case 6300: _kernel_loops = ROUNDS_MD5CRYPT;
12878 _kernel_accel = 32;
12879 break;
12880 case 6700: _kernel_loops = ROUNDS_SHA1AIX;
12881 _kernel_accel = 128;
12882 break;
12883 case 6400: _kernel_loops = ROUNDS_SHA256AIX;
12884 _kernel_accel = 128;
12885 break;
12886 case 6500: _kernel_loops = ROUNDS_SHA512AIX;
12887 _kernel_accel = 32;
12888 break;
12889 case 6600: _kernel_loops = ROUNDS_AGILEKEY;
12890 _kernel_accel = 64;
12891 break;
12892 case 6800: _kernel_loops = ROUNDS_LASTPASS;
12893 #ifndef OSX
12894 _kernel_accel = 64;
12895 #else
12896 if (isCpu) _kernel_accel = 64;
12897 #endif
12898 break;
12899 case 7100: _kernel_loops = ROUNDS_SHA512OSX;
12900 #ifndef OSX
12901 _kernel_accel = 8;
12902 #endif
12903 break;
12904 case 7200: _kernel_loops = ROUNDS_GRUB;
12905 #ifndef OSX
12906 _kernel_accel = 16;
12907 #endif
12908 break;
12909 case 7400: _kernel_loops = ROUNDS_SHA256CRYPT;
12910 _kernel_accel = 8;
12911 break;
12912 case 7900: _kernel_loops = ROUNDS_DRUPAL7;
12913 #ifndef OSX
12914 _kernel_accel = 8;
12915 #else
12916 if (isCpu) _kernel_accel = 8;
12917 #endif
12918 break;
12919 case 8200: _kernel_loops = ROUNDS_CLOUDKEY;
12920 #ifndef OSX
12921 _kernel_accel = 8;
12922 #endif
12923 break;
12924 case 8800: _kernel_loops = ROUNDS_ANDROIDFDE;
12925 _kernel_accel = 32;
12926 break;
12927 case 8900: _kernel_loops = 1;
12928 _kernel_accel = 64;
12929 break;
12930 case 9000: _kernel_loops = ROUNDS_PSAFE2;
12931 _kernel_accel = 16;
12932 break;
12933 case 9100: _kernel_loops = ROUNDS_LOTUS8;
12934 #ifndef OSX
12935 _kernel_accel = 64;
12936 #else
12937 if (isCpu) _kernel_accel = 64;
12938 #endif
12939 break;
12940 case 9200: _kernel_loops = ROUNDS_CISCO8;
12941 #ifndef OSX
12942 _kernel_accel = 8;
12943 #else
12944 if (isCpu) _kernel_accel = 8;
12945 #endif
12946 break;
12947 case 9300: _kernel_loops = 1;
12948 #ifndef OSX
12949 _kernel_accel = 4;
12950 #endif
12951 break;
12952 case 9400: _kernel_loops = ROUNDS_OFFICE2007;
12953 #ifndef OSX
12954 _kernel_accel = 32;
12955 #else
12956 if (isCpu) _kernel_accel = 32;
12957 #endif
12958 break;
12959 case 9500: _kernel_loops = ROUNDS_OFFICE2010;
12960 #ifndef OSX
12961 _kernel_accel = 32;
12962 #else
12963 if (isCpu) _kernel_accel = 32;
12964 #endif
12965 break;
12966 case 9600: _kernel_loops = ROUNDS_OFFICE2013;
12967 #ifndef OSX
12968 _kernel_accel = 8;
12969 #endif
12970 break;
12971 case 10000: _kernel_loops = ROUNDS_DJANGOPBKDF2;
12972 #ifndef OSX
12973 _kernel_accel = 8;
12974 #else
12975 if (isCpu) _kernel_accel = 8;
12976 #endif
12977 break;
12978 case 10300: _kernel_loops = ROUNDS_SAPH_SHA1;
12979 _kernel_accel = 16;
12980 break;
12981 case 10500: _kernel_loops = ROUNDS_PDF14;
12982 _kernel_accel = 256;
12983 break;
12984 case 10700: _kernel_loops = ROUNDS_PDF17L8;
12985 _kernel_accel = 8;
12986 break;
12987 case 10900: _kernel_loops = ROUNDS_PBKDF2_SHA256;
12988 _kernel_accel = 8;
12989 break;
12990 case 11300: _kernel_loops = ROUNDS_BITCOIN_WALLET;
12991 #ifndef OSX
12992 _kernel_accel = 8;
12993 #endif
12994 break;
12995 case 11600: _kernel_loops = ROUNDS_SEVEN_ZIP;
12996 #ifndef OSX
12997 _kernel_accel = 8;
12998 #endif
12999 break;
13000 case 11900: _kernel_loops = ROUNDS_PBKDF2_MD5;
13001 _kernel_accel = 8;
13002 break;
13003 case 12000: _kernel_loops = ROUNDS_PBKDF2_SHA1;
13004 _kernel_accel = 8;
13005 break;
13006 case 12100: _kernel_loops = ROUNDS_PBKDF2_SHA512;
13007 _kernel_accel = 8;
13008 break;
13009 case 12200: _kernel_loops = ROUNDS_ECRYPTFS;
13010 #ifndef OSX
13011 _kernel_accel = 8;
13012 #endif
13013 break;
13014 case 12300: _kernel_loops = ROUNDS_ORACLET;
13015 _kernel_accel = 8;
13016 break;
13017 case 12500: _kernel_loops = ROUNDS_RAR3;
13018 #ifndef OSX
13019 _kernel_accel = 32;
13020 #else
13021 if (isCpu) _kernel_accel = 32;
13022 #endif
13023 break;
13024 case 12700: _kernel_loops = ROUNDS_MYWALLET;
13025 _kernel_accel = 512;
13026 break;
13027 case 12800: _kernel_loops = ROUNDS_MS_DRSR;
13028 _kernel_accel = 512;
13029 break;
13030 case 12900: _kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
13031 _kernel_accel = 8;
13032 break;
13033 case 13000: _kernel_loops = ROUNDS_RAR5;
13034 #ifndef OSX
13035 _kernel_accel = 8;
13036 #endif
13037 break;
13038 }
13039
13040 // some algorithm collide too fast, make that impossible
13041
13042 switch (hash_mode)
13043 {
13044 case 11500: ((uint *) digests_buf)[1] = 1;
13045 break;
13046 }
13047
13048 if (_kernel_loops > 1024) _kernel_loops = 1024;
13049 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
13050 }
13051
13052 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13053 {
13054 _kernel_loops = 1024;
13055 }
13056
13057 if (hash_mode == 12500)
13058 {
13059 _kernel_loops = ROUNDS_RAR3 / 16;
13060 }
13061
13062 device_param->kernel_accel = _kernel_accel;
13063 device_param->kernel_loops = _kernel_loops;
13064
13065 devices_active++;
13066 }
13067
13068 // next please
13069
13070 devices_cnt++;
13071 }
13072 }
13073
13074 if (keyspace == 0 && devices_active == 0)
13075 {
13076 log_error ("ERROR: No devices found/left");
13077
13078 return (-1);
13079 }
13080
13081 data.devices_cnt = devices_cnt;
13082
13083 data.devices_active = devices_active;
13084
13085 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13086 {
13087 log_info ("");
13088 }
13089
13090 /**
13091 * HM devices: init
13092 */
13093
13094 #ifdef HAVE_HWMON
13095 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13096 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13097 #endif
13098
13099 #ifdef HAVE_ADL
13100 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13101 #endif
13102
13103 if (gpu_temp_disable == 0)
13104 {
13105 #if defined(WIN) && defined(HAVE_NVAPI)
13106 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13107
13108 if (nvapi_init (nvapi) == 0)
13109 data.hm_nv = nvapi;
13110
13111 if (data.hm_nv)
13112 {
13113 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13114 {
13115 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13116
13117 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13118
13119 int tmp_out = 0;
13120
13121 for (int i = 0; i < tmp_in; i++)
13122 {
13123 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13124 }
13125
13126 for (int i = 0; i < tmp_out; i++)
13127 {
13128 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13129
13130 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13131
13132 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;
13133 }
13134 }
13135 }
13136 #endif // WIN && HAVE_NVAPI
13137
13138 #if defined(LINUX) && defined(HAVE_NVML)
13139 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13140
13141 if (nvml_init (nvml) == 0)
13142 data.hm_nv = nvml;
13143
13144 if (data.hm_nv)
13145 {
13146 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13147 {
13148 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13149
13150 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13151
13152 int tmp_out = 0;
13153
13154 for (int i = 0; i < tmp_in; i++)
13155 {
13156 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13157 }
13158
13159 for (int i = 0; i < tmp_out; i++)
13160 {
13161 unsigned int speed;
13162
13163 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;
13164 }
13165 }
13166 }
13167 #endif // LINUX && HAVE_NVML
13168
13169 data.hm_amd = NULL;
13170
13171 #ifdef HAVE_ADL
13172 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13173
13174 if (adl_init (adl) == 0)
13175 data.hm_amd = adl;
13176
13177 if (data.hm_amd)
13178 {
13179 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13180 {
13181 // total number of adapters
13182
13183 int hm_adapters_num;
13184
13185 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13186
13187 // adapter info
13188
13189 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13190
13191 if (lpAdapterInfo == NULL) return (-1);
13192
13193 // get a list (of ids of) valid/usable adapters
13194
13195 int num_adl_adapters = 0;
13196
13197 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13198
13199 if (num_adl_adapters > 0)
13200 {
13201 hc_thread_mutex_lock (mux_adl);
13202
13203 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13204
13205 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13206
13207 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13208 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13209
13210 hc_thread_mutex_unlock (mux_adl);
13211 }
13212
13213 myfree (valid_adl_device_list);
13214 myfree (lpAdapterInfo);
13215 }
13216 }
13217 #endif // HAVE_ADL
13218
13219 if (data.hm_amd == NULL && data.hm_nv == NULL)
13220 {
13221 gpu_temp_disable = 1;
13222 }
13223 }
13224
13225 /**
13226 * OpenCL devices: allocate buffer for device specific information
13227 */
13228
13229 #ifdef HAVE_HWMON
13230 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
13231
13232 #ifdef HAVE_ADL
13233 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
13234
13235 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
13236 #endif // ADL
13237 #endif
13238
13239 /**
13240 * enable custom signal handler(s)
13241 */
13242
13243 if (benchmark == 0)
13244 {
13245 hc_signal (sigHandler_default);
13246 }
13247 else
13248 {
13249 hc_signal (sigHandler_benchmark);
13250 }
13251
13252 /**
13253 * User-defined GPU temp handling
13254 */
13255
13256 #ifdef HAVE_HWMON
13257 if (gpu_temp_disable == 1)
13258 {
13259 gpu_temp_abort = 0;
13260 gpu_temp_retain = 0;
13261 }
13262
13263 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13264 {
13265 if (gpu_temp_abort < gpu_temp_retain)
13266 {
13267 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13268
13269 return (-1);
13270 }
13271 }
13272
13273 data.gpu_temp_disable = gpu_temp_disable;
13274 data.gpu_temp_abort = gpu_temp_abort;
13275 data.gpu_temp_retain = gpu_temp_retain;
13276 #endif
13277
13278 /**
13279 * inform the user
13280 */
13281
13282 if (data.quiet == 0)
13283 {
13284 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13285
13286 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);
13287
13288 if (attack_mode == ATTACK_MODE_STRAIGHT)
13289 {
13290 log_info ("Rules: %u", kernel_rules_cnt);
13291 }
13292
13293 if (opti_type)
13294 {
13295 log_info ("Applicable Optimizers:");
13296
13297 for (uint i = 0; i < 32; i++)
13298 {
13299 const uint opti_bit = 1u << i;
13300
13301 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13302 }
13303 }
13304
13305 /**
13306 * Watchdog and Temperature balance
13307 */
13308
13309 #ifdef HAVE_HWMON
13310 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13311 {
13312 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13313 }
13314
13315 if (gpu_temp_abort == 0)
13316 {
13317 log_info ("Watchdog: Temperature abort trigger disabled");
13318 }
13319 else
13320 {
13321 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13322 }
13323
13324 if (gpu_temp_retain == 0)
13325 {
13326 log_info ("Watchdog: Temperature retain trigger disabled");
13327 }
13328 else
13329 {
13330 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13331 }
13332 #endif
13333 }
13334
13335 if (data.quiet == 0) log_info ("");
13336
13337 /**
13338 * HM devices: copy
13339 */
13340
13341 if (gpu_temp_disable == 0)
13342 {
13343 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13344 {
13345 hc_device_param_t *device_param = &data.devices_param[device_id];
13346
13347 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13348
13349 if (device_param->skipped) continue;
13350
13351 const uint platform_devices_id = device_param->platform_devices_id;
13352
13353 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13354 if (device_param->vendor_id == VENDOR_ID_NV)
13355 {
13356 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13357 }
13358 #endif
13359
13360 #ifdef HAVE_ADL
13361 if (device_param->vendor_id == VENDOR_ID_AMD)
13362 {
13363 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13364 }
13365 #endif
13366 }
13367 }
13368
13369 /*
13370 * Temporary fix:
13371 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13372 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13373 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13374 * Driver / ADL bug?
13375 */
13376
13377 #ifdef HAVE_ADL
13378 if (powertune_enable == 1)
13379 {
13380 hc_thread_mutex_lock (mux_adl);
13381
13382 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13383 {
13384 hc_device_param_t *device_param = &data.devices_param[device_id];
13385
13386 if (device_param->skipped) continue;
13387
13388 if (data.hm_device[device_id].od_version == 6)
13389 {
13390 // set powertune value only
13391
13392 int powertune_supported = 0;
13393
13394 int ADL_rc = 0;
13395
13396 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13397 {
13398 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13399
13400 return (-1);
13401 }
13402
13403 if (powertune_supported != 0)
13404 {
13405 // powertune set
13406 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13407
13408 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13409 {
13410 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13411
13412 return (-1);
13413 }
13414
13415 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13416 {
13417 log_error ("ERROR: Failed to set new ADL PowerControl values");
13418
13419 return (-1);
13420 }
13421 }
13422 }
13423 }
13424
13425 hc_thread_mutex_unlock (mux_adl);
13426 }
13427 #endif // HAVE_ADK
13428 #endif // HAVE_HWMON
13429
13430 #ifdef OSX
13431 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13432 {
13433 if (force == 0)
13434 {
13435 log_info ("");
13436 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13437 log_info ("You can use --force to override this but do not post error reports if you do so");
13438 log_info ("");
13439
13440 continue;
13441 }
13442 }
13443 #endif
13444
13445 #ifdef DEBUG
13446 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13447 #endif
13448
13449 uint kernel_blocks_all = 0;
13450
13451 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13452 {
13453 /**
13454 * host buffer
13455 */
13456
13457 hc_device_param_t *device_param = &data.devices_param[device_id];
13458
13459 if (device_param->skipped) continue;
13460
13461 /**
13462 * device properties
13463 */
13464
13465 char *device_name_chksum = device_param->device_name_chksum;
13466
13467 uint device_processors = device_param->device_processors;
13468
13469 uint device_processor_cores = device_param->device_processor_cores;
13470
13471 cl_device_type device_type = device_param->device_type;
13472
13473 /**
13474 * create context for each device
13475 */
13476
13477 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13478
13479 /**
13480 * create command-queue
13481 */
13482
13483 // not supported with NV
13484 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13485
13486 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13487
13488 /**
13489 * create input buffers on device
13490 */
13491
13492 uint kernel_threads = KERNEL_THREADS;
13493
13494 // bcrypt
13495 if (hash_mode == 3200) kernel_threads = 8;
13496 if (hash_mode == 9000) kernel_threads = 8;
13497
13498 if (device_type & CL_DEVICE_TYPE_CPU)
13499 {
13500 if (benchmark_mode == 0)
13501 {
13502 if (device_param->kernel_accel > 16)
13503 {
13504 device_param->kernel_accel = 16;
13505 }
13506 }
13507 else
13508 {
13509 if (device_param->kernel_accel > 64)
13510 {
13511 device_param->kernel_accel = 64;
13512 }
13513 }
13514 }
13515
13516 uint kernel_power = device_processors * kernel_threads * device_param->kernel_accel;
13517 uint kernel_blocks = kernel_power;
13518
13519 device_param->kernel_threads = kernel_threads;
13520 device_param->kernel_power_user = kernel_power;
13521 device_param->kernel_blocks_user = kernel_blocks;
13522
13523 kernel_blocks_all += kernel_blocks;
13524
13525 uint size_pws = kernel_power * sizeof (pw_t);
13526
13527 uint size_tmps = 4;
13528
13529 switch (hash_mode)
13530 {
13531 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13532 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13533 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13534 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13535 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13536 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13537 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13538 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13539 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13540 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13541 case 6211:
13542 case 6212:
13543 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13544 case 6221:
13545 case 6222:
13546 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13547 case 6231:
13548 case 6232:
13549 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13550 case 6241:
13551 case 6242:
13552 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13553 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13554 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13555 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13556 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13557 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13558 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13559 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13560 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13561 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13562 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13563 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13564 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13565 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13566 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13567 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13568 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13569 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13570 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13571 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13572 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13573 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13574 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13575 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13576 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13577 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13578 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13579 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13580 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13581 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13582 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13583 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13584 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13585 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13586 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13587 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13588 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13589 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13590 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13591 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13592 };
13593
13594 uint size_hooks = 4;
13595
13596 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13597 {
13598 // insert correct hook size
13599 }
13600
13601 // we can optimize some stuff here...
13602
13603 device_param->size_pws = size_pws;
13604 device_param->size_tmps = size_tmps;
13605 device_param->size_hooks = size_hooks;
13606
13607 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13608 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13609
13610 device_param->size_root_css = size_root_css;
13611 device_param->size_markov_css = size_markov_css;
13612
13613 uint size_results = KERNEL_THREADS * sizeof (uint);
13614
13615 device_param->size_results = size_results;
13616
13617 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13618 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13619
13620 uint size_plains = digests_cnt * sizeof (plain_t);
13621 uint size_salts = salts_cnt * sizeof (salt_t);
13622 uint size_esalts = salts_cnt * esalt_size;
13623
13624 device_param->size_plains = size_plains;
13625 device_param->size_digests = size_digests;
13626 device_param->size_shown = size_shown;
13627 device_param->size_salts = size_salts;
13628
13629 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13630 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13631 uint size_tm = 32 * sizeof (bs_word_t);
13632
13633 u64 size_scryptV = 1;
13634
13635 if ((hash_mode == 8900) || (hash_mode == 9300))
13636 {
13637 uint tmto_start = 0;
13638 uint tmto_stop = 10;
13639
13640 if (scrypt_tmto)
13641 {
13642 tmto_start = scrypt_tmto;
13643 }
13644 else
13645 {
13646 // in case the user did not specify the tmto manually
13647 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13648 // but set the lower end only in case the user has a device with too less memory
13649
13650 if (hash_mode == 8900)
13651 {
13652 if (device_param->vendor_id == VENDOR_ID_AMD)
13653 {
13654 tmto_start = 1;
13655 }
13656 else if (device_param->vendor_id == VENDOR_ID_NV)
13657 {
13658 tmto_start = 3;
13659 }
13660 }
13661 else if (hash_mode == 9300)
13662 {
13663 if (device_param->vendor_id == VENDOR_ID_AMD)
13664 {
13665 tmto_start = 3;
13666 }
13667 else if (device_param->vendor_id == VENDOR_ID_NV)
13668 {
13669 tmto_start = 5;
13670 }
13671 }
13672 }
13673
13674 if (quiet == 0) log_info ("");
13675
13676 uint shader_per_mp = 1;
13677
13678 if (device_param->vendor_id == VENDOR_ID_AMD)
13679 {
13680 shader_per_mp = 8;
13681 }
13682 else if (device_param->vendor_id == VENDOR_ID_NV)
13683 {
13684 shader_per_mp = 32;
13685 }
13686
13687 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13688 {
13689 // TODO: in theory the following calculation needs to be done per salt, not global
13690 // we assume all hashes have the same scrypt settings
13691
13692 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13693
13694 size_scryptV /= 1 << tmto;
13695
13696 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13697
13698 if (size_scryptV > device_param->device_maxmem_alloc)
13699 {
13700 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13701
13702 continue;
13703 }
13704
13705 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13706 {
13707 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13708 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13709 }
13710
13711 break;
13712 }
13713
13714 if (data.salts_buf[0].scrypt_phy == 0)
13715 {
13716 log_error ("ERROR: can't allocate enough device memory");
13717
13718 return -1;
13719 }
13720
13721 if (quiet == 0) log_info ("");
13722 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13723 }
13724
13725 /**
13726 * default building options
13727 */
13728
13729 char build_opts[1024] = { 0 };
13730
13731 // we don't have sm_* on vendors not NV but it doesn't matter
13732
13733 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13734
13735 /**
13736 * main kernel
13737 */
13738
13739 {
13740 /**
13741 * kernel source filename
13742 */
13743
13744 char source_file[256] = { 0 };
13745
13746 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13747
13748 struct stat sst;
13749
13750 if (stat (source_file, &sst) == -1)
13751 {
13752 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13753
13754 return -1;
13755 }
13756
13757 /**
13758 * kernel cached filename
13759 */
13760
13761 char cached_file[256] = { 0 };
13762
13763 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13764
13765 int cached = 1;
13766
13767 struct stat cst;
13768
13769 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13770 {
13771 cached = 0;
13772 }
13773
13774 /**
13775 * kernel compile or load
13776 */
13777
13778 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13779
13780 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13781
13782 if (force_jit_compilation == -1)
13783 {
13784 if (cached == 0)
13785 {
13786 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13787
13788 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13789
13790 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13791
13792 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13793
13794 size_t binary_size;
13795
13796 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13797
13798 u8 *binary = (u8 *) mymalloc (binary_size);
13799
13800 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13801
13802 writeProgramBin (cached_file, binary, binary_size);
13803
13804 local_free (binary);
13805 }
13806 else
13807 {
13808 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13809
13810 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13811
13812 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13813
13814 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13815 }
13816 }
13817 else
13818 {
13819 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13820
13821 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13822
13823 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13824
13825 char build_opts_update[1024] = { 0 };
13826
13827 if (force_jit_compilation == 1500)
13828 {
13829 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13830 }
13831 else if (force_jit_compilation == 8900)
13832 {
13833 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);
13834 }
13835
13836 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
13837 }
13838
13839 local_free (kernel_lengths);
13840 local_free (kernel_sources[0]);
13841 local_free (kernel_sources);
13842 }
13843
13844 /**
13845 * word generator kernel
13846 */
13847
13848 if (attack_mode != ATTACK_MODE_STRAIGHT)
13849 {
13850 /**
13851 * kernel mp source filename
13852 */
13853
13854 char source_file[256] = { 0 };
13855
13856 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13857
13858 struct stat sst;
13859
13860 if (stat (source_file, &sst) == -1)
13861 {
13862 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13863
13864 return -1;
13865 }
13866
13867 /**
13868 * kernel mp cached filename
13869 */
13870
13871 char cached_file[256] = { 0 };
13872
13873 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13874
13875 int cached = 1;
13876
13877 struct stat cst;
13878
13879 if (stat (cached_file, &cst) == -1)
13880 {
13881 cached = 0;
13882 }
13883
13884 /**
13885 * kernel compile or load
13886 */
13887
13888 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13889
13890 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13891
13892 if (cached == 0)
13893 {
13894 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13895
13896 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13897
13898 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13899
13900 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13901
13902 size_t binary_size;
13903
13904 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13905
13906 u8 *binary = (u8 *) mymalloc (binary_size);
13907
13908 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13909
13910 writeProgramBin (cached_file, binary, binary_size);
13911
13912 local_free (binary);
13913 }
13914 else
13915 {
13916 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13917
13918 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13919
13920 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13921
13922 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13923 }
13924
13925 local_free (kernel_lengths);
13926 local_free (kernel_sources[0]);
13927 local_free (kernel_sources);
13928 }
13929
13930 /**
13931 * amplifier kernel
13932 */
13933
13934 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13935 {
13936
13937 }
13938 else
13939 {
13940 /**
13941 * kernel amp source filename
13942 */
13943
13944 char source_file[256] = { 0 };
13945
13946 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13947
13948 struct stat sst;
13949
13950 if (stat (source_file, &sst) == -1)
13951 {
13952 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13953
13954 return -1;
13955 }
13956
13957 /**
13958 * kernel amp cached filename
13959 */
13960
13961 char cached_file[256] = { 0 };
13962
13963 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13964
13965 int cached = 1;
13966
13967 struct stat cst;
13968
13969 if (stat (cached_file, &cst) == -1)
13970 {
13971 cached = 0;
13972 }
13973
13974 /**
13975 * kernel compile or load
13976 */
13977
13978 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13979
13980 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13981
13982 if (cached == 0)
13983 {
13984 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13985
13986 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13987
13988 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13989
13990 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13991
13992 size_t binary_size;
13993
13994 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13995
13996 u8 *binary = (u8 *) mymalloc (binary_size);
13997
13998 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13999
14000 writeProgramBin (cached_file, binary, binary_size);
14001
14002 local_free (binary);
14003 }
14004 else
14005 {
14006 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14007
14008 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14009
14010 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14011
14012 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
14013 }
14014
14015 local_free (kernel_lengths);
14016 local_free (kernel_sources[0]);
14017 local_free (kernel_sources);
14018 }
14019
14020 /**
14021 * global buffers
14022 */
14023
14024 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14025 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14026 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14027 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14028 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14029 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14030 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14031 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14032 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14033 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14034 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14035 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14036 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14037 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14038 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14039 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14040 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14041 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14042
14043 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);
14044 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);
14045 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);
14046 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);
14047 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);
14048 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);
14049 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);
14050 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);
14051 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14052 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14053 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14054
14055 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14056 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14057 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14058 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14059 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14060 run_kernel_bzero (device_param, device_param->d_result, size_results);
14061
14062 /**
14063 * special buffers
14064 */
14065
14066 if (attack_kern == ATTACK_KERN_STRAIGHT)
14067 {
14068 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14069 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14070
14071 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14072
14073 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14074 }
14075 else if (attack_kern == ATTACK_KERN_COMBI)
14076 {
14077 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14078 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14079 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14080 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14081
14082 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14083 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14084 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14085 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14086 }
14087 else if (attack_kern == ATTACK_KERN_BF)
14088 {
14089 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14090 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14091 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14092 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14093 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14094
14095 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14096 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14097 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14098 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14099 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14100 }
14101
14102 if (size_esalts)
14103 {
14104 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14105
14106 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14107 }
14108
14109 /**
14110 * main host data
14111 */
14112
14113 uint *result = (uint *) mymalloc (size_results);
14114
14115 device_param->result = result;
14116
14117 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14118
14119 device_param->pws_buf = pws_buf;
14120
14121 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14122
14123 for (int i = 0; i < 64; i++)
14124 {
14125 pw_caches[i].pw_buf.pw_len = i;
14126 pw_caches[i].cnt = 0;
14127 }
14128
14129 device_param->pw_caches = pw_caches;
14130
14131 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14132
14133 device_param->combs_buf = combs_buf;
14134
14135 void *hooks_buf = mymalloc (size_hooks);
14136
14137 device_param->hooks_buf = hooks_buf;
14138
14139 device_param->pw_transpose = pw_transpose_to_hi1;
14140 device_param->pw_add = pw_add_to_hc1;
14141
14142 /**
14143 * kernel args
14144 */
14145
14146 device_param->kernel_params_buf32[21] = bitmap_mask;
14147 device_param->kernel_params_buf32[22] = bitmap_shift1;
14148 device_param->kernel_params_buf32[23] = bitmap_shift2;
14149 device_param->kernel_params_buf32[24] = 0; // salt_pos
14150 device_param->kernel_params_buf32[25] = 0; // loop_pos
14151 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14152 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14153 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14154 device_param->kernel_params_buf32[29] = 0; // digests_offset
14155 device_param->kernel_params_buf32[30] = 0; // combs_mode
14156 device_param->kernel_params_buf32[31] = 0; // gid_max
14157
14158 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14159 ? &device_param->d_pws_buf
14160 : &device_param->d_pws_amp_buf;
14161 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14162 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14163 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14164 device_param->kernel_params[ 4] = &device_param->d_tmps;
14165 device_param->kernel_params[ 5] = &device_param->d_hooks;
14166 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14167 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14168 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14169 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14170 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14171 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14172 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14173 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14174 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14175 device_param->kernel_params[15] = &device_param->d_digests_buf;
14176 device_param->kernel_params[16] = &device_param->d_digests_shown;
14177 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14178 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14179 device_param->kernel_params[19] = &device_param->d_result;
14180 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14181 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14182 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14183 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14184 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14185 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14186 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14187 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14188 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14189 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14190 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14191 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14192
14193 device_param->kernel_params_mp_buf64[3] = 0;
14194 device_param->kernel_params_mp_buf32[4] = 0;
14195 device_param->kernel_params_mp_buf32[5] = 0;
14196 device_param->kernel_params_mp_buf32[6] = 0;
14197 device_param->kernel_params_mp_buf32[7] = 0;
14198 device_param->kernel_params_mp_buf32[8] = 0;
14199
14200 device_param->kernel_params_mp[0] = NULL;
14201 device_param->kernel_params_mp[1] = NULL;
14202 device_param->kernel_params_mp[2] = NULL;
14203 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14204 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14205 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14206 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14207 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14208 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14209
14210 device_param->kernel_params_mp_l_buf64[3] = 0;
14211 device_param->kernel_params_mp_l_buf32[4] = 0;
14212 device_param->kernel_params_mp_l_buf32[5] = 0;
14213 device_param->kernel_params_mp_l_buf32[6] = 0;
14214 device_param->kernel_params_mp_l_buf32[7] = 0;
14215 device_param->kernel_params_mp_l_buf32[8] = 0;
14216 device_param->kernel_params_mp_l_buf32[9] = 0;
14217
14218 device_param->kernel_params_mp_l[0] = NULL;
14219 device_param->kernel_params_mp_l[1] = NULL;
14220 device_param->kernel_params_mp_l[2] = NULL;
14221 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14222 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14223 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14224 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14225 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14226 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14227 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14228
14229 device_param->kernel_params_mp_r_buf64[3] = 0;
14230 device_param->kernel_params_mp_r_buf32[4] = 0;
14231 device_param->kernel_params_mp_r_buf32[5] = 0;
14232 device_param->kernel_params_mp_r_buf32[6] = 0;
14233 device_param->kernel_params_mp_r_buf32[7] = 0;
14234 device_param->kernel_params_mp_r_buf32[8] = 0;
14235
14236 device_param->kernel_params_mp_r[0] = NULL;
14237 device_param->kernel_params_mp_r[1] = NULL;
14238 device_param->kernel_params_mp_r[2] = NULL;
14239 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14240 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14241 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14242 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14243 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14244 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14245
14246 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14247 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14248
14249 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14250 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14251 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14252 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14253 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14254 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14255 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14256
14257 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14258
14259 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14260 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14261
14262 /**
14263 * kernel name
14264 */
14265
14266 char kernel_name[64] = { 0 };
14267
14268 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14269 {
14270 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14271 {
14272 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14273
14274 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14275
14276 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14277
14278 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14279
14280 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14281
14282 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14283 }
14284 else
14285 {
14286 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14287
14288 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14289
14290 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14291
14292 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14293
14294 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14295
14296 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14297 }
14298
14299 if (data.attack_mode == ATTACK_MODE_BF)
14300 {
14301 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14302 {
14303 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14304
14305 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14306
14307 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14308
14309 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14310 }
14311 }
14312 }
14313 else
14314 {
14315 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14316
14317 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14318
14319 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14320
14321 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14322
14323 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14324
14325 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14326
14327 if (opts_type & OPTS_TYPE_HOOK12)
14328 {
14329 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14330
14331 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14332 }
14333
14334 if (opts_type & OPTS_TYPE_HOOK23)
14335 {
14336 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14337
14338 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14339 }
14340 }
14341
14342 for (uint i = 0; i <= 20; i++)
14343 {
14344 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14345 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14346 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14347
14348 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14349 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14350 }
14351
14352 for (uint i = 21; i <= 31; i++)
14353 {
14354 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14355 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14356 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14357
14358 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14359 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14360 }
14361
14362 if (attack_mode == ATTACK_MODE_BF)
14363 {
14364 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14365 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14366
14367 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14368 {
14369 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14370
14371 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14372 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14373 }
14374 }
14375 else if (attack_mode == ATTACK_MODE_HYBRID1)
14376 {
14377 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14378 }
14379 else if (attack_mode == ATTACK_MODE_HYBRID2)
14380 {
14381 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14382 }
14383
14384 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14385 {
14386 // nothing to do
14387 }
14388 else
14389 {
14390 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14391 }
14392
14393 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14394 {
14395 // nothing to do
14396 }
14397 else
14398 {
14399 for (uint i = 0; i < 5; i++)
14400 {
14401 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14402 }
14403
14404 for (uint i = 5; i < 7; i++)
14405 {
14406 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14407 }
14408 }
14409
14410 /**
14411 * Store initial fanspeed if gpu_temp_retain is enabled
14412 */
14413
14414 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14415 int gpu_temp_retain_set = 0;
14416
14417 if (gpu_temp_disable == 0)
14418 {
14419 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14420 {
14421 hc_thread_mutex_lock (mux_adl);
14422
14423 if (data.hm_device[device_id].fan_supported == 1)
14424 {
14425 if (gpu_temp_retain_chgd == 0)
14426 {
14427 uint cur_temp = 0;
14428 uint default_temp = 0;
14429
14430 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);
14431
14432 if (ADL_rc == ADL_OK)
14433 {
14434 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14435
14436 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14437
14438 // special case with multi gpu setups: always use minimum retain
14439
14440 if (gpu_temp_retain_set == 0)
14441 {
14442 gpu_temp_retain = gpu_temp_retain_target;
14443 gpu_temp_retain_set = 1;
14444 }
14445 else
14446 {
14447 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14448 }
14449
14450 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14451 }
14452 }
14453
14454 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14455
14456 temp_retain_fanspeed_value[device_id] = fan_speed;
14457
14458 if (fan_speed == -1)
14459 {
14460 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14461
14462 temp_retain_fanspeed_value[device_id] = 0;
14463 }
14464 }
14465
14466 hc_thread_mutex_unlock (mux_adl);
14467 }
14468 }
14469
14470 /**
14471 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14472 */
14473
14474 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14475 {
14476 hc_thread_mutex_lock (mux_adl);
14477
14478 if (data.hm_device[device_id].od_version == 6)
14479 {
14480 int ADL_rc;
14481
14482 // check powertune capabilities first, if not available then skip device
14483
14484 int powertune_supported = 0;
14485
14486 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14487 {
14488 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14489
14490 return (-1);
14491 }
14492
14493 if (powertune_supported != 0)
14494 {
14495 // powercontrol settings
14496
14497 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14498
14499 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14500 {
14501 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14502 }
14503
14504 if (ADL_rc != ADL_OK)
14505 {
14506 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14507
14508 return (-1);
14509 }
14510
14511 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14512 {
14513 log_error ("ERROR: Failed to set new ADL PowerControl values");
14514
14515 return (-1);
14516 }
14517
14518 // clocks
14519
14520 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14521
14522 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14523
14524 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)
14525 {
14526 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14527
14528 return (-1);
14529 }
14530
14531 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14532
14533 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14534
14535 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14536 {
14537 log_error ("ERROR: Failed to get ADL device capabilities");
14538
14539 return (-1);
14540 }
14541
14542 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14543 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14544
14545 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14546 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14547
14548 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14549 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14550
14551 // warning if profile has too low max values
14552
14553 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14554 {
14555 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14556 }
14557
14558 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14559 {
14560 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14561 }
14562
14563 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14564
14565 performance_state->iNumberOfPerformanceLevels = 2;
14566
14567 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14568 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14569 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14570 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14571
14572 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)
14573 {
14574 log_info ("ERROR: Failed to set ADL performance state");
14575
14576 return (-1);
14577 }
14578
14579 local_free (performance_state);
14580 }
14581 }
14582
14583 hc_thread_mutex_unlock (mux_adl);
14584 }
14585 #endif // HAVE_HWMON && HAVE_ADL
14586 }
14587
14588 data.kernel_blocks_all = kernel_blocks_all;
14589
14590 if (data.quiet == 0) log_info ("");
14591
14592 /**
14593 * Inform user which algorithm is checked and at which workload setting
14594 */
14595
14596 if (benchmark == 1)
14597 {
14598 quiet = 0;
14599
14600 data.quiet = quiet;
14601
14602 char *hash_type = strhashtype (data.hash_mode); // not a bug
14603
14604 log_info ("Hashtype: %s", hash_type);
14605 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14606 log_info ("");
14607 }
14608
14609 /**
14610 * keep track of the progress
14611 */
14612
14613 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14614 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14615 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14616
14617 /**
14618 * open filehandles
14619 */
14620
14621 #if _WIN
14622 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14623 {
14624 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14625
14626 return (-1);
14627 }
14628
14629 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14630 {
14631 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14632
14633 return (-1);
14634 }
14635
14636 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14637 {
14638 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14639
14640 return (-1);
14641 }
14642 #endif
14643
14644 /**
14645 * dictionary pad
14646 */
14647
14648 segment_size *= (1024 * 1024);
14649
14650 data.segment_size = segment_size;
14651
14652 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14653
14654 wl_data->buf = (char *) mymalloc (segment_size);
14655 wl_data->avail = segment_size;
14656 wl_data->incr = segment_size;
14657 wl_data->cnt = 0;
14658 wl_data->pos = 0;
14659
14660 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14661
14662 data.wordlist_mode = wordlist_mode;
14663
14664 cs_t *css_buf = NULL;
14665 uint css_cnt = 0;
14666 uint dictcnt = 0;
14667 uint maskcnt = 1;
14668 char **masks = NULL;
14669 char **dictfiles = NULL;
14670
14671 uint mask_from_file = 0;
14672
14673 if (attack_mode == ATTACK_MODE_STRAIGHT)
14674 {
14675 if (wordlist_mode == WL_MODE_FILE)
14676 {
14677 int wls_left = myargc - (optind + 1);
14678
14679 for (int i = 0; i < wls_left; i++)
14680 {
14681 char *l0_filename = myargv[optind + 1 + i];
14682
14683 struct stat l0_stat;
14684
14685 if (stat (l0_filename, &l0_stat) == -1)
14686 {
14687 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14688
14689 return (-1);
14690 }
14691
14692 uint is_dir = S_ISDIR (l0_stat.st_mode);
14693
14694 if (is_dir == 0)
14695 {
14696 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14697
14698 dictcnt++;
14699
14700 dictfiles[dictcnt - 1] = l0_filename;
14701 }
14702 else
14703 {
14704 // do not allow --keyspace w/ a directory
14705
14706 if (keyspace == 1)
14707 {
14708 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14709
14710 return (-1);
14711 }
14712
14713 char **dictionary_files = NULL;
14714
14715 dictionary_files = scan_directory (l0_filename);
14716
14717 if (dictionary_files != NULL)
14718 {
14719 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14720
14721 for (int d = 0; dictionary_files[d] != NULL; d++)
14722 {
14723 char *l1_filename = dictionary_files[d];
14724
14725 struct stat l1_stat;
14726
14727 if (stat (l1_filename, &l1_stat) == -1)
14728 {
14729 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14730
14731 return (-1);
14732 }
14733
14734 if (S_ISREG (l1_stat.st_mode))
14735 {
14736 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14737
14738 dictcnt++;
14739
14740 dictfiles[dictcnt - 1] = strdup (l1_filename);
14741 }
14742 }
14743 }
14744
14745 local_free (dictionary_files);
14746 }
14747 }
14748
14749 if (dictcnt < 1)
14750 {
14751 log_error ("ERROR: No usable dictionary file found.");
14752
14753 return (-1);
14754 }
14755 }
14756 else if (wordlist_mode == WL_MODE_STDIN)
14757 {
14758 dictcnt = 1;
14759 }
14760 }
14761 else if (attack_mode == ATTACK_MODE_COMBI)
14762 {
14763 // display
14764
14765 char *dictfile1 = myargv[optind + 1 + 0];
14766 char *dictfile2 = myargv[optind + 1 + 1];
14767
14768 // find the bigger dictionary and use as base
14769
14770 FILE *fp1 = NULL;
14771 FILE *fp2 = NULL;
14772
14773 struct stat tmp_stat;
14774
14775 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14776 {
14777 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14778
14779 return (-1);
14780 }
14781
14782 if (stat (dictfile1, &tmp_stat) == -1)
14783 {
14784 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14785
14786 fclose (fp1);
14787
14788 return (-1);
14789 }
14790
14791 if (S_ISDIR (tmp_stat.st_mode))
14792 {
14793 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14794
14795 fclose (fp1);
14796
14797 return (-1);
14798 }
14799
14800 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14801 {
14802 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14803
14804 fclose (fp1);
14805
14806 return (-1);
14807 }
14808
14809 if (stat (dictfile2, &tmp_stat) == -1)
14810 {
14811 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14812
14813 fclose (fp1);
14814 fclose (fp2);
14815
14816 return (-1);
14817 }
14818
14819 if (S_ISDIR (tmp_stat.st_mode))
14820 {
14821 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14822
14823 fclose (fp1);
14824 fclose (fp2);
14825
14826 return (-1);
14827 }
14828
14829 data.combs_cnt = 1;
14830
14831 data.quiet = 1;
14832
14833 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14834
14835 data.quiet = quiet;
14836
14837 if (words1_cnt == 0)
14838 {
14839 log_error ("ERROR: %s: empty file", dictfile1);
14840
14841 fclose (fp1);
14842 fclose (fp2);
14843
14844 return (-1);
14845 }
14846
14847 data.combs_cnt = 1;
14848
14849 data.quiet = 1;
14850
14851 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14852
14853 data.quiet = quiet;
14854
14855 if (words2_cnt == 0)
14856 {
14857 log_error ("ERROR: %s: empty file", dictfile2);
14858
14859 fclose (fp1);
14860 fclose (fp2);
14861
14862 return (-1);
14863 }
14864
14865 fclose (fp1);
14866 fclose (fp2);
14867
14868 data.dictfile = dictfile1;
14869 data.dictfile2 = dictfile2;
14870
14871 if (words1_cnt >= words2_cnt)
14872 {
14873 data.combs_cnt = words2_cnt;
14874 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14875
14876 dictfiles = &data.dictfile;
14877
14878 dictcnt = 1;
14879 }
14880 else
14881 {
14882 data.combs_cnt = words1_cnt;
14883 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14884
14885 dictfiles = &data.dictfile2;
14886
14887 dictcnt = 1;
14888
14889 // we also have to switch wordlist related rules!
14890
14891 char *tmpc = data.rule_buf_l;
14892
14893 data.rule_buf_l = data.rule_buf_r;
14894 data.rule_buf_r = tmpc;
14895
14896 int tmpi = data.rule_len_l;
14897
14898 data.rule_len_l = data.rule_len_r;
14899 data.rule_len_r = tmpi;
14900 }
14901 }
14902 else if (attack_mode == ATTACK_MODE_BF)
14903 {
14904 char *mask = NULL;
14905
14906 maskcnt = 0;
14907
14908 if (benchmark == 0)
14909 {
14910 mask = myargv[optind + 1];
14911
14912 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14913
14914 if ((optind + 2) <= myargc)
14915 {
14916 struct stat file_stat;
14917
14918 if (stat (mask, &file_stat) == -1)
14919 {
14920 maskcnt = 1;
14921
14922 masks[maskcnt - 1] = mystrdup (mask);
14923 }
14924 else
14925 {
14926 int wls_left = myargc - (optind + 1);
14927
14928 uint masks_avail = INCR_MASKS;
14929
14930 for (int i = 0; i < wls_left; i++)
14931 {
14932 if (i != 0)
14933 {
14934 mask = myargv[optind + 1 + i];
14935
14936 if (stat (mask, &file_stat) == -1)
14937 {
14938 log_error ("ERROR: %s: %s", mask, strerror (errno));
14939
14940 return (-1);
14941 }
14942 }
14943
14944 uint is_file = S_ISREG (file_stat.st_mode);
14945
14946 if (is_file == 1)
14947 {
14948 FILE *mask_fp;
14949
14950 if ((mask_fp = fopen (mask, "r")) == NULL)
14951 {
14952 log_error ("ERROR: %s: %s", mask, strerror (errno));
14953
14954 return (-1);
14955 }
14956
14957 char line_buf[BUFSIZ] = { 0 };
14958
14959 while (!feof (mask_fp))
14960 {
14961 memset (line_buf, 0, BUFSIZ);
14962
14963 int line_len = fgetl (mask_fp, line_buf);
14964
14965 if (line_len == 0) continue;
14966
14967 if (line_buf[0] == '#') continue;
14968
14969 if (masks_avail == maskcnt)
14970 {
14971 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14972
14973 masks_avail += INCR_MASKS;
14974 }
14975
14976 masks[maskcnt] = mystrdup (line_buf);
14977
14978 maskcnt++;
14979 }
14980
14981 fclose (mask_fp);
14982 }
14983 else
14984 {
14985 log_error ("ERROR: %s: unsupported file-type", mask);
14986
14987 return (-1);
14988 }
14989 }
14990
14991 mask_from_file = 1;
14992 }
14993 }
14994 else
14995 {
14996 custom_charset_1 = (char *) "?l?d?u";
14997 custom_charset_2 = (char *) "?l?d";
14998 custom_charset_3 = (char *) "?l?d*!$@_";
14999
15000 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15001 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15002 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15003
15004 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15005
15006 wordlist_mode = WL_MODE_MASK;
15007
15008 data.wordlist_mode = wordlist_mode;
15009
15010 increment = 1;
15011
15012 maskcnt = 1;
15013 }
15014 }
15015 else
15016 {
15017 /**
15018 * generate full masks and charsets
15019 */
15020
15021 masks = (char **) mymalloc (sizeof (char *));
15022
15023 switch (hash_mode)
15024 {
15025 case 1731: pw_min = 5;
15026 pw_max = 5;
15027 mask = mystrdup ("?b?b?b?b?b");
15028 break;
15029 case 12500: pw_min = 5;
15030 pw_max = 5;
15031 mask = mystrdup ("?b?b?b?b?b");
15032 break;
15033 default: pw_min = 7;
15034 pw_max = 7;
15035 mask = mystrdup ("?b?b?b?b?b?b?b");
15036 break;
15037 }
15038
15039 maskcnt = 1;
15040
15041 masks[maskcnt - 1] = mystrdup (mask);
15042
15043 wordlist_mode = WL_MODE_MASK;
15044
15045 data.wordlist_mode = wordlist_mode;
15046
15047 increment = 1;
15048 }
15049
15050 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15051
15052 if (increment)
15053 {
15054 if (increment_min > pw_min) pw_min = increment_min;
15055
15056 if (increment_max < pw_max) pw_max = increment_max;
15057 }
15058 }
15059 else if (attack_mode == ATTACK_MODE_HYBRID1)
15060 {
15061 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15062
15063 // display
15064
15065 char *mask = myargv[myargc - 1];
15066
15067 maskcnt = 0;
15068
15069 masks = (char **) mymalloc (1 * sizeof (char *));
15070
15071 // mod
15072
15073 struct stat file_stat;
15074
15075 if (stat (mask, &file_stat) == -1)
15076 {
15077 maskcnt = 1;
15078
15079 masks[maskcnt - 1] = mystrdup (mask);
15080 }
15081 else
15082 {
15083 uint is_file = S_ISREG (file_stat.st_mode);
15084
15085 if (is_file == 1)
15086 {
15087 FILE *mask_fp;
15088
15089 if ((mask_fp = fopen (mask, "r")) == NULL)
15090 {
15091 log_error ("ERROR: %s: %s", mask, strerror (errno));
15092
15093 return (-1);
15094 }
15095
15096 char line_buf[BUFSIZ] = { 0 };
15097
15098 uint masks_avail = 1;
15099
15100 while (!feof (mask_fp))
15101 {
15102 memset (line_buf, 0, BUFSIZ);
15103
15104 int line_len = fgetl (mask_fp, line_buf);
15105
15106 if (line_len == 0) continue;
15107
15108 if (line_buf[0] == '#') continue;
15109
15110 if (masks_avail == maskcnt)
15111 {
15112 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15113
15114 masks_avail += INCR_MASKS;
15115 }
15116
15117 masks[maskcnt] = mystrdup (line_buf);
15118
15119 maskcnt++;
15120 }
15121
15122 fclose (mask_fp);
15123
15124 mask_from_file = 1;
15125 }
15126 else
15127 {
15128 maskcnt = 1;
15129
15130 masks[maskcnt - 1] = mystrdup (mask);
15131 }
15132 }
15133
15134 // base
15135
15136 int wls_left = myargc - (optind + 2);
15137
15138 for (int i = 0; i < wls_left; i++)
15139 {
15140 char *filename = myargv[optind + 1 + i];
15141
15142 struct stat file_stat;
15143
15144 if (stat (filename, &file_stat) == -1)
15145 {
15146 log_error ("ERROR: %s: %s", filename, strerror (errno));
15147
15148 return (-1);
15149 }
15150
15151 uint is_dir = S_ISDIR (file_stat.st_mode);
15152
15153 if (is_dir == 0)
15154 {
15155 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15156
15157 dictcnt++;
15158
15159 dictfiles[dictcnt - 1] = filename;
15160 }
15161 else
15162 {
15163 // do not allow --keyspace w/ a directory
15164
15165 if (keyspace == 1)
15166 {
15167 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15168
15169 return (-1);
15170 }
15171
15172 char **dictionary_files = NULL;
15173
15174 dictionary_files = scan_directory (filename);
15175
15176 if (dictionary_files != NULL)
15177 {
15178 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15179
15180 for (int d = 0; dictionary_files[d] != NULL; d++)
15181 {
15182 char *l1_filename = dictionary_files[d];
15183
15184 struct stat l1_stat;
15185
15186 if (stat (l1_filename, &l1_stat) == -1)
15187 {
15188 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15189
15190 return (-1);
15191 }
15192
15193 if (S_ISREG (l1_stat.st_mode))
15194 {
15195 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15196
15197 dictcnt++;
15198
15199 dictfiles[dictcnt - 1] = strdup (l1_filename);
15200 }
15201 }
15202 }
15203
15204 local_free (dictionary_files);
15205 }
15206 }
15207
15208 if (dictcnt < 1)
15209 {
15210 log_error ("ERROR: No usable dictionary file found.");
15211
15212 return (-1);
15213 }
15214
15215 if (increment)
15216 {
15217 maskcnt = 0;
15218
15219 uint mask_min = increment_min; // we can't reject smaller masks here
15220 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15221
15222 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15223 {
15224 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15225
15226 if (cur_mask == NULL) break;
15227
15228 masks[maskcnt] = cur_mask;
15229
15230 maskcnt++;
15231
15232 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15233 }
15234 }
15235 }
15236 else if (attack_mode == ATTACK_MODE_HYBRID2)
15237 {
15238 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15239
15240 // display
15241
15242 char *mask = myargv[optind + 1 + 0];
15243
15244 maskcnt = 0;
15245
15246 masks = (char **) mymalloc (1 * sizeof (char *));
15247
15248 // mod
15249
15250 struct stat file_stat;
15251
15252 if (stat (mask, &file_stat) == -1)
15253 {
15254 maskcnt = 1;
15255
15256 masks[maskcnt - 1] = mystrdup (mask);
15257 }
15258 else
15259 {
15260 uint is_file = S_ISREG (file_stat.st_mode);
15261
15262 if (is_file == 1)
15263 {
15264 FILE *mask_fp;
15265
15266 if ((mask_fp = fopen (mask, "r")) == NULL)
15267 {
15268 log_error ("ERROR: %s: %s", mask, strerror (errno));
15269
15270 return (-1);
15271 }
15272
15273 char line_buf[BUFSIZ] = { 0 };
15274
15275 uint masks_avail = 1;
15276
15277 while (!feof (mask_fp))
15278 {
15279 memset (line_buf, 0, BUFSIZ);
15280
15281 int line_len = fgetl (mask_fp, line_buf);
15282
15283 if (line_len == 0) continue;
15284
15285 if (line_buf[0] == '#') continue;
15286
15287 if (masks_avail == maskcnt)
15288 {
15289 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15290
15291 masks_avail += INCR_MASKS;
15292 }
15293
15294 masks[maskcnt] = mystrdup (line_buf);
15295
15296 maskcnt++;
15297 }
15298
15299 fclose (mask_fp);
15300
15301 mask_from_file = 1;
15302 }
15303 else
15304 {
15305 maskcnt = 1;
15306
15307 masks[maskcnt - 1] = mystrdup (mask);
15308 }
15309 }
15310
15311 // base
15312
15313 int wls_left = myargc - (optind + 2);
15314
15315 for (int i = 0; i < wls_left; i++)
15316 {
15317 char *filename = myargv[optind + 2 + i];
15318
15319 struct stat file_stat;
15320
15321 if (stat (filename, &file_stat) == -1)
15322 {
15323 log_error ("ERROR: %s: %s", filename, strerror (errno));
15324
15325 return (-1);
15326 }
15327
15328 uint is_dir = S_ISDIR (file_stat.st_mode);
15329
15330 if (is_dir == 0)
15331 {
15332 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15333
15334 dictcnt++;
15335
15336 dictfiles[dictcnt - 1] = filename;
15337 }
15338 else
15339 {
15340 // do not allow --keyspace w/ a directory
15341
15342 if (keyspace == 1)
15343 {
15344 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15345
15346 return (-1);
15347 }
15348
15349 char **dictionary_files = NULL;
15350
15351 dictionary_files = scan_directory (filename);
15352
15353 if (dictionary_files != NULL)
15354 {
15355 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15356
15357 for (int d = 0; dictionary_files[d] != NULL; d++)
15358 {
15359 char *l1_filename = dictionary_files[d];
15360
15361 struct stat l1_stat;
15362
15363 if (stat (l1_filename, &l1_stat) == -1)
15364 {
15365 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15366
15367 return (-1);
15368 }
15369
15370 if (S_ISREG (l1_stat.st_mode))
15371 {
15372 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15373
15374 dictcnt++;
15375
15376 dictfiles[dictcnt - 1] = strdup (l1_filename);
15377 }
15378 }
15379 }
15380
15381 local_free (dictionary_files);
15382 }
15383 }
15384
15385 if (dictcnt < 1)
15386 {
15387 log_error ("ERROR: No usable dictionary file found.");
15388
15389 return (-1);
15390 }
15391
15392 if (increment)
15393 {
15394 maskcnt = 0;
15395
15396 uint mask_min = increment_min; // we can't reject smaller masks here
15397 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15398
15399 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15400 {
15401 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15402
15403 if (cur_mask == NULL) break;
15404
15405 masks[maskcnt] = cur_mask;
15406
15407 maskcnt++;
15408
15409 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15410 }
15411 }
15412 }
15413
15414 data.pw_min = pw_min;
15415 data.pw_max = pw_max;
15416
15417 /**
15418 * weak hash check
15419 */
15420
15421 if (weak_hash_threshold >= salts_cnt)
15422 {
15423 hc_device_param_t *device_param = NULL;
15424
15425 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15426 {
15427 device_param = &data.devices_param[device_id];
15428
15429 if (device_param->skipped) continue;
15430
15431 break;
15432 }
15433
15434 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15435
15436 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15437 {
15438 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15439 }
15440 }
15441
15442 // Display hack, guarantee that there is at least one \r before real start
15443
15444 if (data.quiet == 0) log_info_nn ("");
15445
15446 /**
15447 * status and monitor threads
15448 */
15449
15450 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15451
15452 hc_thread_t i_thread = 0;
15453
15454 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15455 {
15456 hc_thread_create (i_thread, thread_keypress, &benchmark);
15457 }
15458
15459 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15460
15461 uint ni_threads_cnt = 0;
15462
15463 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15464
15465 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15466
15467 ni_threads_cnt++;
15468
15469 /**
15470 * Outfile remove
15471 */
15472
15473 if (keyspace == 0)
15474 {
15475 if (outfile_check_timer != 0)
15476 {
15477 if (data.outfile_check_directory != NULL)
15478 {
15479 if ((hash_mode != 5200) &&
15480 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15481 (hash_mode != 9000))
15482 {
15483 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15484
15485 ni_threads_cnt++;
15486 }
15487 else
15488 {
15489 outfile_check_timer = 0;
15490 }
15491 }
15492 else
15493 {
15494 outfile_check_timer = 0;
15495 }
15496 }
15497 }
15498
15499 /**
15500 * Inform the user if we got some hashes remove because of the pot file remove feature
15501 */
15502
15503 if (data.quiet == 0)
15504 {
15505 if (potfile_remove_cracks > 0)
15506 {
15507 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15508 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15509 }
15510 }
15511
15512 data.outfile_check_timer = outfile_check_timer;
15513
15514 /**
15515 * main loop
15516 */
15517
15518 char **induction_dictionaries = NULL;
15519
15520 int induction_dictionaries_cnt = 0;
15521
15522 hcstat_table_t *root_table_buf = NULL;
15523 hcstat_table_t *markov_table_buf = NULL;
15524
15525 uint initial_restore_done = 0;
15526
15527 data.maskcnt = maskcnt;
15528
15529 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15530 {
15531 if (data.devices_status == STATUS_CRACKED) break;
15532
15533 data.devices_status = STATUS_INIT;
15534
15535 if (maskpos > rd->maskpos)
15536 {
15537 rd->dictpos = 0;
15538 }
15539
15540 rd->maskpos = maskpos;
15541 data.maskpos = maskpos;
15542
15543 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15544 {
15545 char *mask = masks[maskpos];
15546
15547 if (mask_from_file == 1)
15548 {
15549 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15550
15551 char *str_ptr;
15552 uint str_pos;
15553
15554 uint mask_offset = 0;
15555
15556 uint separator_cnt;
15557
15558 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15559 {
15560 str_ptr = strstr (mask + mask_offset, ",");
15561
15562 if (str_ptr == NULL) break;
15563
15564 str_pos = str_ptr - mask;
15565
15566 // escaped separator, i.e. "\,"
15567
15568 if (str_pos > 0)
15569 {
15570 if (mask[str_pos - 1] == '\\')
15571 {
15572 separator_cnt --;
15573
15574 mask_offset = str_pos + 1;
15575
15576 continue;
15577 }
15578 }
15579
15580 // reset the offset
15581
15582 mask_offset = 0;
15583
15584 mask[str_pos] = '\0';
15585
15586 switch (separator_cnt)
15587 {
15588 case 0:
15589 mp_reset_usr (mp_usr, 0);
15590
15591 custom_charset_1 = mask;
15592 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15593 break;
15594
15595 case 1:
15596 mp_reset_usr (mp_usr, 1);
15597
15598 custom_charset_2 = mask;
15599 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15600 break;
15601
15602 case 2:
15603 mp_reset_usr (mp_usr, 2);
15604
15605 custom_charset_3 = mask;
15606 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15607 break;
15608
15609 case 3:
15610 mp_reset_usr (mp_usr, 3);
15611
15612 custom_charset_4 = mask;
15613 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15614 break;
15615 }
15616
15617 mask = mask + str_pos + 1;
15618 }
15619 }
15620
15621 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15622 {
15623 if (maskpos > 0)
15624 {
15625 local_free (css_buf);
15626 local_free (data.root_css_buf);
15627 local_free (data.markov_css_buf);
15628
15629 local_free (masks[maskpos - 1]);
15630 }
15631
15632 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15633
15634 data.mask = mask;
15635 data.css_cnt = css_cnt;
15636 data.css_buf = css_buf;
15637
15638 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15639
15640 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15641
15642 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15643 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15644
15645 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15646
15647 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15648
15649 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15650 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15651
15652 data.root_css_buf = root_css_buf;
15653 data.markov_css_buf = markov_css_buf;
15654
15655 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15656
15657 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15658
15659 local_free (root_table_buf);
15660 local_free (markov_table_buf);
15661
15662 // args
15663
15664 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15665 {
15666 hc_device_param_t *device_param = &data.devices_param[device_id];
15667
15668 if (device_param->skipped) continue;
15669
15670 device_param->kernel_params_mp[0] = &device_param->d_combs;
15671 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15672 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15673
15674 device_param->kernel_params_mp_buf64[3] = 0;
15675 device_param->kernel_params_mp_buf32[4] = css_cnt;
15676 device_param->kernel_params_mp_buf32[5] = 0;
15677 device_param->kernel_params_mp_buf32[6] = 0;
15678 device_param->kernel_params_mp_buf32[7] = 0;
15679
15680 if (attack_mode == ATTACK_MODE_HYBRID1)
15681 {
15682 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15683 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15684 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15685 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15686 }
15687 else if (attack_mode == ATTACK_MODE_HYBRID2)
15688 {
15689 device_param->kernel_params_mp_buf32[5] = 0;
15690 device_param->kernel_params_mp_buf32[6] = 0;
15691 device_param->kernel_params_mp_buf32[7] = 0;
15692 }
15693
15694 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]);
15695 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]);
15696 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]);
15697
15698 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);
15699 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);
15700 }
15701 }
15702 else if (attack_mode == ATTACK_MODE_BF)
15703 {
15704 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15705
15706 if (increment)
15707 {
15708 for (uint i = 0; i < dictcnt; i++)
15709 {
15710 local_free (dictfiles[i]);
15711 }
15712
15713 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15714 {
15715 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15716
15717 if (l1_filename == NULL) break;
15718
15719 dictcnt++;
15720
15721 dictfiles[dictcnt - 1] = l1_filename;
15722 }
15723 }
15724 else
15725 {
15726 dictcnt++;
15727
15728 dictfiles[dictcnt - 1] = mask;
15729 }
15730
15731 if (dictcnt == 0)
15732 {
15733 log_error ("ERROR: Mask is too small");
15734
15735 return (-1);
15736 }
15737 }
15738 }
15739
15740 free (induction_dictionaries);
15741
15742 // induction_dictionaries_cnt = 0; // implied
15743
15744 if (attack_mode != ATTACK_MODE_BF)
15745 {
15746 if (keyspace == 0)
15747 {
15748 induction_dictionaries = scan_directory (induction_directory);
15749
15750 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15751 }
15752 }
15753
15754 if (induction_dictionaries_cnt)
15755 {
15756 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15757 }
15758
15759 /**
15760 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15761 */
15762 if (keyspace == 1)
15763 {
15764 if ((maskcnt > 1) || (dictcnt > 1))
15765 {
15766 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15767
15768 return (-1);
15769 }
15770 }
15771
15772 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15773 {
15774 char *subid = logfile_generate_subid ();
15775
15776 data.subid = subid;
15777
15778 logfile_sub_msg ("START");
15779
15780 data.devices_status = STATUS_INIT;
15781
15782 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15783 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15784 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15785
15786 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15787
15788 data.cpt_pos = 0;
15789
15790 data.cpt_start = time (NULL);
15791
15792 data.cpt_total = 0;
15793
15794 if (data.restore == 0)
15795 {
15796 rd->words_cur = skip;
15797
15798 skip = 0;
15799
15800 data.skip = 0;
15801 }
15802
15803 data.ms_paused = 0;
15804
15805 data.words_cur = rd->words_cur;
15806
15807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15808 {
15809 hc_device_param_t *device_param = &data.devices_param[device_id];
15810
15811 if (device_param->skipped) continue;
15812
15813 device_param->speed_pos = 0;
15814
15815 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15816 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15817 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15818
15819 device_param->kernel_power = device_param->kernel_power_user;
15820 device_param->kernel_blocks = device_param->kernel_blocks_user;
15821
15822 device_param->outerloop_pos = 0;
15823 device_param->outerloop_left = 0;
15824 device_param->innerloop_pos = 0;
15825 device_param->innerloop_left = 0;
15826
15827 // some more resets:
15828
15829 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15830
15831 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15832
15833 device_param->pw_cnt = 0;
15834 device_param->pws_cnt = 0;
15835
15836 device_param->words_off = 0;
15837 device_param->words_done = 0;
15838 }
15839
15840 data.kernel_blocks_div = 0;
15841
15842 // figure out some workload
15843
15844 if (attack_mode == ATTACK_MODE_STRAIGHT)
15845 {
15846 if (data.wordlist_mode == WL_MODE_FILE)
15847 {
15848 char *dictfile = NULL;
15849
15850 if (induction_dictionaries_cnt)
15851 {
15852 dictfile = induction_dictionaries[0];
15853 }
15854 else
15855 {
15856 dictfile = dictfiles[dictpos];
15857 }
15858
15859 data.dictfile = dictfile;
15860
15861 logfile_sub_string (dictfile);
15862
15863 for (uint i = 0; i < rp_files_cnt; i++)
15864 {
15865 logfile_sub_var_string ("rulefile", rp_files[i]);
15866 }
15867
15868 FILE *fd2 = fopen (dictfile, "rb");
15869
15870 if (fd2 == NULL)
15871 {
15872 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15873
15874 return (-1);
15875 }
15876
15877 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15878
15879 fclose (fd2);
15880
15881 if (data.words_cnt == 0)
15882 {
15883 if (data.devices_status == STATUS_CRACKED) break;
15884 if (data.devices_status == STATUS_ABORTED) break;
15885
15886 dictpos++;
15887
15888 continue;
15889 }
15890 }
15891 }
15892 else if (attack_mode == ATTACK_MODE_COMBI)
15893 {
15894 char *dictfile = data.dictfile;
15895 char *dictfile2 = data.dictfile2;
15896
15897 logfile_sub_string (dictfile);
15898 logfile_sub_string (dictfile2);
15899
15900 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15901 {
15902 FILE *fd2 = fopen (dictfile, "rb");
15903
15904 if (fd2 == NULL)
15905 {
15906 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15907
15908 return (-1);
15909 }
15910
15911 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15912
15913 fclose (fd2);
15914 }
15915 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15916 {
15917 FILE *fd2 = fopen (dictfile2, "rb");
15918
15919 if (fd2 == NULL)
15920 {
15921 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15922
15923 return (-1);
15924 }
15925
15926 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15927
15928 fclose (fd2);
15929 }
15930
15931 if (data.words_cnt == 0)
15932 {
15933 if (data.devices_status == STATUS_CRACKED) break;
15934 if (data.devices_status == STATUS_ABORTED) break;
15935
15936 dictpos++;
15937
15938 continue;
15939 }
15940 }
15941 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15942 {
15943 char *dictfile = NULL;
15944
15945 if (induction_dictionaries_cnt)
15946 {
15947 dictfile = induction_dictionaries[0];
15948 }
15949 else
15950 {
15951 dictfile = dictfiles[dictpos];
15952 }
15953
15954 data.dictfile = dictfile;
15955
15956 char *mask = data.mask;
15957
15958 logfile_sub_string (dictfile);
15959 logfile_sub_string (mask);
15960
15961 FILE *fd2 = fopen (dictfile, "rb");
15962
15963 if (fd2 == NULL)
15964 {
15965 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15966
15967 return (-1);
15968 }
15969
15970 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15971
15972 fclose (fd2);
15973
15974 if (data.words_cnt == 0)
15975 {
15976 if (data.devices_status == STATUS_CRACKED) break;
15977 if (data.devices_status == STATUS_ABORTED) break;
15978
15979 dictpos++;
15980
15981 continue;
15982 }
15983 }
15984 else if (attack_mode == ATTACK_MODE_BF)
15985 {
15986 local_free (css_buf);
15987 local_free (data.root_css_buf);
15988 local_free (data.markov_css_buf);
15989
15990 char *mask = dictfiles[dictpos];
15991
15992 logfile_sub_string (mask);
15993
15994 // base
15995
15996 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15997
15998 if (opts_type & OPTS_TYPE_PT_UNICODE)
15999 {
16000 uint css_cnt_unicode = css_cnt * 2;
16001
16002 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16003
16004 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16005 {
16006 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16007
16008 css_buf_unicode[j + 1].cs_buf[0] = 0;
16009 css_buf_unicode[j + 1].cs_len = 1;
16010 }
16011
16012 free (css_buf);
16013
16014 css_buf = css_buf_unicode;
16015 css_cnt = css_cnt_unicode;
16016 }
16017
16018 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16019
16020 uint mask_min = pw_min;
16021 uint mask_max = pw_max;
16022
16023 if (opts_type & OPTS_TYPE_PT_UNICODE)
16024 {
16025 mask_min *= 2;
16026 mask_max *= 2;
16027 }
16028
16029 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16030 {
16031 if (css_cnt < mask_min)
16032 {
16033 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16034 }
16035
16036 if (css_cnt > mask_max)
16037 {
16038 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16039 }
16040
16041 // skip to next mask
16042
16043 dictpos++;
16044
16045 rd->dictpos = dictpos;
16046
16047 logfile_sub_msg ("STOP");
16048
16049 continue;
16050 }
16051
16052 uint save_css_cnt = css_cnt;
16053
16054 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16055 {
16056 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16057 {
16058 uint salt_len = (uint) data.salts_buf[0].salt_len;
16059 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16060
16061 uint css_cnt_salt = css_cnt + salt_len;
16062
16063 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16064
16065 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16066
16067 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16068 {
16069 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16070 css_buf_salt[j].cs_len = 1;
16071 }
16072
16073 free (css_buf);
16074
16075 css_buf = css_buf_salt;
16076 css_cnt = css_cnt_salt;
16077 }
16078 }
16079
16080 data.mask = mask;
16081 data.css_cnt = css_cnt;
16082 data.css_buf = css_buf;
16083
16084 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16085
16086 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16087
16088 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16089
16090 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16091 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16092
16093 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16094
16095 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16096
16097 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16098 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16099
16100 data.root_css_buf = root_css_buf;
16101 data.markov_css_buf = markov_css_buf;
16102
16103 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16104
16105 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16106
16107 local_free (root_table_buf);
16108 local_free (markov_table_buf);
16109
16110 // copy + args
16111
16112 uint css_cnt_l = css_cnt;
16113 uint css_cnt_r;
16114
16115 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16116 {
16117 if (save_css_cnt < 6)
16118 {
16119 css_cnt_r = 1;
16120 }
16121 else if (save_css_cnt == 6)
16122 {
16123 css_cnt_r = 2;
16124 }
16125 else
16126 {
16127 if (opts_type & OPTS_TYPE_PT_UNICODE)
16128 {
16129 if (save_css_cnt == 8 || save_css_cnt == 10)
16130 {
16131 css_cnt_r = 2;
16132 }
16133 else
16134 {
16135 css_cnt_r = 4;
16136 }
16137 }
16138 else
16139 {
16140 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16141 {
16142 css_cnt_r = 3;
16143 }
16144 else
16145 {
16146 css_cnt_r = 4;
16147 }
16148 }
16149 }
16150 }
16151 else
16152 {
16153 css_cnt_r = 1;
16154
16155 /* unfinished code?
16156 int sum = css_buf[css_cnt_r - 1].cs_len;
16157
16158 for (uint i = 1; i < 4 && i < css_cnt; i++)
16159 {
16160 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16161
16162 css_cnt_r++;
16163
16164 sum *= css_buf[css_cnt_r - 1].cs_len;
16165 }
16166 */
16167 }
16168
16169 css_cnt_l -= css_cnt_r;
16170
16171 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16172
16173 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16174 {
16175 hc_device_param_t *device_param = &data.devices_param[device_id];
16176
16177 if (device_param->skipped) continue;
16178
16179 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16180 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16181 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16182
16183 device_param->kernel_params_mp_l_buf64[3] = 0;
16184 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16185 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16186 device_param->kernel_params_mp_l_buf32[6] = 0;
16187 device_param->kernel_params_mp_l_buf32[7] = 0;
16188 device_param->kernel_params_mp_l_buf32[8] = 0;
16189
16190 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16191 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16192 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16193 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16194
16195 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16196 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16197 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16198
16199 device_param->kernel_params_mp_r_buf64[3] = 0;
16200 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16201 device_param->kernel_params_mp_r_buf32[5] = 0;
16202 device_param->kernel_params_mp_r_buf32[6] = 0;
16203 device_param->kernel_params_mp_r_buf32[7] = 0;
16204
16205 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]);
16206 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]);
16207 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]);
16208
16209 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]);
16210 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]);
16211 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]);
16212
16213 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);
16214 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);
16215 }
16216 }
16217
16218 u64 words_base = data.words_cnt;
16219
16220 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16221 {
16222 if (data.kernel_rules_cnt)
16223 {
16224 words_base /= data.kernel_rules_cnt;
16225 }
16226 }
16227 else if (data.attack_kern == ATTACK_KERN_COMBI)
16228 {
16229 if (data.combs_cnt)
16230 {
16231 words_base /= data.combs_cnt;
16232 }
16233 }
16234 else if (data.attack_kern == ATTACK_KERN_BF)
16235 {
16236 if (data.bfs_cnt)
16237 {
16238 words_base /= data.bfs_cnt;
16239 }
16240 }
16241
16242 data.words_base = words_base;
16243
16244 if (keyspace == 1)
16245 {
16246 log_info ("%llu", (unsigned long long int) words_base);
16247
16248 return (0);
16249 }
16250
16251 if (data.words_cur > data.words_base)
16252 {
16253 log_error ("ERROR: restore value greater keyspace");
16254
16255 return (-1);
16256 }
16257
16258 if (data.words_cur)
16259 {
16260 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16261 {
16262 for (uint i = 0; i < data.salts_cnt; i++)
16263 {
16264 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16265 }
16266 }
16267 else if (data.attack_kern == ATTACK_KERN_COMBI)
16268 {
16269 for (uint i = 0; i < data.salts_cnt; i++)
16270 {
16271 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16272 }
16273 }
16274 else if (data.attack_kern == ATTACK_KERN_BF)
16275 {
16276 for (uint i = 0; i < data.salts_cnt; i++)
16277 {
16278 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16279 }
16280 }
16281 }
16282
16283 /*
16284 * Inform user about possible slow speeds
16285 */
16286
16287 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16288 {
16289 if (data.words_base < kernel_blocks_all)
16290 {
16291 if (quiet == 0)
16292 {
16293 log_info ("");
16294 log_info ("ATTENTION!");
16295 log_info (" The wordlist or mask you are using is too small.");
16296 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16297 log_info (" The cracking speed will drop.");
16298 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16299 log_info ("");
16300 }
16301 }
16302 }
16303
16304 /*
16305 * Update loopback file
16306 */
16307
16308 if (loopback == 1)
16309 {
16310 time_t now;
16311
16312 time (&now);
16313
16314 uint random_num = get_random_num (0, 9999);
16315
16316 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16317
16318 data.loopback_file = loopback_file;
16319 }
16320
16321 /*
16322 * Update dictionary statistic
16323 */
16324
16325 if (keyspace == 0)
16326 {
16327 dictstat_fp = fopen (dictstat, "wb");
16328
16329 if (dictstat_fp)
16330 {
16331 lock_file (dictstat_fp);
16332
16333 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16334
16335 fclose (dictstat_fp);
16336 }
16337 }
16338
16339 data.devices_status = STATUS_RUNNING;
16340
16341 if (initial_restore_done == 0)
16342 {
16343 if (data.restore_disable == 0) cycle_restore ();
16344
16345 initial_restore_done = 1;
16346 }
16347
16348 hc_timer_set (&data.timer_running);
16349
16350 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16351 {
16352 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16353 {
16354 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16355 if (quiet == 0) fflush (stdout);
16356 }
16357 }
16358 else if (wordlist_mode == WL_MODE_STDIN)
16359 {
16360 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16361 if (data.quiet == 0) log_info ("");
16362 }
16363
16364 time_t runtime_start;
16365
16366 time (&runtime_start);
16367
16368 data.runtime_start = runtime_start;
16369
16370 /**
16371 * create cracker threads
16372 */
16373
16374 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16375
16376 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16377 {
16378 hc_device_param_t *device_param = &devices_param[device_id];
16379
16380 if (wordlist_mode == WL_MODE_STDIN)
16381 {
16382 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16383 }
16384 else
16385 {
16386 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16387 }
16388 }
16389
16390 // wait for crack threads to exit
16391
16392 hc_thread_wait (devices_cnt, c_threads);
16393
16394 local_free (c_threads);
16395
16396 data.restore = 0;
16397
16398 // finalize task
16399
16400 logfile_sub_var_uint ("status-after-work", data.devices_status);
16401
16402 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16403
16404 if (data.devices_status == STATUS_CRACKED) break;
16405 if (data.devices_status == STATUS_ABORTED) break;
16406
16407 if (data.devices_status == STATUS_BYPASS)
16408 {
16409 data.devices_status = STATUS_RUNNING;
16410 }
16411
16412 if (induction_dictionaries_cnt)
16413 {
16414 unlink (induction_dictionaries[0]);
16415 }
16416
16417 free (induction_dictionaries);
16418
16419 if (attack_mode != ATTACK_MODE_BF)
16420 {
16421 induction_dictionaries = scan_directory (induction_directory);
16422
16423 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16424 }
16425
16426 if (benchmark == 0)
16427 {
16428 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16429 {
16430 if (quiet == 0) clear_prompt ();
16431
16432 if (quiet == 0) log_info ("");
16433
16434 if (status == 1)
16435 {
16436 status_display ();
16437 }
16438 else
16439 {
16440 if (quiet == 0) status_display ();
16441 }
16442
16443 if (quiet == 0) log_info ("");
16444 }
16445 }
16446
16447 if (attack_mode == ATTACK_MODE_BF)
16448 {
16449 dictpos++;
16450
16451 rd->dictpos = dictpos;
16452 }
16453 else
16454 {
16455 if (induction_dictionaries_cnt)
16456 {
16457 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16458 }
16459 else
16460 {
16461 dictpos++;
16462
16463 rd->dictpos = dictpos;
16464 }
16465 }
16466
16467 time_t runtime_stop;
16468
16469 time (&runtime_stop);
16470
16471 data.runtime_stop = runtime_stop;
16472
16473 logfile_sub_uint (runtime_start);
16474 logfile_sub_uint (runtime_stop);
16475
16476 logfile_sub_msg ("STOP");
16477
16478 global_free (subid);
16479 }
16480
16481 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16482
16483 if (data.devices_status == STATUS_CRACKED) break;
16484 if (data.devices_status == STATUS_ABORTED) break;
16485 if (data.devices_status == STATUS_QUIT) break;
16486
16487 if (data.devices_status == STATUS_BYPASS)
16488 {
16489 data.devices_status = STATUS_RUNNING;
16490 }
16491 }
16492
16493 // 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
16494
16495 if (attack_mode == ATTACK_MODE_STRAIGHT)
16496 {
16497 if (data.wordlist_mode == WL_MODE_FILE)
16498 {
16499 if (data.dictfile == NULL)
16500 {
16501 if (dictfiles != NULL)
16502 {
16503 data.dictfile = dictfiles[0];
16504
16505 hc_timer_set (&data.timer_running);
16506 }
16507 }
16508 }
16509 }
16510 // NOTE: combi is okay because it is already set beforehand
16511 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16512 {
16513 if (data.dictfile == NULL)
16514 {
16515 if (dictfiles != NULL)
16516 {
16517 hc_timer_set (&data.timer_running);
16518
16519 data.dictfile = dictfiles[0];
16520 }
16521 }
16522 }
16523 else if (attack_mode == ATTACK_MODE_BF)
16524 {
16525 if (data.mask == NULL)
16526 {
16527 hc_timer_set (&data.timer_running);
16528
16529 data.mask = masks[0];
16530 }
16531 }
16532
16533 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16534 {
16535 data.devices_status = STATUS_EXHAUSTED;
16536 }
16537
16538 // if cracked / aborted remove last induction dictionary
16539
16540 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16541 {
16542 struct stat induct_stat;
16543
16544 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16545 {
16546 unlink (induction_dictionaries[file_pos]);
16547 }
16548 }
16549
16550 // wait for non-interactive threads
16551
16552 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16553 {
16554 hc_thread_wait (1, &ni_threads[thread_idx]);
16555 }
16556
16557 local_free (ni_threads);
16558
16559 // wait for interactive threads
16560
16561 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16562 {
16563 hc_thread_wait (1, &i_thread);
16564 }
16565
16566 // we dont need restore file anymore
16567 if (data.restore_disable == 0)
16568 {
16569 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16570 {
16571 unlink (eff_restore_file);
16572 unlink (new_restore_file);
16573 }
16574 else
16575 {
16576 cycle_restore ();
16577 }
16578 }
16579
16580 // finally save left hashes
16581
16582 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16583 {
16584 save_hash ();
16585 }
16586
16587 /**
16588 * Clean up
16589 */
16590
16591 if (benchmark == 1)
16592 {
16593 status_benchmark ();
16594
16595 log_info ("");
16596 }
16597 else
16598 {
16599 if (quiet == 0) clear_prompt ();
16600
16601 if (quiet == 0) log_info ("");
16602
16603 if (status == 1)
16604 {
16605 status_display ();
16606 }
16607 else
16608 {
16609 if (quiet == 0) status_display ();
16610 }
16611
16612 if (quiet == 0) log_info ("");
16613 }
16614
16615 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16616 {
16617 hc_device_param_t *device_param = &data.devices_param[device_id];
16618
16619 if (device_param->skipped) continue;
16620
16621 local_free (device_param->result);
16622
16623 local_free (device_param->pw_caches);
16624
16625 local_free (device_param->combs_buf);
16626
16627 local_free (device_param->hooks_buf);
16628
16629 local_free (device_param->device_name);
16630
16631 local_free (device_param->device_name_chksum);
16632
16633 local_free (device_param->device_version);
16634
16635 local_free (device_param->driver_version);
16636
16637 if (device_param->pws_buf) myfree (device_param->pws_buf);
16638 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16639 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16640 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16641 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16642 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16643 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16644 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16645 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16646 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16647 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16648 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16649 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16650 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16651 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16652 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16653 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16654 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16655 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16656 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16657 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16658 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16659 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16660 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16661 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16662 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16663 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16664 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16665 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16666
16667 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16668 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16669 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16670 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16671 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16672 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16673 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16674 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16675 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16676 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16677 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16678
16679 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16680 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16681 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16682
16683 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16684 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16685 }
16686
16687 // reset default fan speed
16688
16689 #ifdef HAVE_HWMON
16690 if (gpu_temp_disable == 0)
16691 {
16692 #ifdef HAVE_ADL
16693 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16694 {
16695 hc_thread_mutex_lock (mux_adl);
16696
16697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16698 {
16699 hc_device_param_t *device_param = &data.devices_param[device_id];
16700
16701 if (device_param->skipped) continue;
16702
16703 if (data.hm_device[device_id].fan_supported == 1)
16704 {
16705 int fanspeed = temp_retain_fanspeed_value[device_id];
16706
16707 if (fanspeed == -1) continue;
16708
16709 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16710
16711 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16712 }
16713 }
16714
16715 hc_thread_mutex_unlock (mux_adl);
16716 }
16717 #endif // HAVE_ADL
16718 }
16719
16720 #ifdef HAVE_ADL
16721 // reset power tuning
16722
16723 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16724 {
16725 hc_thread_mutex_lock (mux_adl);
16726
16727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16728 {
16729 hc_device_param_t *device_param = &data.devices_param[device_id];
16730
16731 if (device_param->skipped) continue;
16732
16733 if (data.hm_device[device_id].od_version == 6)
16734 {
16735 // check powertune capabilities first, if not available then skip device
16736
16737 int powertune_supported = 0;
16738
16739 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16740 {
16741 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16742
16743 return (-1);
16744 }
16745
16746 if (powertune_supported != 0)
16747 {
16748 // powercontrol settings
16749
16750 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)
16751 {
16752 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16753
16754 return (-1);
16755 }
16756
16757 // clocks
16758
16759 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16760
16761 performance_state->iNumberOfPerformanceLevels = 2;
16762
16763 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16764 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16765 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16766 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16767
16768 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)
16769 {
16770 log_info ("ERROR: Failed to restore ADL performance state");
16771
16772 return (-1);
16773 }
16774
16775 local_free (performance_state);
16776 }
16777 }
16778 }
16779
16780 hc_thread_mutex_unlock (mux_adl);
16781 }
16782 #endif // HAVE_ADL
16783
16784 if (gpu_temp_disable == 0)
16785 {
16786 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16787 if (data.hm_nv)
16788 {
16789 #if defined(LINUX) && defined(HAVE_NVML)
16790
16791 hm_NVML_nvmlShutdown (data.hm_nv);
16792
16793 nvml_close (data.hm_nv);
16794
16795 #elif defined(WIN) && (HAVE_NVAPI)
16796
16797 hm_NvAPI_Unload (data.hm_nv);
16798
16799 nvapi_close (data.hm_nv);
16800
16801 #endif
16802
16803 data.hm_nv = NULL;
16804 }
16805 #endif
16806
16807 #ifdef HAVE_ADL
16808 if (data.hm_amd)
16809 {
16810 hm_ADL_Main_Control_Destroy (data.hm_amd);
16811
16812 adl_close (data.hm_amd);
16813 data.hm_amd = NULL;
16814 }
16815 #endif
16816 }
16817 #endif // HAVE_HWMON
16818
16819 // free memory
16820
16821 local_free (masks);
16822
16823 local_free (dictstat_base);
16824
16825 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16826 {
16827 pot_t *pot_ptr = &pot[pot_pos];
16828
16829 hash_t *hash = &pot_ptr->hash;
16830
16831 local_free (hash->digest);
16832
16833 if (isSalted)
16834 {
16835 local_free (hash->salt);
16836 }
16837 }
16838
16839 local_free (pot);
16840
16841 local_free (all_kernel_rules_cnt);
16842 local_free (all_kernel_rules_buf);
16843
16844 local_free (wl_data->buf);
16845 local_free (wl_data);
16846
16847 local_free (bitmap_s1_a);
16848 local_free (bitmap_s1_b);
16849 local_free (bitmap_s1_c);
16850 local_free (bitmap_s1_d);
16851 local_free (bitmap_s2_a);
16852 local_free (bitmap_s2_b);
16853 local_free (bitmap_s2_c);
16854 local_free (bitmap_s2_d);
16855
16856 #ifdef HAVE_HWMON
16857 local_free (temp_retain_fanspeed_value);
16858 #ifdef HAVE_ADL
16859 local_free (od_clock_mem_status);
16860 local_free (od_power_control_status);
16861 #endif // ADL
16862 #endif
16863
16864 global_free (devices_param);
16865
16866 global_free (kernel_rules_buf);
16867
16868 global_free (root_css_buf);
16869 global_free (markov_css_buf);
16870
16871 global_free (digests_buf);
16872 global_free (digests_shown);
16873 global_free (digests_shown_tmp);
16874
16875 global_free (salts_buf);
16876 global_free (salts_shown);
16877
16878 global_free (esalts_buf);
16879
16880 global_free (words_progress_done);
16881 global_free (words_progress_rejected);
16882 global_free (words_progress_restored);
16883
16884 if (pot_fp) fclose (pot_fp);
16885
16886 if (data.devices_status == STATUS_QUIT) break;
16887 }
16888
16889 // destroy others mutex
16890
16891 hc_thread_mutex_delete (mux_dispatcher);
16892 hc_thread_mutex_delete (mux_counter);
16893 hc_thread_mutex_delete (mux_display);
16894 hc_thread_mutex_delete (mux_adl);
16895
16896 // free memory
16897
16898 local_free (eff_restore_file);
16899 local_free (new_restore_file);
16900
16901 local_free (rd);
16902
16903 // loopback
16904
16905 local_free (loopback_file);
16906
16907 if (loopback == 1) unlink (loopback_file);
16908
16909 // induction directory
16910
16911 if (induction_dir == NULL)
16912 {
16913 if (attack_mode != ATTACK_MODE_BF)
16914 {
16915 if (rmdir (induction_directory) == -1)
16916 {
16917 if (errno == ENOENT)
16918 {
16919 // good, we can ignore
16920 }
16921 else if (errno == ENOTEMPTY)
16922 {
16923 // good, we can ignore
16924 }
16925 else
16926 {
16927 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16928
16929 return (-1);
16930 }
16931 }
16932
16933 local_free (induction_directory);
16934 }
16935 }
16936
16937 // outfile-check directory
16938
16939 if (outfile_check_dir == NULL)
16940 {
16941 if (rmdir (outfile_check_directory) == -1)
16942 {
16943 if (errno == ENOENT)
16944 {
16945 // good, we can ignore
16946 }
16947 else if (errno == ENOTEMPTY)
16948 {
16949 // good, we can ignore
16950 }
16951 else
16952 {
16953 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16954
16955 return (-1);
16956 }
16957 }
16958
16959 local_free (outfile_check_directory);
16960 }
16961
16962 time_t proc_stop;
16963
16964 time (&proc_stop);
16965
16966 logfile_top_uint (proc_start);
16967 logfile_top_uint (proc_stop);
16968
16969 logfile_top_msg ("STOP");
16970
16971 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16972 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16973
16974 if (data.ocl) ocl_close (data.ocl);
16975
16976 if (data.devices_status == STATUS_ABORTED) return 2;
16977 if (data.devices_status == STATUS_QUIT) return 2;
16978 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16979 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16980 if (data.devices_status == STATUS_CRACKED) return 0;
16981
16982 return -1;
16983 }
Hashcat additions to support pwdhash