projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Prepare for better autotuning capabilities
[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 double TARGET_MS_PROFILE[3] = { 8, 24, 72 };
22
23 #define INCR_RULES 10000
24 #define INCR_SALTS 100000
25 #define INCR_MASKS 1000
26 #define INCR_POT 1000
27
28 #define USAGE 0
29 #define VERSION 0
30 #define QUIET 0
31 #define MARKOV_THRESHOLD 0
32 #define MARKOV_DISABLE 0
33 #define MARKOV_CLASSIC 0
34 #define BENCHMARK 0
35 #define RESTORE 0
36 #define RESTORE_TIMER 60
37 #define RESTORE_DISABLE 0
38 #define STATUS 0
39 #define STATUS_TIMER 10
40 #define STATUS_AUTOMAT 0
41 #define LOOPBACK 0
42 #define WEAK_HASH_THRESHOLD 100
43 #define SHOW 0
44 #define LEFT 0
45 #define USERNAME 0
46 #define REMOVE 0
47 #define REMOVE_TIMER 60
48 #define SKIP 0
49 #define LIMIT 0
50 #define KEYSPACE 0
51 #define POTFILE_DISABLE 0
52 #define DEBUG_MODE 0
53 #define RP_GEN 0
54 #define RP_GEN_FUNC_MIN 1
55 #define RP_GEN_FUNC_MAX 4
56 #define RP_GEN_SEED 0
57 #define RULE_BUF_L ":"
58 #define RULE_BUF_R ":"
59 #define FORCE 0
60 #define RUNTIME 0
61 #define HEX_CHARSET 0
62 #define HEX_SALT 0
63 #define HEX_WORDLIST 0
64 #define OUTFILE_FORMAT 3
65 #define OUTFILE_AUTOHEX 1
66 #define OUTFILE_CHECK_TIMER 5
67 #define ATTACK_MODE 0
68 #define HASH_MODE 0
69 #define SEGMENT_SIZE 32
70 #define INCREMENT 0
71 #define INCREMENT_MIN 1
72 #define INCREMENT_MAX PW_MAX
73 #define SEPARATOR ':'
74 #define BITMAP_MIN 16
75 #define BITMAP_MAX 24
76 #define GPU_TEMP_DISABLE 0
77 #define GPU_TEMP_ABORT 90
78 #define GPU_TEMP_RETAIN 80
79 #define WORKLOAD_PROFILE 2
80 #define KERNEL_ACCEL 0
81 #define KERNEL_LOOPS 0
82 #define KERNEL_RULES 1024
83 #define KERNEL_COMBS 1024
84 #define KERNEL_BFS 1024
85 #define KERNEL_THREADS 64
86 #define POWERTUNE_ENABLE 0
87 #define LOGFILE_DISABLE 0
88 #define SCRYPT_TMTO 0
89 #define OPENCL_VECTOR_WIDTH 0
90
91 #define WL_MODE_STDIN 1
92 #define WL_MODE_FILE 2
93 #define WL_MODE_MASK 3
94
95 #define HL_MODE_FILE 4
96 #define HL_MODE_ARG 5
97
98 #define HLFMT_HASHCAT 0
99 #define HLFMT_PWDUMP 1
100 #define HLFMT_PASSWD 2
101 #define HLFMT_SHADOW 3
102 #define HLFMT_DCC 4
103 #define HLFMT_DCC2 5
104 #define HLFMT_NETNTLM1 7
105 #define HLFMT_NETNTLM2 8
106 #define HLFMT_NSLDAP 9
107 #define HLFMT_NSLDAPS 10
108 #define HLFMTS_CNT 11
109
110 #define ATTACK_MODE_STRAIGHT 0
111 #define ATTACK_MODE_COMBI 1
112 #define ATTACK_MODE_TOGGLE 2
113 #define ATTACK_MODE_BF 3
114 #define ATTACK_MODE_PERM 4
115 #define ATTACK_MODE_TABLE 5
116 #define ATTACK_MODE_HYBRID1 6
117 #define ATTACK_MODE_HYBRID2 7
118 #define ATTACK_MODE_NONE 100
119
120 #define ATTACK_KERN_STRAIGHT 0
121 #define ATTACK_KERN_COMBI 1
122 #define ATTACK_KERN_BF 3
123 #define ATTACK_KERN_NONE 100
124
125 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
126 #define ATTACK_EXEC_INSIDE_KERNEL 11
127
128 #define COMBINATOR_MODE_BASE_LEFT 10001
129 #define COMBINATOR_MODE_BASE_RIGHT 10002
130
131 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
132 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
133
134 #define MAX_CUT_TRIES 4
135
136 #define MAX_DICTSTAT 10000
137
138 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
139
140 #define global_free(attr) \
141 { \
142 myfree ((void *) data.attr); \
143 \
144 data.attr = NULL; \
145 }
146
147 #define local_free(attr) \
148 { \
149 myfree ((void *) attr); \
150 \
151 attr = NULL; \
152 }
153
154 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
155 {
156 900,
157 0,
158 5100,
159 100,
160 1400,
161 10800,
162 1700,
163 5000,
164 10100,
165 6000,
166 6100,
167 6900,
168 11700,
169 11800,
170 400,
171 8900,
172 11900,
173 12000,
174 10900,
175 12100,
176 23,
177 2500,
178 5300,
179 5400,
180 5500,
181 5600,
182 7300,
183 7500,
184 8300,
185 11100,
186 11200,
187 11400,
188 121,
189 2611,
190 2711,
191 2811,
192 8400,
193 11,
194 2612,
195 7900,
196 21,
197 11000,
198 124,
199 10000,
200 3711,
201 7600,
202 12,
203 131,
204 132,
205 1731,
206 200,
207 300,
208 3100,
209 112,
210 12300,
211 8000,
212 141,
213 1441,
214 1600,
215 12600,
216 1421,
217 101,
218 111,
219 1711,
220 3000, // broken in osx
221 1000,
222 1100,
223 2100,
224 12800,
225 1500, // broken in osx
226 12400,
227 500,
228 3200,
229 7400,
230 1800,
231 122,
232 1722,
233 7100,
234 6300,
235 6700,
236 6400,
237 6500,
238 2400,
239 2410,
240 5700,
241 9200,
242 9300,
243 22,
244 501,
245 5800,
246 8100,
247 8500,
248 7200,
249 9900,
250 7700,
251 7800,
252 10300,
253 8600,
254 8700,
255 9100,
256 133,
257 11600,
258 12500,
259 13000,
260 6211,
261 6221,
262 6231,
263 6241,
264 8800,
265 12900,
266 12200,
267 9700,
268 9710,
269 9800,
270 9810,
271 9400,
272 9500,
273 9600,
274 10400,
275 10410,
276 10500,
277 10600,
278 10700, // broken in osx
279 9000,
280 5200,
281 6800,
282 6600,
283 8200,
284 11300,
285 12700
286 };
287
288 /**
289 * types
290 */
291
292 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
293
294 /**
295 * globals
296 */
297
298 static unsigned int full01 = 0x01010101;
299 static unsigned int full80 = 0x80808080;
300
301 int SUPPRESS_OUTPUT = 0;
302
303 hc_thread_mutex_t mux_adl;
304 hc_thread_mutex_t mux_counter;
305 hc_thread_mutex_t mux_dispatcher;
306 hc_thread_mutex_t mux_display;
307
308 hc_global_data_t data;
309
310 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
311
312 const char *USAGE_MINI[] =
313 {
314 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
315 "",
316 "Try --help for more help.",
317 NULL
318 };
319
320 const char *USAGE_BIG[] =
321 {
322 "%s, advanced password recovery",
323 "",
324 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
325 "",
326 "=======",
327 "Options",
328 "=======",
329 "",
330 "* General:",
331 "",
332 " -m, --hash-type=NUM Hash-type, see references below",
333 " -a, --attack-mode=NUM Attack-mode, see references below",
334 " -V, --version Print version",
335 " -h, --help Print help",
336 " --quiet Suppress output",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -b, --benchmark Run benchmark",
387 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
388 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
389 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
390 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
391 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
392 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
393 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
394 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
395 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
396 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
397 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
398 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
399 #ifdef HAVE_HWMON
400 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
401 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
402 #ifdef HAVE_ADL
403 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
404 #endif
405 #endif
406 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
407 "",
408 "* Distributed:",
409 "",
410 " -s, --skip=NUM Skip number of words",
411 " -l, --limit=NUM Limit number of words",
412 " --keyspace Show keyspace base:mod values and quit",
413 "",
414 "* Rules:",
415 "",
416 " -j, --rule-left=RULE Single rule applied to each word from left dict",
417 " -k, --rule-right=RULE Single rule applied to each word from right dict",
418 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
419 " -g, --generate-rules=NUM Generate NUM random rules",
420 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
421 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
422 " --generate-rules-seed=NUM Force RNG seed to NUM",
423 "",
424 "* Custom charsets:",
425 "",
426 " -1, --custom-charset1=CS User-defined charsets",
427 " -2, --custom-charset2=CS Example:",
428 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
429 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
430 "",
431 "* Increment:",
432 "",
433 " -i, --increment Enable increment mode",
434 " --increment-min=NUM Start incrementing at NUM",
435 " --increment-max=NUM Stop incrementing at NUM",
436 "",
437 "==========",
438 "References",
439 "==========",
440 "",
441 "* Workload Profile:",
442 "",
443 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
444 " 2 = Default performance profile, kernel execution runtime to 24ms, economic setting",
445 " 3 = Headless performance profile, kernel execution runtime to 72ms, higher latency desktop, higher speed",
446 "",
447 "* OpenCL device-types:",
448 "",
449 " 1 = CPU devices",
450 " 2 = GPU devices",
451 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
452 "",
453 "* Outfile Formats:",
454 "",
455 " 1 = hash[:salt]",
456 " 2 = plain",
457 " 3 = hash[:salt]:plain",
458 " 4 = hex_plain",
459 " 5 = hash[:salt]:hex_plain",
460 " 6 = plain:hex_plain",
461 " 7 = hash[:salt]:plain:hex_plain",
462 " 8 = crackpos",
463 " 9 = hash[:salt]:crackpos",
464 " 10 = plain:crackpos",
465 " 11 = hash[:salt]:plain:crackpos",
466 " 12 = hex_plain:crackpos",
467 " 13 = hash[:salt]:hex_plain:crackpos",
468 " 14 = plain:hex_plain:crackpos",
469 " 15 = hash[:salt]:plain:hex_plain:crackpos",
470 "",
471 "* Debug mode output formats (for hybrid mode only, by using rules):",
472 "",
473 " 1 = save finding rule",
474 " 2 = save original word",
475 " 3 = save original word and finding rule",
476 " 4 = save original word, finding rule and modified plain",
477 "",
478 "* Built-in charsets:",
479 "",
480 " ?l = abcdefghijklmnopqrstuvwxyz",
481 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
482 " ?d = 0123456789",
483 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
484 " ?a = ?l?u?d?s",
485 " ?b = 0x00 - 0xff",
486 "",
487 "* Attack modes:",
488 "",
489 " 0 = Straight",
490 " 1 = Combination",
491 " 3 = Brute-force",
492 " 6 = Hybrid dict + mask",
493 " 7 = Hybrid mask + dict",
494 "",
495 "* Hash types:",
496 "",
497 "[[ Roll-your-own: Raw Hashes ]]",
498 "",
499 " 900 = MD4",
500 " 0 = MD5",
501 " 5100 = Half MD5",
502 " 100 = SHA1",
503 " 10800 = SHA-384",
504 " 1400 = SHA-256",
505 " 1700 = SHA-512",
506 " 5000 = SHA-3(Keccak)",
507 " 10100 = SipHash",
508 " 6000 = RipeMD160",
509 " 6100 = Whirlpool",
510 " 6900 = GOST R 34.11-94",
511 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
512 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
513 "",
514 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
515 "",
516 " 10 = md5($pass.$salt)",
517 " 20 = md5($salt.$pass)",
518 " 30 = md5(unicode($pass).$salt)",
519 " 40 = md5($salt.unicode($pass))",
520 " 3800 = md5($salt.$pass.$salt)",
521 " 3710 = md5($salt.md5($pass))",
522 " 2600 = md5(md5($pass)",
523 " 4300 = md5(strtoupper(md5($pass)))",
524 " 4400 = md5(sha1($pass))",
525 " 110 = sha1($pass.$salt)",
526 " 120 = sha1($salt.$pass)",
527 " 130 = sha1(unicode($pass).$salt)",
528 " 140 = sha1($salt.unicode($pass))",
529 " 4500 = sha1(sha1($pass)",
530 " 4700 = sha1(md5($pass))",
531 " 4900 = sha1($salt.$pass.$salt)",
532 " 1410 = sha256($pass.$salt)",
533 " 1420 = sha256($salt.$pass)",
534 " 1430 = sha256(unicode($pass).$salt)",
535 " 1440 = sha256($salt.unicode($pass))",
536 " 1710 = sha512($pass.$salt)",
537 " 1720 = sha512($salt.$pass)",
538 " 1730 = sha512(unicode($pass).$salt)",
539 " 1740 = sha512($salt.unicode($pass))",
540 "",
541 "[[ Roll-your-own: Authenticated Hashes ]]",
542 "",
543 " 50 = HMAC-MD5 (key = $pass)",
544 " 60 = HMAC-MD5 (key = $salt)",
545 " 150 = HMAC-SHA1 (key = $pass)",
546 " 160 = HMAC-SHA1 (key = $salt)",
547 " 1450 = HMAC-SHA256 (key = $pass)",
548 " 1460 = HMAC-SHA256 (key = $salt)",
549 " 1750 = HMAC-SHA512 (key = $pass)",
550 " 1760 = HMAC-SHA512 (key = $salt)",
551 "",
552 "[[ Generic KDF ]]",
553 "",
554 " 400 = phpass",
555 " 8900 = scrypt",
556 " 11900 = PBKDF2-HMAC-MD5",
557 " 12000 = PBKDF2-HMAC-SHA1",
558 " 10900 = PBKDF2-HMAC-SHA256",
559 " 12100 = PBKDF2-HMAC-SHA512",
560 "",
561 "[[ Network protocols, Challenge-Response ]]",
562 "",
563 " 23 = Skype",
564 " 2500 = WPA/WPA2",
565 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
566 " 5300 = IKE-PSK MD5",
567 " 5400 = IKE-PSK SHA1",
568 " 5500 = NetNTLMv1",
569 " 5500 = NetNTLMv1 + ESS",
570 " 5600 = NetNTLMv2",
571 " 7300 = IPMI2 RAKP HMAC-SHA1",
572 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
573 " 8300 = DNSSEC (NSEC3)",
574 " 10200 = Cram MD5",
575 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
576 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
577 " 11400 = SIP digest authentication (MD5)",
578 "",
579 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
580 "",
581 " 121 = SMF (Simple Machines Forum)",
582 " 400 = phpBB3",
583 " 2611 = vBulletin < v3.8.5",
584 " 2711 = vBulletin > v3.8.5",
585 " 2811 = MyBB",
586 " 2811 = IPB (Invison Power Board)",
587 " 8400 = WBB3 (Woltlab Burning Board)",
588 " 11 = Joomla < 2.5.18",
589 " 400 = Joomla > 2.5.18",
590 " 400 = Wordpress",
591 " 2612 = PHPS",
592 " 7900 = Drupal7",
593 " 21 = osCommerce",
594 " 21 = xt:Commerce",
595 " 11000 = PrestaShop",
596 " 124 = Django (SHA-1)",
597 " 10000 = Django (PBKDF2-SHA256)",
598 " 3711 = Mediawiki B type",
599 " 7600 = Redmine",
600 "",
601 "[[ Database Server ]]",
602 "",
603 " 12 = PostgreSQL",
604 " 131 = MSSQL(2000)",
605 " 132 = MSSQL(2005)",
606 " 1731 = MSSQL(2012)",
607 " 1731 = MSSQL(2014)",
608 " 200 = MySQL323",
609 " 300 = MySQL4.1/MySQL5",
610 " 3100 = Oracle H: Type (Oracle 7+)",
611 " 112 = Oracle S: Type (Oracle 11+)",
612 " 12300 = Oracle T: Type (Oracle 12+)",
613 " 8000 = Sybase ASE",
614 "",
615 "[[ HTTP, SMTP, LDAP Server ]]",
616 "",
617 " 141 = EPiServer 6.x < v4",
618 " 1441 = EPiServer 6.x > v4",
619 " 1600 = Apache $apr1$",
620 " 12600 = ColdFusion 10+",
621 " 1421 = hMailServer",
622 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
623 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
624 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
625 "",
626 "[[ Checksums ]]",
627 "",
628 " 11500 = CRC32",
629 "",
630 "[[ Operating-Systems ]]",
631 "",
632 " 3000 = LM",
633 " 1000 = NTLM",
634 " 1100 = Domain Cached Credentials (DCC), MS Cache",
635 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
636 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
637 " 1500 = descrypt, DES(Unix), Traditional DES",
638 " 12400 = BSDiCrypt, Extended DES",
639 " 500 = md5crypt $1$, MD5(Unix)",
640 " 3200 = bcrypt $2*$, Blowfish(Unix)",
641 " 7400 = sha256crypt $5$, SHA256(Unix)",
642 " 1800 = sha512crypt $6$, SHA512(Unix)",
643 " 122 = OSX v10.4",
644 " 122 = OSX v10.5",
645 " 122 = OSX v10.6",
646 " 1722 = OSX v10.7",
647 " 7100 = OSX v10.8",
648 " 7100 = OSX v10.9",
649 " 7100 = OSX v10.10",
650 " 6300 = AIX {smd5}",
651 " 6700 = AIX {ssha1}",
652 " 6400 = AIX {ssha256}",
653 " 6500 = AIX {ssha512}",
654 " 2400 = Cisco-PIX",
655 " 2410 = Cisco-ASA",
656 " 500 = Cisco-IOS $1$",
657 " 5700 = Cisco-IOS $4$",
658 " 9200 = Cisco-IOS $8$",
659 " 9300 = Cisco-IOS $9$",
660 " 22 = Juniper Netscreen/SSG (ScreenOS)",
661 " 501 = Juniper IVE",
662 " 5800 = Android PIN",
663 " 8100 = Citrix Netscaler",
664 " 8500 = RACF",
665 " 7200 = GRUB 2",
666 " 9900 = Radmin2",
667 "",
668 "[[ Enterprise Application Software (EAS) ]]",
669 "",
670 " 7700 = SAP CODVN B (BCODE)",
671 " 7800 = SAP CODVN F/G (PASSCODE)",
672 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
673 " 8600 = Lotus Notes/Domino 5",
674 " 8700 = Lotus Notes/Domino 6",
675 " 9100 = Lotus Notes/Domino 8",
676 " 133 = PeopleSoft",
677 "",
678 "[[ Archives ]]",
679 "",
680 " 11600 = 7-Zip",
681 " 12500 = RAR3-hp",
682 " 13000 = RAR5",
683 "",
684 "[[ Full-Disk encryptions (FDE) ]]",
685 "",
686 " 62XY = TrueCrypt 5.0+",
687 " X = 1 = PBKDF2-HMAC-RipeMD160",
688 " X = 2 = PBKDF2-HMAC-SHA512",
689 " X = 3 = PBKDF2-HMAC-Whirlpool",
690 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
691 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
692 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
693 " Y = 3 = XTS 1536 bit (Ciphers: All)",
694 " 8800 = Android FDE < v4.3",
695 " 12900 = Android FDE (Samsung DEK)",
696 " 12200 = eCryptfs",
697 "",
698 "[[ Documents ]]",
699 "",
700 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
701 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
702 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
703 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
704 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
705 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
706 " 9400 = MS Office 2007",
707 " 9500 = MS Office 2010",
708 " 9600 = MS Office 2013",
709 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
710 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
711 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
712 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
713 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
714 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
715 "",
716 "[[ Password Managers ]]",
717 "",
718 " 9000 = Password Safe v2",
719 " 5200 = Password Safe v3",
720 " 6800 = Lastpass",
721 " 6600 = 1Password, agilekeychain",
722 " 8200 = 1Password, cloudkeychain",
723 " 11300 = Bitcoin/Litecoin wallet.dat",
724 " 12700 = Blockchain, My Wallet",
725 "",
726 NULL
727 };
728
729 /**
730 * oclHashcat specific functions
731 */
732
733 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
734 {
735 int exec_pos = (int) device_param->exec_pos - 1 - last_num_entries;
736
737 if (exec_pos < 0) exec_pos += EXEC_CACHE;
738
739 double exec_ms_total = 0;
740
741 int exec_ms_cnt = 0;
742
743 for (int i = 0; i < last_num_entries; i++)
744 {
745 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
746
747 if (exec_ms)
748 {
749 exec_ms_total += exec_ms;
750
751 exec_ms_cnt++;
752 }
753 }
754
755 return exec_ms_total / exec_ms_cnt;
756 }
757
758 void status_display_automat ()
759 {
760 FILE *out = stdout;
761
762 fprintf (out, "STATUS\t%u\t", data.devices_status);
763
764 /**
765 * speed new
766 */
767
768 fprintf (out, "SPEED\t");
769
770 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
771 {
772 hc_device_param_t *device_param = &data.devices_param[device_id];
773
774 if (device_param->skipped) continue;
775
776 u64 speed_cnt = 0;
777 float speed_ms = 0;
778
779 for (int i = 0; i < SPEED_CACHE; i++)
780 {
781 float rec_ms;
782
783 hc_timer_get (device_param->speed_rec[i], rec_ms);
784
785 if (rec_ms > SPEED_MAXAGE) continue;
786
787 speed_cnt += device_param->speed_cnt[i];
788 speed_ms += device_param->speed_ms[i];
789 }
790
791 speed_cnt /= SPEED_CACHE;
792 speed_ms /= SPEED_CACHE;
793
794 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
795 }
796
797 /**
798 * exec time
799 */
800
801 fprintf (out, "EXEC_RUNTIME\t");
802
803 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
804 {
805 hc_device_param_t *device_param = &data.devices_param[device_id];
806
807 if (device_param->skipped) continue;
808
809 double exec_ms_total = get_avg_exec_time (device_param, EXEC_CACHE);
810
811 fprintf (out, "%f\t", exec_ms_total);
812 }
813
814 /**
815 * words_cur
816 */
817
818 u64 words_cur = get_lowest_words_done ();
819
820 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
821
822 /**
823 * counter
824 */
825
826 uint salts_left = data.salts_cnt - data.salts_done;
827
828 if (salts_left == 0) salts_left = 1;
829
830 u64 progress_total = data.words_cnt * salts_left;
831
832 u64 all_done = 0;
833 u64 all_rejected = 0;
834 u64 all_restored = 0;
835
836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
837 {
838 if (salts_left > 1)
839 {
840 // otherwise the final cracked status shows 0/XXX progress
841
842 if (data.salts_shown[salt_pos] == 1) continue;
843 }
844
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * salts_left;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * salts_left;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 uint pke[25] = { 0 };
1059
1060 char *pke_ptr = (char *) pke;
1061
1062 for (uint i = 0; i < 25; i++)
1063 {
1064 pke[i] = byte_swap_32 (wpa->pke[i]);
1065 }
1066
1067 char mac1[6] = { 0 };
1068 char mac2[6] = { 0 };
1069
1070 memcpy (mac1, pke_ptr + 23, 6);
1071 memcpy (mac2, pke_ptr + 29, 6);
1072
1073 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1074 (char *) data.salts_buf[0].salt_buf,
1075 mac1[0] & 0xff,
1076 mac1[1] & 0xff,
1077 mac1[2] & 0xff,
1078 mac1[3] & 0xff,
1079 mac1[4] & 0xff,
1080 mac1[5] & 0xff,
1081 mac2[0] & 0xff,
1082 mac2[1] & 0xff,
1083 mac2[2] & 0xff,
1084 mac2[3] & 0xff,
1085 mac2[4] & 0xff,
1086 mac2[5] & 0xff);
1087 }
1088 else if (data.hash_mode == 5200)
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else if (data.hash_mode == 9000)
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 else
1101 {
1102 char out_buf[4096] = { 0 };
1103
1104 ascii_digest (out_buf, 0, 0);
1105
1106 // limit length
1107 if (strlen (out_buf) > 40)
1108 {
1109 out_buf[41] = '.';
1110 out_buf[42] = '.';
1111 out_buf[43] = '.';
1112 out_buf[44] = 0;
1113 }
1114
1115 log_info ("Hash.Target....: %s", out_buf);
1116 }
1117 }
1118 else
1119 {
1120 if (data.hash_mode == 3000)
1121 {
1122 char out_buf1[4096] = { 0 };
1123 char out_buf2[4096] = { 0 };
1124
1125 ascii_digest (out_buf1, 0, 0);
1126 ascii_digest (out_buf2, 0, 1);
1127
1128 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1129 }
1130 else
1131 {
1132 log_info ("Hash.Target....: File (%s)", data.hashfile);
1133 }
1134 }
1135
1136 log_info ("Hash.Type......: %s", hash_type);
1137
1138 /**
1139 * speed new
1140 */
1141
1142 u64 speed_cnt[DEVICES_MAX] = { 0 };
1143 float speed_ms[DEVICES_MAX] = { 0 };
1144
1145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1146 {
1147 hc_device_param_t *device_param = &data.devices_param[device_id];
1148
1149 if (device_param->skipped) continue;
1150
1151 // we need to clear values (set to 0) because in case the device does
1152 // not get new candidates it idles around but speed display would
1153 // show it as working.
1154 // if we instantly set it to 0 after reading it happens that the
1155 // speed can be shown as zero if the users refreshes too fast.
1156 // therefore, we add a timestamp when a stat was recorded and if its
1157 // too old we will not use it
1158
1159 speed_cnt[device_id] = 0;
1160 speed_ms[device_id] = 0;
1161
1162 for (int i = 0; i < SPEED_CACHE; i++)
1163 {
1164 float rec_ms;
1165
1166 hc_timer_get (device_param->speed_rec[i], rec_ms);
1167
1168 if (rec_ms > SPEED_MAXAGE) continue;
1169
1170 speed_cnt[device_id] += device_param->speed_cnt[i];
1171 speed_ms[device_id] += device_param->speed_ms[i];
1172 }
1173
1174 speed_cnt[device_id] /= SPEED_CACHE;
1175 speed_ms[device_id] /= SPEED_CACHE;
1176 }
1177
1178 float hashes_all_ms = 0;
1179
1180 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1181
1182 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1183 {
1184 hc_device_param_t *device_param = &data.devices_param[device_id];
1185
1186 if (device_param->skipped) continue;
1187
1188 hashes_dev_ms[device_id] = 0;
1189
1190 if (speed_ms[device_id])
1191 {
1192 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1193
1194 hashes_all_ms += hashes_dev_ms[device_id];
1195 }
1196 }
1197
1198 /**
1199 * exec time
1200 */
1201
1202 double exec_all_ms[DEVICES_MAX] = { 0 };
1203
1204 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1205 {
1206 hc_device_param_t *device_param = &data.devices_param[device_id];
1207
1208 if (device_param->skipped) continue;
1209
1210 double exec_ms_total = get_avg_exec_time (device_param, EXEC_CACHE);
1211
1212 exec_all_ms[device_id] = exec_ms_total;
1213 }
1214
1215 /**
1216 * timers
1217 */
1218
1219 float ms_running = 0;
1220
1221 hc_timer_get (data.timer_running, ms_running);
1222
1223 float ms_paused = data.ms_paused;
1224
1225 if (data.devices_status == STATUS_PAUSED)
1226 {
1227 float ms_paused_tmp = 0;
1228
1229 hc_timer_get (data.timer_paused, ms_paused_tmp);
1230
1231 ms_paused += ms_paused_tmp;
1232 }
1233
1234 #ifdef WIN
1235
1236 __time64_t sec_run = ms_running / 1000;
1237
1238 #else
1239
1240 time_t sec_run = ms_running / 1000;
1241
1242 #endif
1243
1244 if (sec_run)
1245 {
1246 char display_run[32] = { 0 };
1247
1248 struct tm tm_run;
1249
1250 struct tm *tmp = NULL;
1251
1252 #ifdef WIN
1253
1254 tmp = _gmtime64 (&sec_run);
1255
1256 #else
1257
1258 tmp = gmtime (&sec_run);
1259
1260 #endif
1261
1262 if (tmp != NULL)
1263 {
1264 memset (&tm_run, 0, sizeof (tm_run));
1265
1266 memcpy (&tm_run, tmp, sizeof (tm_run));
1267
1268 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1269
1270 char *start = ctime (&data.proc_start);
1271
1272 size_t start_len = strlen (start);
1273
1274 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1275 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1276
1277 log_info ("Time.Started...: %s (%s)", start, display_run);
1278 }
1279 }
1280 else
1281 {
1282 log_info ("Time.Started...: 0 secs");
1283 }
1284
1285 /**
1286 * counters
1287 */
1288
1289 uint salts_left = data.salts_cnt - data.salts_done;
1290
1291 if (salts_left == 0) salts_left = 1;
1292
1293 u64 progress_total = data.words_cnt * salts_left;
1294
1295 u64 all_done = 0;
1296 u64 all_rejected = 0;
1297 u64 all_restored = 0;
1298
1299 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1300 {
1301 if (salts_left > 1)
1302 {
1303 // otherwise the final cracked status shows 0/XXX progress
1304
1305 if (data.salts_shown[salt_pos] == 1) continue;
1306 }
1307
1308 all_done += data.words_progress_done[salt_pos];
1309 all_rejected += data.words_progress_rejected[salt_pos];
1310 all_restored += data.words_progress_restored[salt_pos];
1311 }
1312
1313 u64 progress_cur = all_restored + all_done + all_rejected;
1314 u64 progress_end = progress_total;
1315
1316 u64 progress_skip = 0;
1317
1318 if (data.skip)
1319 {
1320 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1321
1322 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1323 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1324 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1325 }
1326
1327 if (data.limit)
1328 {
1329 progress_end = MIN (data.limit, data.words_base) * salts_left;
1330
1331 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1332 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1333 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1334 }
1335
1336 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1337 u64 progress_end_relative_skip = progress_end - progress_skip;
1338
1339 float speed_ms_real = ms_running - ms_paused;
1340 u64 speed_plains_real = all_done;
1341
1342 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1343 {
1344 if (data.devices_status != STATUS_CRACKED)
1345 {
1346 u64 words_per_ms = 0;
1347
1348 if (speed_plains_real && speed_ms_real)
1349 {
1350 words_per_ms = speed_plains_real / speed_ms_real;
1351 }
1352
1353 #ifdef WIN
1354 __time64_t sec_etc = 0;
1355 #else
1356 time_t sec_etc = 0;
1357 #endif
1358
1359 if (words_per_ms)
1360 {
1361 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1362
1363 u64 ms_left = progress_left_relative_skip / words_per_ms;
1364
1365 sec_etc = ms_left / 1000;
1366 }
1367
1368 if (sec_etc == 0)
1369 {
1370 log_info ("Time.Estimated.: 0 secs");
1371 }
1372 else if ((u64) sec_etc > ETC_MAX)
1373 {
1374 log_info ("Time.Estimated.: > 10 Years");
1375 }
1376 else
1377 {
1378 char display_etc[32] = { 0 };
1379
1380 struct tm tm_etc;
1381
1382 struct tm *tmp = NULL;
1383
1384 #ifdef WIN
1385
1386 tmp = _gmtime64 (&sec_etc);
1387
1388 #else
1389
1390 tmp = gmtime (&sec_etc);
1391
1392 #endif
1393
1394 if (tmp != NULL)
1395 {
1396 memset (&tm_etc, 0, sizeof (tm_etc));
1397
1398 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1399
1400 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1401
1402 time_t now;
1403
1404 time (&now);
1405
1406 now += sec_etc;
1407
1408 char *etc = ctime (&now);
1409
1410 size_t etc_len = strlen (etc);
1411
1412 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1413 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1414
1415 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1416 }
1417 }
1418 }
1419 }
1420
1421 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1422 {
1423 hc_device_param_t *device_param = &data.devices_param[device_id];
1424
1425 if (device_param->skipped) continue;
1426
1427 char display_dev_cur[16] = { 0 };
1428
1429 strncpy (display_dev_cur, "0.00", 4);
1430
1431 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1432
1433 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1434 }
1435
1436 char display_all_cur[16] = { 0 };
1437
1438 strncpy (display_all_cur, "0.00", 4);
1439
1440 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1441
1442 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1443
1444 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1445 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1446
1447 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);
1448
1449 // crack-per-time
1450
1451 if (data.digests_cnt > 100)
1452 {
1453 time_t now = time (NULL);
1454
1455 int cpt_cur_min = 0;
1456 int cpt_cur_hour = 0;
1457 int cpt_cur_day = 0;
1458
1459 for (int i = 0; i < CPT_BUF; i++)
1460 {
1461 const uint cracked = data.cpt_buf[i].cracked;
1462 const time_t timestamp = data.cpt_buf[i].timestamp;
1463
1464 if ((timestamp + 60) > now)
1465 {
1466 cpt_cur_min += cracked;
1467 }
1468
1469 if ((timestamp + 3600) > now)
1470 {
1471 cpt_cur_hour += cracked;
1472 }
1473
1474 if ((timestamp + 86400) > now)
1475 {
1476 cpt_cur_day += cracked;
1477 }
1478 }
1479
1480 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1481 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1482 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1483
1484 if ((data.cpt_start + 86400) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_cur_hour,
1489 cpt_cur_day,
1490 cpt_avg_min,
1491 cpt_avg_hour,
1492 cpt_avg_day);
1493 }
1494 else if ((data.cpt_start + 3600) < now)
1495 {
1496 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1497 cpt_cur_min,
1498 cpt_cur_hour,
1499 cpt_avg_min,
1500 cpt_avg_hour,
1501 cpt_avg_day);
1502 }
1503 else if ((data.cpt_start + 60) < now)
1504 {
1505 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1506 cpt_cur_min,
1507 cpt_avg_min,
1508 cpt_avg_hour,
1509 cpt_avg_day);
1510 }
1511 else
1512 {
1513 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 }
1519
1520 // Restore point
1521
1522 u64 restore_point = get_lowest_words_done ();
1523
1524 u64 restore_total = data.words_base;
1525
1526 float percent_restore = 0;
1527
1528 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1529
1530 if (progress_end_relative_skip)
1531 {
1532 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1533 {
1534 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1535 float percent_rejected = 0.0;
1536
1537 if (progress_cur)
1538 {
1539 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1540 }
1541
1542 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);
1543 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1544
1545 if (data.restore_disable == 0)
1546 {
1547 if (percent_finished != 1)
1548 {
1549 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1550 }
1551 }
1552 }
1553 }
1554 else
1555 {
1556 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1557 {
1558 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560
1561 if (data.restore_disable == 0)
1562 {
1563 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1564 }
1565 }
1566 else
1567 {
1568 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1569 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1570
1571 // --restore not allowed if stdin is used -- really? why?
1572
1573 //if (data.restore_disable == 0)
1574 //{
1575 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1576 //}
1577 }
1578 }
1579
1580 #ifdef HAVE_HWMON
1581 if (data.gpu_temp_disable == 0)
1582 {
1583 hc_thread_mutex_lock (mux_adl);
1584
1585 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1586 {
1587 hc_device_param_t *device_param = &data.devices_param[device_id];
1588
1589 if (device_param->skipped) continue;
1590
1591 #define HM_STR_BUF_SIZE 255
1592
1593 if (data.hm_device[device_id].fan_supported == 1)
1594 {
1595 char utilization[HM_STR_BUF_SIZE] = { 0 };
1596 char temperature[HM_STR_BUF_SIZE] = { 0 };
1597 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 if (device_param->vendor_id == VENDOR_ID_AMD)
1603 {
1604 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1605 }
1606 else if (device_param->vendor_id == VENDOR_ID_NV)
1607 {
1608 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1609 }
1610
1611 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1612 }
1613 else
1614 {
1615 char utilization[HM_STR_BUF_SIZE] = { 0 };
1616 char temperature[HM_STR_BUF_SIZE] = { 0 };
1617
1618 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1619 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1620
1621 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1622 }
1623 }
1624
1625 hc_thread_mutex_unlock (mux_adl);
1626 }
1627 #endif // HAVE_HWMON
1628 }
1629
1630 static void status_benchmark ()
1631 {
1632 if (data.devices_status == STATUS_INIT) return;
1633 if (data.devices_status == STATUS_STARTING) return;
1634
1635 if (data.words_cnt == 0) return;
1636
1637 u64 speed_cnt[DEVICES_MAX] = { 0 };
1638 float speed_ms[DEVICES_MAX] = { 0 };
1639
1640 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1641 {
1642 hc_device_param_t *device_param = &data.devices_param[device_id];
1643
1644 if (device_param->skipped) continue;
1645
1646 speed_cnt[device_id] = 0;
1647 speed_ms[device_id] = 0;
1648
1649 for (int i = 0; i < SPEED_CACHE; i++)
1650 {
1651 speed_cnt[device_id] += device_param->speed_cnt[i];
1652 speed_ms[device_id] += device_param->speed_ms[i];
1653 }
1654
1655 speed_cnt[device_id] /= SPEED_CACHE;
1656 speed_ms[device_id] /= SPEED_CACHE;
1657 }
1658
1659 float hashes_all_ms = 0;
1660
1661 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1662
1663 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1664 {
1665 hc_device_param_t *device_param = &data.devices_param[device_id];
1666
1667 if (device_param->skipped) continue;
1668
1669 hashes_dev_ms[device_id] = 0;
1670
1671 if (speed_ms[device_id])
1672 {
1673 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1674
1675 hashes_all_ms += hashes_dev_ms[device_id];
1676 }
1677 }
1678
1679 /**
1680 * exec time
1681 */
1682
1683 double exec_all_ms[DEVICES_MAX] = { 0 };
1684
1685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1686 {
1687 hc_device_param_t *device_param = &data.devices_param[device_id];
1688
1689 if (device_param->skipped) continue;
1690
1691 double exec_ms_total = get_avg_exec_time (device_param, EXEC_CACHE);
1692
1693 exec_all_ms[device_id] = exec_ms_total;
1694 }
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 char display_dev_cur[16] = { 0 };
1703
1704 strncpy (display_dev_cur, "0.00", 4);
1705
1706 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1707
1708 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1709 }
1710
1711 char display_all_cur[16] = { 0 };
1712
1713 strncpy (display_all_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1716
1717 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1718 }
1719
1720 /**
1721 * oclHashcat -only- functions
1722 */
1723
1724 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1725 {
1726 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1727 {
1728 if (attack_kern == ATTACK_KERN_STRAIGHT)
1729 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1730 else if (attack_kern == ATTACK_KERN_COMBI)
1731 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1732 else if (attack_kern == ATTACK_KERN_BF)
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1734 }
1735 else
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1737 }
1738
1739 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1740 {
1741 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1742 {
1743 if (attack_kern == ATTACK_KERN_STRAIGHT)
1744 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1745 else if (attack_kern == ATTACK_KERN_COMBI)
1746 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1747 else if (attack_kern == ATTACK_KERN_BF)
1748 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 }
1750 else
1751 {
1752 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1753 }
1754 }
1755
1756 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1757 {
1758 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1759 {
1760 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1761 }
1762 else
1763 {
1764 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1765 }
1766 }
1767
1768 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1769 {
1770 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1771 {
1772 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1773 }
1774 else
1775 {
1776 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1777 }
1778 }
1779
1780 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1781 {
1782 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1783 }
1784
1785 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1786 {
1787 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1788 }
1789
1790 static uint convert_from_hex (char *line_buf, const uint line_len)
1791 {
1792 if (line_len & 1) return (line_len); // not in hex
1793
1794 if (data.hex_wordlist == 1)
1795 {
1796 uint i;
1797 uint j;
1798
1799 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1800 {
1801 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1802 }
1803
1804 memset (line_buf + i, 0, line_len - i);
1805
1806 return (i);
1807 }
1808 else if (line_len >= 6) // $HEX[] = 6
1809 {
1810 if (line_buf[0] != '$') return (line_len);
1811 if (line_buf[1] != 'H') return (line_len);
1812 if (line_buf[2] != 'E') return (line_len);
1813 if (line_buf[3] != 'X') return (line_len);
1814 if (line_buf[4] != '[') return (line_len);
1815 if (line_buf[line_len - 1] != ']') return (line_len);
1816
1817 uint i;
1818 uint j;
1819
1820 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1821 {
1822 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1823 }
1824
1825 memset (line_buf + i, 0, line_len - i);
1826
1827 return (i);
1828 }
1829
1830 return (line_len);
1831 }
1832
1833 static void clear_prompt ()
1834 {
1835 fputc ('\r', stdout);
1836
1837 for (size_t i = 0; i < strlen (PROMPT); i++)
1838 {
1839 fputc (' ', stdout);
1840 }
1841
1842 fputc ('\r', stdout);
1843
1844 fflush (stdout);
1845 }
1846
1847 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1848 {
1849 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);
1850 }
1851
1852 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1853 {
1854 char *outfile = data.outfile;
1855 uint quiet = data.quiet;
1856 FILE *pot_fp = data.pot_fp;
1857 uint loopback = data.loopback;
1858 uint debug_mode = data.debug_mode;
1859 char *debug_file = data.debug_file;
1860
1861 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1862 int debug_rule_len = 0; // -1 error
1863 uint debug_plain_len = 0;
1864
1865 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1866
1867 // hash
1868
1869 char out_buf[4096] = { 0 };
1870
1871 ascii_digest (out_buf, salt_pos, digest_pos);
1872
1873 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1874
1875 // plain
1876
1877 plain_t plain;
1878
1879 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);
1880
1881 uint gidvid = plain.gidvid;
1882 uint il_pos = plain.il_pos;
1883
1884 u64 crackpos = device_param->words_off;
1885
1886 uint plain_buf[16] = { 0 };
1887
1888 u8 *plain_ptr = (u8 *) plain_buf;
1889 unsigned int plain_len = 0;
1890
1891 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1892 {
1893 u64 gidd = gidvid;
1894 u64 gidm = 0;
1895
1896 pw_t pw;
1897
1898 gidd_to_pw_t (device_param, gidd, &pw);
1899
1900 for (int i = 0, j = gidm; i < 16; i++, j++)
1901 {
1902 plain_buf[i] = pw.h.hi1[0][j];
1903 }
1904
1905 plain_len = pw.pw_len;
1906
1907 const uint off = device_param->innerloop_pos + il_pos;
1908
1909 if (debug_mode > 0)
1910 {
1911 debug_rule_len = 0;
1912
1913 // save rule
1914 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1915 {
1916 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1917
1918 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1919 }
1920
1921 // save plain
1922 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1923 {
1924 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1925
1926 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1927
1928 debug_plain_len = plain_len;
1929 }
1930 }
1931
1932 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1933
1934 crackpos += gidvid;
1935 crackpos *= data.kernel_rules_cnt;
1936 crackpos += device_param->innerloop_pos + il_pos;
1937
1938 if (plain_len > data.pw_max) plain_len = data.pw_max;
1939 }
1940 else if (data.attack_mode == ATTACK_MODE_COMBI)
1941 {
1942 u64 gidd = gidvid;
1943 u64 gidm = 0;
1944
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidd, &pw);
1948
1949 for (int i = 0, j = gidm; i < 16; i++, j++)
1950 {
1951 plain_buf[i] = pw.h.hi1[0][j];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 u64 gidd = gidvid;
2004 u64 gidm = 0;
2005
2006 pw_t pw;
2007
2008 gidd_to_pw_t (device_param, gidd, &pw);
2009
2010 for (int i = 0, j = gidm; i < 16; i++, j++)
2011 {
2012 plain_buf[i] = pw.h.hi1[0][j];
2013 }
2014
2015 plain_len = pw.pw_len;
2016
2017 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2018
2019 uint start = 0;
2020 uint stop = device_param->kernel_params_mp_buf32[4];
2021
2022 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2023
2024 plain_len += start + stop;
2025
2026 crackpos += gidvid;
2027 crackpos *= data.combs_cnt;
2028 crackpos += device_param->innerloop_pos + il_pos;
2029
2030 if (data.pw_max != PW_DICTMAX1)
2031 {
2032 if (plain_len > data.pw_max) plain_len = data.pw_max;
2033 }
2034 }
2035 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2036 {
2037 u64 gidd = gidvid;
2038 u64 gidm = 0;
2039
2040 pw_t pw;
2041
2042 gidd_to_pw_t (device_param, gidd, &pw);
2043
2044 for (int i = 0, j = gidm; i < 16; i++, j++)
2045 {
2046 plain_buf[i] = pw.h.hi1[0][j];
2047 }
2048
2049 plain_len = pw.pw_len;
2050
2051 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2052
2053 uint start = 0;
2054 uint stop = device_param->kernel_params_mp_buf32[4];
2055
2056 memmove (plain_ptr + stop, plain_ptr, plain_len);
2057
2058 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2059
2060 plain_len += start + stop;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.combs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065
2066 if (data.pw_max != PW_DICTMAX1)
2067 {
2068 if (plain_len > data.pw_max) plain_len = data.pw_max;
2069 }
2070 }
2071
2072 if (data.attack_mode == ATTACK_MODE_BF)
2073 {
2074 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2075 {
2076 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2077 {
2078 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2079 {
2080 plain_len = plain_len - data.salts_buf[0].salt_len;
2081 }
2082 }
2083
2084 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2085 {
2086 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2087 {
2088 plain_ptr[j] = plain_ptr[i];
2089 }
2090
2091 plain_len = plain_len / 2;
2092 }
2093 }
2094 }
2095
2096 // if enabled, update also the potfile
2097
2098 if (pot_fp)
2099 {
2100 lock_file (pot_fp);
2101
2102 fprintf (pot_fp, "%s:", out_buf);
2103
2104 format_plain (pot_fp, plain_ptr, plain_len, 1);
2105
2106 fputc ('\n', pot_fp);
2107
2108 fflush (pot_fp);
2109
2110 unlock_file (pot_fp);
2111 }
2112
2113 // outfile
2114
2115 FILE *out_fp = NULL;
2116
2117 if (outfile != NULL)
2118 {
2119 if ((out_fp = fopen (outfile, "ab")) == NULL)
2120 {
2121 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2122
2123 out_fp = stdout;
2124 }
2125 lock_file (out_fp);
2126 }
2127 else
2128 {
2129 out_fp = stdout;
2130
2131 if (quiet == 0) clear_prompt ();
2132 }
2133
2134 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2135
2136 if (outfile != NULL)
2137 {
2138 if (out_fp != stdout)
2139 {
2140 fclose (out_fp);
2141 }
2142 }
2143 else
2144 {
2145 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2146 {
2147 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2148 {
2149 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2150 if (quiet == 0) fflush (stdout);
2151 }
2152 }
2153 }
2154
2155 // loopback
2156
2157 if (loopback)
2158 {
2159 char *loopback_file = data.loopback_file;
2160
2161 FILE *fb_fp = NULL;
2162
2163 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2164 {
2165 lock_file (fb_fp);
2166
2167 format_plain (fb_fp, plain_ptr, plain_len, 1);
2168
2169 fputc ('\n', fb_fp);
2170
2171 fclose (fb_fp);
2172 }
2173 }
2174
2175 // (rule) debug mode
2176
2177 // the next check implies that:
2178 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2179 // - debug_mode > 0
2180
2181 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2182 {
2183 if (debug_rule_len < 0) debug_rule_len = 0;
2184
2185 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2186
2187 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2188
2189 if ((quiet == 0) && (debug_file == NULL))
2190 {
2191 fprintf (stdout, "%s", PROMPT);
2192 fflush (stdout);
2193 }
2194 }
2195 }
2196
2197 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2198 {
2199 salt_t *salt_buf = &data.salts_buf[salt_pos];
2200
2201 int found = 0;
2202
2203 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);
2204
2205 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2206
2207 if (found == 1)
2208 {
2209 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2210
2211 log_info_nn ("");
2212
2213 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);
2214
2215 uint cpt_cracked = 0;
2216
2217 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2218 {
2219 uint idx = salt_buf->digests_offset + digest_pos;
2220
2221 if (data.digests_shown_tmp[idx] == 0) continue;
2222
2223 if (data.digests_shown[idx] == 1) continue;
2224
2225 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2226 {
2227 data.digests_shown[idx] = 1;
2228
2229 data.digests_done++;
2230
2231 cpt_cracked++;
2232
2233 salt_buf->digests_done++;
2234
2235 if (salt_buf->digests_done == salt_buf->digests_cnt)
2236 {
2237 data.salts_shown[salt_pos] = 1;
2238
2239 data.salts_done++;
2240 }
2241 }
2242
2243 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2244
2245 check_hash (device_param, salt_pos, digest_pos);
2246 }
2247
2248 if (cpt_cracked > 0)
2249 {
2250 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2251 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2252
2253 data.cpt_pos++;
2254
2255 data.cpt_total += cpt_cracked;
2256
2257 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2258 }
2259
2260 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2261 {
2262 // we need to reset cracked state on the device
2263 // otherwise host thinks again and again the hash was cracked
2264 // and returns invalid password each time
2265
2266 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2267
2268 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);
2269 }
2270
2271 memset (device_param->result, 0, device_param->size_results);
2272
2273 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);
2274 }
2275 }
2276
2277 static void save_hash ()
2278 {
2279 char *hashfile = data.hashfile;
2280
2281 char new_hashfile[256] = { 0 };
2282 char old_hashfile[256] = { 0 };
2283
2284 snprintf (new_hashfile, 255, "%s.new", hashfile);
2285 snprintf (old_hashfile, 255, "%s.old", hashfile);
2286
2287 unlink (new_hashfile);
2288
2289 char separator = data.separator;
2290
2291 FILE *fp = fopen (new_hashfile, "wb");
2292
2293 if (fp == NULL)
2294 {
2295 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2296
2297 exit (-1);
2298 }
2299
2300 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2301 {
2302 if (data.salts_shown[salt_pos] == 1) continue;
2303
2304 salt_t *salt_buf = &data.salts_buf[salt_pos];
2305
2306 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2307 {
2308 uint idx = salt_buf->digests_offset + digest_pos;
2309
2310 if (data.digests_shown[idx] == 1) continue;
2311
2312 if (data.hash_mode != 2500)
2313 {
2314 char out_buf[4096] = { 0 };
2315
2316 if (data.username == 1)
2317 {
2318 user_t *user = data.hash_info[idx]->user;
2319
2320 uint i;
2321
2322 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2323
2324 fputc (separator, fp);
2325 }
2326
2327 ascii_digest (out_buf, salt_pos, digest_pos);
2328
2329 fputs (out_buf, fp);
2330
2331 log_out (fp, "");
2332 }
2333 else
2334 {
2335 hccap_t hccap;
2336
2337 to_hccap_t (&hccap, salt_pos, digest_pos);
2338
2339 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2340 }
2341 }
2342 }
2343
2344 fflush (fp);
2345
2346 fclose (fp);
2347
2348 unlink (old_hashfile);
2349
2350 if (rename (hashfile, old_hashfile) != 0)
2351 {
2352 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2353
2354 exit (-1);
2355 }
2356
2357 unlink (hashfile);
2358
2359 if (rename (new_hashfile, hashfile) != 0)
2360 {
2361 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2362
2363 exit (-1);
2364 }
2365
2366 unlink (old_hashfile);
2367 }
2368
2369 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2370 {
2371 // function called only in case kernel_power_all > words_left
2372
2373 float kernel_power_div = (float) (total_left) / kernel_power_all;
2374
2375 kernel_power_div += kernel_power_div / 100;
2376
2377 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2378
2379 while (kernel_power_new < total_left)
2380 {
2381 kernel_power_div += kernel_power_div / 100;
2382
2383 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2384 }
2385
2386 if (data.quiet == 0)
2387 {
2388 clear_prompt ();
2389
2390 log_info ("");
2391
2392 log_info ("INFO: approaching final keyspace, workload adjusted");
2393
2394 log_info ("");
2395
2396 fprintf (stdout, "%s", PROMPT);
2397
2398 fflush (stdout);
2399 }
2400
2401 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2402
2403 return kernel_power_div;
2404 }
2405
2406 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2407 {
2408 uint num_elements = num;
2409
2410 device_param->kernel_params_buf32[30] = data.combs_mode;
2411 device_param->kernel_params_buf32[31] = num;
2412
2413 uint kernel_threads = device_param->kernel_threads;
2414
2415 while (num_elements % kernel_threads) num_elements++;
2416
2417 cl_kernel kernel = NULL;
2418
2419 switch (kern_run)
2420 {
2421 case KERN_RUN_1: kernel = device_param->kernel1; break;
2422 case KERN_RUN_12: kernel = device_param->kernel12; break;
2423 case KERN_RUN_2: kernel = device_param->kernel2; break;
2424 case KERN_RUN_23: kernel = device_param->kernel23; break;
2425 case KERN_RUN_3: kernel = device_param->kernel3; break;
2426 }
2427
2428 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2429 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2430 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2431 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2432 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2433 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2434 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2435 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2436 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2437 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2438 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2439
2440 cl_event event;
2441
2442 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2443 {
2444 const size_t global_work_size[3] = { num_elements, 32, 1 };
2445 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2446
2447 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2448 }
2449 else
2450 {
2451 const size_t global_work_size[3] = { num_elements, 1, 1 };
2452 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2453
2454 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2455
2456 if (rc != CL_SUCCESS)
2457 {
2458 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2459
2460 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2461 }
2462 }
2463
2464 hc_clFlush (data.ocl, device_param->command_queue);
2465
2466 hc_clWaitForEvents (data.ocl, 1, &event);
2467
2468 if (event_update)
2469 {
2470 cl_ulong time_start;
2471 cl_ulong time_end;
2472
2473 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2474 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2475
2476 const double exec_time = (time_end - time_start) / 1000000.0;
2477
2478 uint exec_pos = device_param->exec_pos;
2479
2480 device_param->exec_ms[exec_pos] = exec_time;
2481
2482 exec_pos++;
2483
2484 if (exec_pos == EXEC_CACHE)
2485 {
2486 exec_pos = 0;
2487 }
2488
2489 device_param->exec_pos = exec_pos;
2490
2491 // autotune, first get the current avarage time exec_ms_total, this is our base for all
2492
2493 const double exec_ms_total = get_avg_exec_time (device_param, 4);
2494
2495 // now adjust kernel_loops
2496
2497 #define MIN_LOOPS device_param->kernel_loops_min
2498 #define MAX_LOOPS device_param->kernel_loops_max
2499
2500 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2501
2502 if (exec_ms_total > target_ms)
2503 {
2504 u32 adj = 1;
2505
2506 if (device_param->kernel_loops >= (MIN_LOOPS + adj))
2507 {
2508 device_param->kernel_loops -= adj;
2509 }
2510 }
2511
2512 if (exec_ms_total < target_ms)
2513 {
2514 u32 adj = 1;
2515
2516 if (device_param->kernel_loops <= (MAX_LOOPS - adj))
2517 {
2518 device_param->kernel_loops += adj;
2519 }
2520 }
2521
2522 //printf ("%d %d %f\n", device_param->kernel_accel, device_param->kernel_loops, exec_ms_total);
2523 }
2524
2525 hc_clReleaseEvent (data.ocl, event);
2526
2527 hc_clFinish (data.ocl, device_param->command_queue);
2528 }
2529
2530 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2531 {
2532 uint num_elements = num;
2533
2534 switch (kern_run)
2535 {
2536 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2537 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2538 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2539 }
2540
2541 // causes problems with special threads like in bcrypt
2542 // const uint kernel_threads = device_param->kernel_threads;
2543
2544 const uint kernel_threads = KERNEL_THREADS;
2545
2546 while (num_elements % kernel_threads) num_elements++;
2547
2548 cl_kernel kernel = NULL;
2549
2550 switch (kern_run)
2551 {
2552 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2553 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2554 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2555 }
2556
2557 switch (kern_run)
2558 {
2559 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2560 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2561 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2562 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2563 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2564 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2565 break;
2566 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2567 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2568 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2569 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2570 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2571 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2572 break;
2573 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2574 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2577 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2578 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2579 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2580 break;
2581 }
2582
2583 const size_t global_work_size[3] = { num_elements, 1, 1 };
2584 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2585
2586 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);
2587
2588 if (rc != CL_SUCCESS)
2589 {
2590 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2591
2592 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2593 }
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2601 {
2602 uint num_elements = num;
2603
2604 uint kernel_threads = device_param->kernel_threads;
2605
2606 while (num_elements % kernel_threads) num_elements++;
2607
2608 cl_kernel kernel = device_param->kernel_tb;
2609
2610 const size_t global_work_size[3] = { num_elements, 1, 1 };
2611 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2612
2613 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);
2614
2615 if (rc != CL_SUCCESS)
2616 {
2617 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2618
2619 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2620 }
2621
2622 hc_clFlush (data.ocl, device_param->command_queue);
2623
2624 hc_clFinish (data.ocl, device_param->command_queue);
2625 }
2626
2627 static void run_kernel_tm (hc_device_param_t *device_param)
2628 {
2629 const uint num_elements = 1024; // fixed
2630
2631 const uint kernel_threads = 32;
2632
2633 cl_kernel kernel = device_param->kernel_tm;
2634
2635 const size_t global_work_size[3] = { num_elements, 1, 1 };
2636 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2637
2638 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);
2639
2640 if (rc != CL_SUCCESS)
2641 {
2642 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2643
2644 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2645 }
2646
2647 hc_clFlush (data.ocl, device_param->command_queue);
2648
2649 hc_clFinish (data.ocl, device_param->command_queue);
2650 }
2651
2652 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2653 {
2654 uint num_elements = num;
2655
2656 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2657 device_param->kernel_params_amp_buf32[6] = num_elements;
2658
2659 // causes problems with special threads like in bcrypt
2660 // const uint kernel_threads = device_param->kernel_threads;
2661
2662 const uint kernel_threads = KERNEL_THREADS;
2663
2664 while (num_elements % kernel_threads) num_elements++;
2665
2666 cl_kernel kernel = device_param->kernel_amp;
2667
2668 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2669 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2670
2671 const size_t global_work_size[3] = { num_elements, 1, 1 };
2672 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2673
2674 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);
2675
2676 if (rc != CL_SUCCESS)
2677 {
2678 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2679
2680 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2681 }
2682
2683 hc_clFlush (data.ocl, device_param->command_queue);
2684
2685 hc_clFinish (data.ocl, device_param->command_queue);
2686 }
2687
2688 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2689 {
2690 int rc = -1;
2691
2692 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2693 {
2694 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2695
2696 const cl_uchar zero = 0;
2697
2698 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2699 }
2700
2701 if (rc != 0)
2702 {
2703 // NOTE: clEnqueueFillBuffer () always fails with -59
2704 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2705 // How's that possible, OpenCL 1.2 support is advertised??
2706 // We need to workaround...
2707
2708 #define FILLSZ 0x100000
2709
2710 char *tmp = (char *) mymalloc (FILLSZ);
2711
2712 for (uint i = 0; i < size; i += FILLSZ)
2713 {
2714 const int left = size - i;
2715
2716 const int fillsz = MIN (FILLSZ, left);
2717
2718 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2719 }
2720
2721 myfree (tmp);
2722 }
2723 }
2724
2725 static int run_rule_engine (const int rule_len, const char *rule_buf)
2726 {
2727 if (rule_len == 0)
2728 {
2729 return 0;
2730 }
2731 else if (rule_len == 1)
2732 {
2733 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2734 }
2735
2736 return 1;
2737 }
2738
2739 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2740 {
2741 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2742 {
2743 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);
2744 }
2745 else if (data.attack_kern == ATTACK_KERN_COMBI)
2746 {
2747 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);
2748 }
2749 else if (data.attack_kern == ATTACK_KERN_BF)
2750 {
2751 const u64 off = device_param->words_off;
2752
2753 device_param->kernel_params_mp_l_buf64[3] = off;
2754
2755 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2756 }
2757 }
2758
2759 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2760 {
2761 // init speed timer
2762
2763 uint speed_pos = device_param->speed_pos;
2764
2765 #ifdef _POSIX
2766 if (device_param->timer_speed.tv_sec == 0)
2767 {
2768 hc_timer_set (&device_param->timer_speed);
2769 }
2770 #endif
2771
2772 #ifdef _WIN
2773 if (device_param->timer_speed.QuadPart == 0)
2774 {
2775 hc_timer_set (&device_param->timer_speed);
2776 }
2777 #endif
2778
2779 // find higest password length, this is for optimization stuff
2780
2781 uint highest_pw_len = 0;
2782
2783 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2784 {
2785 }
2786 else if (data.attack_kern == ATTACK_KERN_COMBI)
2787 {
2788 }
2789 else if (data.attack_kern == ATTACK_KERN_BF)
2790 {
2791 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2792 + device_param->kernel_params_mp_l_buf32[5];
2793 }
2794
2795 // bitslice optimization stuff
2796
2797 if (data.attack_mode == ATTACK_MODE_BF)
2798 {
2799 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2800 {
2801 run_kernel_tb (device_param, pws_cnt);
2802 }
2803 }
2804
2805 // iteration type
2806
2807 uint innerloop_step = 0;
2808 uint innerloop_cnt = 0;
2809
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
2811 else innerloop_step = 1;
2812
2813 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2814 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2815 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2816
2817 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2818
2819 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2820 {
2821 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2822
2823 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2824
2825 if (data.devices_status == STATUS_CRACKED) break;
2826 if (data.devices_status == STATUS_ABORTED) break;
2827 if (data.devices_status == STATUS_QUIT) break;
2828 if (data.devices_status == STATUS_BYPASS) break;
2829
2830 if (data.salts_shown[salt_pos] == 1) continue;
2831
2832 salt_t *salt_buf = &data.salts_buf[salt_pos];
2833
2834 device_param->kernel_params_buf32[24] = salt_pos;
2835 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2836 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2837
2838 FILE *combs_fp = device_param->combs_fp;
2839
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 rewind (combs_fp);
2843 }
2844
2845 // innerloops
2846
2847 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2848 {
2849 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2850
2851 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2852
2853 if (data.devices_status == STATUS_CRACKED) break;
2854 if (data.devices_status == STATUS_ABORTED) break;
2855 if (data.devices_status == STATUS_QUIT) break;
2856 if (data.devices_status == STATUS_BYPASS) break;
2857
2858 // autotune start
2859
2860 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
2861
2862 // autotune stop
2863
2864 uint innerloop_left = innerloop_cnt - innerloop_pos;
2865
2866 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2867
2868 device_param->innerloop_pos = innerloop_pos;
2869 device_param->innerloop_left = innerloop_left;
2870
2871 device_param->kernel_params_buf32[27] = innerloop_left;
2872
2873 // i think we can get rid of this
2874 if (innerloop_left == 0)
2875 {
2876 puts ("bug, how should this happen????\n");
2877
2878 continue;
2879 }
2880
2881 // initialize amplifiers
2882
2883 if (data.attack_mode == ATTACK_MODE_COMBI)
2884 {
2885 char line_buf[BUFSIZ] = { 0 };
2886
2887 uint i = 0;
2888
2889 while (i < innerloop_left)
2890 {
2891 if (feof (combs_fp)) break;
2892
2893 int line_len = fgetl (combs_fp, line_buf);
2894
2895 if (line_len >= PW_MAX1) continue;
2896
2897 line_len = convert_from_hex (line_buf, line_len);
2898
2899 char *line_buf_new = line_buf;
2900
2901 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2902 {
2903 char rule_buf_out[BLOCK_SIZE] = { 0 };
2904
2905 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2906
2907 if (rule_len_out < 0)
2908 {
2909 data.words_progress_rejected[salt_pos] += pw_cnt;
2910
2911 continue;
2912 }
2913
2914 line_len = rule_len_out;
2915
2916 line_buf_new = rule_buf_out;
2917 }
2918
2919 line_len = MIN (line_len, PW_DICTMAX);
2920
2921 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2922
2923 memcpy (ptr, line_buf_new, line_len);
2924
2925 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2926
2927 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2928 {
2929 uppercase (ptr, line_len);
2930 }
2931
2932 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2933 {
2934 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2935 {
2936 ptr[line_len] = 0x80;
2937 }
2938
2939 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2940 {
2941 ptr[line_len] = 0x01;
2942 }
2943 }
2944
2945 device_param->combs_buf[i].pw_len = line_len;
2946
2947 i++;
2948 }
2949
2950 for (uint j = i; j < innerloop_left; j++)
2951 {
2952 device_param->combs_buf[j].i[0] = 0;
2953 device_param->combs_buf[j].i[1] = 0;
2954 device_param->combs_buf[j].i[2] = 0;
2955 device_param->combs_buf[j].i[3] = 0;
2956 device_param->combs_buf[j].i[4] = 0;
2957 device_param->combs_buf[j].i[5] = 0;
2958 device_param->combs_buf[j].i[6] = 0;
2959 device_param->combs_buf[j].i[7] = 0;
2960
2961 device_param->combs_buf[j].pw_len = 0;
2962 }
2963
2964 innerloop_left = i;
2965 }
2966 else if (data.attack_mode == ATTACK_MODE_BF)
2967 {
2968 u64 off = innerloop_pos;
2969
2970 device_param->kernel_params_mp_r_buf64[3] = off;
2971
2972 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2973 }
2974 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2975 {
2976 u64 off = innerloop_pos;
2977
2978 device_param->kernel_params_mp_buf64[3] = off;
2979
2980 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2981 }
2982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2983 {
2984 u64 off = innerloop_pos;
2985
2986 device_param->kernel_params_mp_buf64[3] = off;
2987
2988 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2989 }
2990
2991 // copy amplifiers
2992
2993 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2994 {
2995 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);
2996 }
2997 else if (data.attack_mode == ATTACK_MODE_COMBI)
2998 {
2999 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);
3000 }
3001 else if (data.attack_mode == ATTACK_MODE_BF)
3002 {
3003 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);
3004 }
3005 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3006 {
3007 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);
3008 }
3009 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3010 {
3011 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);
3012 }
3013
3014 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3015 {
3016 if (data.attack_mode == ATTACK_MODE_BF)
3017 {
3018 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3019 {
3020 const uint size_tm = 32 * sizeof (bs_word_t);
3021
3022 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3023
3024 run_kernel_tm (device_param);
3025
3026 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);
3027 }
3028 }
3029
3030 if (highest_pw_len < 16)
3031 {
3032 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3033 }
3034 else if (highest_pw_len < 32)
3035 {
3036 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3037 }
3038 else
3039 {
3040 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3041 }
3042 }
3043 else
3044 {
3045 run_kernel_amp (device_param, pws_cnt);
3046
3047 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3048
3049 if (data.opts_type & OPTS_TYPE_HOOK12)
3050 {
3051 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3052 }
3053
3054 uint iter = salt_buf->salt_iter;
3055
3056 uint loop_step = device_param->kernel_loops;
3057
3058 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
3059 {
3060 // autotune start
3061
3062 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL) loop_step = device_param->kernel_loops;
3063
3064 // autotune stop
3065
3066 uint loop_left = iter - loop_pos;
3067
3068 loop_left = MIN (loop_left, loop_step);
3069
3070 device_param->kernel_params_buf32[25] = loop_pos;
3071 device_param->kernel_params_buf32[26] = loop_left;
3072
3073 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3074
3075 if (data.devices_status == STATUS_CRACKED) break;
3076 if (data.devices_status == STATUS_ABORTED) break;
3077 if (data.devices_status == STATUS_QUIT) break;
3078 }
3079
3080 if (data.opts_type & OPTS_TYPE_HOOK23)
3081 {
3082 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3083
3084 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);
3085
3086 // do something with data
3087
3088 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);
3089 }
3090
3091 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3092 }
3093
3094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3095
3096 if (data.devices_status == STATUS_CRACKED) break;
3097 if (data.devices_status == STATUS_ABORTED) break;
3098 if (data.devices_status == STATUS_QUIT) break;
3099
3100 /**
3101 * result
3102 */
3103
3104 hc_thread_mutex_lock (mux_display);
3105
3106 check_cracked (device_param, salt_pos);
3107
3108 hc_thread_mutex_unlock (mux_display);
3109
3110 /**
3111 * progress
3112 */
3113
3114 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3115
3116 hc_thread_mutex_lock (mux_counter);
3117
3118 data.words_progress_done[salt_pos] += perf_sum_all;
3119
3120 hc_thread_mutex_unlock (mux_counter);
3121
3122 /**
3123 * speed
3124 */
3125
3126 float speed_ms;
3127
3128 hc_timer_get (device_param->timer_speed, speed_ms);
3129
3130 hc_timer_set (&device_param->timer_speed);
3131
3132 hc_thread_mutex_lock (mux_display);
3133
3134 device_param->speed_cnt[speed_pos] = perf_sum_all;
3135
3136 device_param->speed_ms[speed_pos] = speed_ms;
3137
3138 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3139
3140 hc_thread_mutex_unlock (mux_display);
3141
3142 speed_pos++;
3143
3144 if (speed_pos == SPEED_CACHE)
3145 {
3146 speed_pos = 0;
3147 }
3148 }
3149 }
3150
3151 device_param->speed_pos = speed_pos;
3152 }
3153
3154 static void load_segment (wl_data_t *wl_data, FILE *fd)
3155 {
3156 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3157
3158 wl_data->pos = 0;
3159
3160 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3161
3162 wl_data->buf[wl_data->cnt] = 0;
3163
3164 if (wl_data->cnt == 0) return;
3165
3166 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3167
3168 while (!feof (fd))
3169 {
3170 if (wl_data->cnt == wl_data->avail)
3171 {
3172 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3173
3174 wl_data->avail += wl_data->incr;
3175 }
3176
3177 const int c = fgetc (fd);
3178
3179 if (c == EOF) break;
3180
3181 wl_data->buf[wl_data->cnt] = (char) c;
3182
3183 wl_data->cnt++;
3184
3185 if (c == '\n') break;
3186 }
3187
3188 // ensure stream ends with a newline
3189
3190 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3191 {
3192 wl_data->cnt++;
3193
3194 wl_data->buf[wl_data->cnt - 1] = '\n';
3195 }
3196
3197 return;
3198 }
3199
3200 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3201 {
3202 char *ptr = buf;
3203
3204 for (u32 i = 0; i < sz; i++, ptr++)
3205 {
3206 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3207
3208 if (i == 7)
3209 {
3210 *off = i;
3211 *len = i;
3212
3213 return;
3214 }
3215
3216 if (*ptr != '\n') continue;
3217
3218 *off = i + 1;
3219
3220 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3221
3222 *len = i;
3223
3224 return;
3225 }
3226
3227 *off = sz;
3228 *len = sz;
3229 }
3230
3231 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3232 {
3233 char *ptr = buf;
3234
3235 for (u32 i = 0; i < sz; i++, ptr++)
3236 {
3237 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3238
3239 if (*ptr != '\n') continue;
3240
3241 *off = i + 1;
3242
3243 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3244
3245 *len = i;
3246
3247 return;
3248 }
3249
3250 *off = sz;
3251 *len = sz;
3252 }
3253
3254 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3255 {
3256 char *ptr = buf;
3257
3258 for (u32 i = 0; i < sz; i++, ptr++)
3259 {
3260 if (*ptr != '\n') continue;
3261
3262 *off = i + 1;
3263
3264 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3265
3266 *len = i;
3267
3268 return;
3269 }
3270
3271 *off = sz;
3272 *len = sz;
3273 }
3274
3275 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3276 {
3277 while (wl_data->pos < wl_data->cnt)
3278 {
3279 uint off;
3280 uint len;
3281
3282 char *ptr = wl_data->buf + wl_data->pos;
3283
3284 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3285
3286 wl_data->pos += off;
3287
3288 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3289 {
3290 char rule_buf_out[BLOCK_SIZE] = { 0 };
3291
3292 int rule_len_out = -1;
3293
3294 if (len < BLOCK_SIZE)
3295 {
3296 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3297 }
3298
3299 if (rule_len_out < 0)
3300 {
3301 continue;
3302 }
3303
3304 if (rule_len_out > PW_MAX)
3305 {
3306 continue;
3307 }
3308 }
3309 else
3310 {
3311 if (len > PW_MAX)
3312 {
3313 continue;
3314 }
3315 }
3316
3317 *out_buf = ptr;
3318 *out_len = len;
3319
3320 return;
3321 }
3322
3323 if (feof (fd))
3324 {
3325 fprintf (stderr, "bug!!\n");
3326
3327 return;
3328 }
3329
3330 load_segment (wl_data, fd);
3331
3332 get_next_word (wl_data, fd, out_buf, out_len);
3333 }
3334
3335 #ifdef _POSIX
3336 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3337 #endif
3338
3339 #ifdef _WIN
3340 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3341 #endif
3342 {
3343 hc_signal (NULL);
3344
3345 dictstat_t d;
3346
3347 d.cnt = 0;
3348
3349 #ifdef _POSIX
3350 fstat (fileno (fd), &d.stat);
3351 #endif
3352
3353 #ifdef _WIN
3354 _fstat64 (fileno (fd), &d.stat);
3355 #endif
3356
3357 d.stat.st_mode = 0;
3358 d.stat.st_nlink = 0;
3359 d.stat.st_uid = 0;
3360 d.stat.st_gid = 0;
3361 d.stat.st_rdev = 0;
3362 d.stat.st_atime = 0;
3363
3364 #ifdef _POSIX
3365 d.stat.st_blksize = 0;
3366 d.stat.st_blocks = 0;
3367 #endif
3368
3369 if (d.stat.st_size == 0) return 0;
3370
3371 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3372
3373 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3374 {
3375 if (d_cache)
3376 {
3377 u64 cnt = d_cache->cnt;
3378
3379 u64 keyspace = cnt;
3380
3381 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3382 {
3383 keyspace *= data.kernel_rules_cnt;
3384 }
3385 else if (data.attack_kern == ATTACK_KERN_COMBI)
3386 {
3387 keyspace *= data.combs_cnt;
3388 }
3389
3390 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);
3391 if (data.quiet == 0) log_info ("");
3392
3393 hc_signal (sigHandler_default);
3394
3395 return (keyspace);
3396 }
3397 }
3398
3399 time_t now = 0;
3400 time_t prev = 0;
3401
3402 u64 comp = 0;
3403 u64 cnt = 0;
3404 u64 cnt2 = 0;
3405
3406 while (!feof (fd))
3407 {
3408 load_segment (wl_data, fd);
3409
3410 comp += wl_data->cnt;
3411
3412 u32 i = 0;
3413
3414 while (i < wl_data->cnt)
3415 {
3416 u32 len;
3417 u32 off;
3418
3419 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3420
3421 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3422 {
3423 char rule_buf_out[BLOCK_SIZE] = { 0 };
3424
3425 int rule_len_out = -1;
3426
3427 if (len < BLOCK_SIZE)
3428 {
3429 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3430 }
3431
3432 if (rule_len_out < 0)
3433 {
3434 len = PW_MAX1;
3435 }
3436 else
3437 {
3438 len = rule_len_out;
3439 }
3440 }
3441
3442 if (len < PW_MAX1)
3443 {
3444 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3445 {
3446 cnt += data.kernel_rules_cnt;
3447 }
3448 else if (data.attack_kern == ATTACK_KERN_COMBI)
3449 {
3450 cnt += data.combs_cnt;
3451 }
3452
3453 d.cnt++;
3454 }
3455
3456 i += off;
3457
3458 cnt2++;
3459 }
3460
3461 time (&now);
3462
3463 if ((now - prev) == 0) continue;
3464
3465 float percent = (float) comp / (float) d.stat.st_size;
3466
3467 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);
3468
3469 time (&prev);
3470 }
3471
3472 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);
3473 if (data.quiet == 0) log_info ("");
3474
3475 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3476
3477 hc_signal (sigHandler_default);
3478
3479 return (cnt);
3480 }
3481
3482 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3483 {
3484 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3485 }
3486
3487 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3488 {
3489 if (data.devices_status == STATUS_BYPASS) return 0;
3490
3491 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3492
3493 uint cache_cnt = pw_cache->cnt;
3494
3495 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3496
3497 memcpy (pw_hc1, pw_buf, pw_len);
3498
3499 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3500
3501 uint pws_cnt = device_param->pws_cnt;
3502
3503 cache_cnt++;
3504
3505 pw_t *pw = device_param->pws_buf + pws_cnt;
3506
3507 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3508
3509 pw->pw_len = pw_len;
3510
3511 pws_cnt++;
3512
3513 device_param->pws_cnt = pws_cnt;
3514 device_param->pw_cnt = pws_cnt * 1;
3515
3516 cache_cnt = 0;
3517
3518 pw_cache->cnt = cache_cnt;
3519
3520 return pws_cnt;
3521 }
3522
3523 static void *thread_monitor (void *p)
3524 {
3525 uint runtime_check = 0;
3526 uint remove_check = 0;
3527 uint status_check = 0;
3528 uint restore_check = 0;
3529
3530 uint restore_left = data.restore_timer;
3531 uint remove_left = data.remove_timer;
3532 uint status_left = data.status_timer;
3533
3534 #ifdef HAVE_HWMON
3535 uint hwmon_check = 0;
3536
3537 // these variables are mainly used for fan control (AMD only)
3538
3539 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3540
3541 // temperature controller "loopback" values
3542
3543 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3544 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3545
3546 #ifdef HAVE_ADL
3547 int temp_threshold = 1; // degrees celcius
3548
3549 int fan_speed_min = 15; // in percentage
3550 int fan_speed_max = 100;
3551 #endif // HAVE_ADL
3552
3553 time_t last_temp_check_time;
3554 #endif // HAVE_HWMON
3555
3556 uint sleep_time = 1;
3557
3558 if (data.runtime)
3559 {
3560 runtime_check = 1;
3561 }
3562
3563 if (data.restore_timer)
3564 {
3565 restore_check = 1;
3566 }
3567
3568 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3569 {
3570 remove_check = 1;
3571 }
3572
3573 if (data.status == 1)
3574 {
3575 status_check = 1;
3576 }
3577
3578 #ifdef HAVE_HWMON
3579 if (data.gpu_temp_disable == 0)
3580 {
3581 time (&last_temp_check_time);
3582
3583 hwmon_check = 1;
3584 }
3585 #endif
3586
3587 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3588 {
3589 #ifdef HAVE_HWMON
3590 if (hwmon_check == 0)
3591 #endif
3592 return (p);
3593 }
3594
3595 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3596 {
3597 hc_sleep (sleep_time);
3598
3599 if (data.devices_status != STATUS_RUNNING) continue;
3600
3601 #ifdef HAVE_HWMON
3602 if (hwmon_check == 1)
3603 {
3604 hc_thread_mutex_lock (mux_adl);
3605
3606 time_t temp_check_time;
3607
3608 time (&temp_check_time);
3609
3610 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3611
3612 if (Ta == 0) Ta = 1;
3613
3614 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3615 {
3616 hc_device_param_t *device_param = &data.devices_param[device_id];
3617
3618 if (device_param->skipped) continue;
3619
3620 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3621
3622 const int temperature = hm_get_temperature_with_device_id (device_id);
3623
3624 if (temperature > (int) data.gpu_temp_abort)
3625 {
3626 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3627
3628 if (data.devices_status != STATUS_QUIT) myabort ();
3629
3630 break;
3631 }
3632
3633 #ifdef HAVE_ADL
3634 const int gpu_temp_retain = data.gpu_temp_retain;
3635
3636 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3637 {
3638 if (data.hm_device[device_id].fan_supported == 1)
3639 {
3640 int temp_cur = temperature;
3641
3642 int temp_diff_new = gpu_temp_retain - temp_cur;
3643
3644 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3645
3646 // calculate Ta value (time difference in seconds between the last check and this check)
3647
3648 last_temp_check_time = temp_check_time;
3649
3650 float Kp = 1.8;
3651 float Ki = 0.005;
3652 float Kd = 6;
3653
3654 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3655
3656 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);
3657
3658 if (abs (fan_diff_required) >= temp_threshold)
3659 {
3660 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3661
3662 int fan_speed_level = fan_speed_cur;
3663
3664 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3665
3666 int fan_speed_new = fan_speed_level - fan_diff_required;
3667
3668 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3669 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3670
3671 if (fan_speed_new != fan_speed_cur)
3672 {
3673 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3674 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3675
3676 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3677 {
3678 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3679
3680 fan_speed_chgd[device_id] = 1;
3681 }
3682
3683 temp_diff_old[device_id] = temp_diff_new;
3684 }
3685 }
3686 }
3687 }
3688 #endif // HAVE_ADL
3689 }
3690
3691 hc_thread_mutex_unlock (mux_adl);
3692 }
3693 #endif // HAVE_HWMON
3694
3695 if (restore_check == 1)
3696 {
3697 restore_left--;
3698
3699 if (restore_left == 0)
3700 {
3701 if (data.restore_disable == 0) cycle_restore ();
3702
3703 restore_left = data.restore_timer;
3704 }
3705 }
3706
3707 if ((runtime_check == 1) && (data.runtime_start > 0))
3708 {
3709 time_t runtime_cur;
3710
3711 time (&runtime_cur);
3712
3713 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3714
3715 if (runtime_left <= 0)
3716 {
3717 if (data.benchmark == 0)
3718 {
3719 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3720 }
3721
3722 if (data.devices_status != STATUS_QUIT) myabort ();
3723 }
3724 }
3725
3726 if (remove_check == 1)
3727 {
3728 remove_left--;
3729
3730 if (remove_left == 0)
3731 {
3732 if (data.digests_saved != data.digests_done)
3733 {
3734 data.digests_saved = data.digests_done;
3735
3736 save_hash ();
3737 }
3738
3739 remove_left = data.remove_timer;
3740 }
3741 }
3742
3743 if (status_check == 1)
3744 {
3745 status_left--;
3746
3747 if (status_left == 0)
3748 {
3749 hc_thread_mutex_lock (mux_display);
3750
3751 if (data.quiet == 0) clear_prompt ();
3752
3753 if (data.quiet == 0) log_info ("");
3754
3755 status_display ();
3756
3757 if (data.quiet == 0) log_info ("");
3758
3759 hc_thread_mutex_unlock (mux_display);
3760
3761 status_left = data.status_timer;
3762 }
3763 }
3764 }
3765
3766 #ifdef HAVE_HWMON
3767 myfree (fan_speed_chgd);
3768
3769 myfree (temp_diff_old);
3770 myfree (temp_diff_sum);
3771 #endif
3772
3773 p = NULL;
3774
3775 return (p);
3776 }
3777
3778 static void *thread_outfile_remove (void *p)
3779 {
3780 // some hash-dependent constants
3781 char *outfile_dir = data.outfile_check_directory;
3782 uint dgst_size = data.dgst_size;
3783 uint isSalted = data.isSalted;
3784 uint esalt_size = data.esalt_size;
3785 uint hash_mode = data.hash_mode;
3786
3787 uint outfile_check_timer = data.outfile_check_timer;
3788
3789 char separator = data.separator;
3790
3791 // some hash-dependent functions
3792 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3793 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3794
3795 // buffers
3796 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3797
3798 hash_buf.digest = mymalloc (dgst_size);
3799
3800 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3801
3802 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3803
3804 uint digest_buf[64] = { 0 };
3805
3806 outfile_data_t *out_info = NULL;
3807
3808 char **out_files = NULL;
3809
3810 time_t folder_mtime = 0;
3811
3812 int out_cnt = 0;
3813
3814 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3815
3816 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3817 {
3818 hc_sleep (1);
3819
3820 if (data.devices_status != STATUS_RUNNING) continue;
3821
3822 check_left--;
3823
3824 if (check_left == 0)
3825 {
3826 struct stat outfile_check_stat;
3827
3828 if (stat (outfile_dir, &outfile_check_stat) == 0)
3829 {
3830 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3831
3832 if (is_dir == 1)
3833 {
3834 if (outfile_check_stat.st_mtime > folder_mtime)
3835 {
3836 char **out_files_new = scan_directory (outfile_dir);
3837
3838 int out_cnt_new = count_dictionaries (out_files_new);
3839
3840 outfile_data_t *out_info_new = NULL;
3841
3842 if (out_cnt_new > 0)
3843 {
3844 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3845
3846 for (int i = 0; i < out_cnt_new; i++)
3847 {
3848 out_info_new[i].file_name = out_files_new[i];
3849
3850 // check if there are files that we have seen/checked before (and not changed)
3851
3852 for (int j = 0; j < out_cnt; j++)
3853 {
3854 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3855 {
3856 struct stat outfile_stat;
3857
3858 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3859 {
3860 if (outfile_stat.st_ctime == out_info[j].ctime)
3861 {
3862 out_info_new[i].ctime = out_info[j].ctime;
3863 out_info_new[i].seek = out_info[j].seek;
3864 }
3865 }
3866 }
3867 }
3868 }
3869 }
3870
3871 local_free (out_info);
3872 local_free (out_files);
3873
3874 out_files = out_files_new;
3875 out_cnt = out_cnt_new;
3876 out_info = out_info_new;
3877
3878 folder_mtime = outfile_check_stat.st_mtime;
3879 }
3880
3881 for (int j = 0; j < out_cnt; j++)
3882 {
3883 FILE *fp = fopen (out_info[j].file_name, "rb");
3884
3885 if (fp != NULL)
3886 {
3887 //hc_thread_mutex_lock (mux_display);
3888
3889 #ifdef _POSIX
3890 struct stat outfile_stat;
3891
3892 fstat (fileno (fp), &outfile_stat);
3893 #endif
3894
3895 #ifdef _WIN
3896 struct stat64 outfile_stat;
3897
3898 _fstat64 (fileno (fp), &outfile_stat);
3899 #endif
3900
3901 if (outfile_stat.st_ctime > out_info[j].ctime)
3902 {
3903 out_info[j].ctime = outfile_stat.st_ctime;
3904 out_info[j].seek = 0;
3905 }
3906
3907 fseek (fp, out_info[j].seek, SEEK_SET);
3908
3909 while (!feof (fp))
3910 {
3911 char line_buf[BUFSIZ] = { 0 };
3912
3913 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3914
3915 if (ptr == NULL) break;
3916
3917 int line_len = strlen (line_buf);
3918
3919 if (line_len <= 0) continue;
3920
3921 int iter = MAX_CUT_TRIES;
3922
3923 for (uint i = line_len - 1; i && iter; i--, line_len--)
3924 {
3925 if (line_buf[i] != separator) continue;
3926
3927 int parser_status = PARSER_OK;
3928
3929 if ((hash_mode != 2500) && (hash_mode != 6800))
3930 {
3931 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3932 }
3933
3934 uint found = 0;
3935
3936 if (parser_status == PARSER_OK)
3937 {
3938 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3939 {
3940 if (data.salts_shown[salt_pos] == 1) continue;
3941
3942 salt_t *salt_buf = &data.salts_buf[salt_pos];
3943
3944 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3945 {
3946 uint idx = salt_buf->digests_offset + digest_pos;
3947
3948 if (data.digests_shown[idx] == 1) continue;
3949
3950 uint cracked = 0;
3951
3952 if (hash_mode == 6800)
3953 {
3954 if (i == salt_buf->salt_len)
3955 {
3956 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3957 }
3958 }
3959 else if (hash_mode == 2500)
3960 {
3961 // BSSID : MAC1 : MAC2 (:plain)
3962 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3963 {
3964 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3965
3966 if (!cracked) continue;
3967
3968 // now compare MAC1 and MAC2 too, since we have this additional info
3969 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3970 char *mac2_pos = mac1_pos + 12 + 1;
3971
3972 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3973 wpa_t *wpa = &wpas[salt_pos];
3974
3975 uint pke[25] = { 0 };
3976
3977 char *pke_ptr = (char *) pke;
3978
3979 for (uint i = 0; i < 25; i++)
3980 {
3981 pke[i] = byte_swap_32 (wpa->pke[i]);
3982 }
3983
3984 u8 mac1[6] = { 0 };
3985 u8 mac2[6] = { 0 };
3986
3987 memcpy (mac1, pke_ptr + 23, 6);
3988 memcpy (mac2, pke_ptr + 29, 6);
3989
3990 // compare hex string(s) vs binary MAC address(es)
3991
3992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3993 {
3994 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3995 {
3996 cracked = 0;
3997 break;
3998 }
3999 }
4000
4001 // early skip ;)
4002 if (!cracked) continue;
4003
4004 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4005 {
4006 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4007 {
4008 cracked = 0;
4009 break;
4010 }
4011 }
4012 }
4013 }
4014 else
4015 {
4016 char *digests_buf_ptr = (char *) data.digests_buf;
4017
4018 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4019
4020 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4021 }
4022
4023 if (cracked == 1)
4024 {
4025 found = 1;
4026
4027 data.digests_shown[idx] = 1;
4028
4029 data.digests_done++;
4030
4031 salt_buf->digests_done++;
4032
4033 if (salt_buf->digests_done == salt_buf->digests_cnt)
4034 {
4035 data.salts_shown[salt_pos] = 1;
4036
4037 data.salts_done++;
4038
4039 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4040 }
4041 }
4042 }
4043
4044 if (data.devices_status == STATUS_CRACKED) break;
4045 }
4046 }
4047
4048 if (found) break;
4049
4050 if (data.devices_status == STATUS_CRACKED) break;
4051
4052 iter--;
4053 }
4054
4055 if (data.devices_status == STATUS_CRACKED) break;
4056 }
4057
4058 out_info[j].seek = ftell (fp);
4059
4060 //hc_thread_mutex_unlock (mux_display);
4061
4062 fclose (fp);
4063 }
4064 }
4065 }
4066 }
4067
4068 check_left = outfile_check_timer;
4069 }
4070 }
4071
4072 if (esalt_size) local_free (hash_buf.esalt);
4073
4074 if (isSalted) local_free (hash_buf.salt);
4075
4076 local_free (hash_buf.digest);
4077
4078 local_free (out_info);
4079
4080 local_free (out_files);
4081
4082 p = NULL;
4083
4084 return (p);
4085 }
4086
4087 static uint get_work (hc_device_param_t *device_param, const u64 max)
4088 {
4089 hc_thread_mutex_lock (mux_dispatcher);
4090
4091 const u64 words_cur = data.words_cur;
4092 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4093
4094 device_param->words_off = words_cur;
4095
4096 const u64 words_left = words_base - words_cur;
4097
4098 if (data.kernel_power_all > words_left)
4099 {
4100 if (data.kernel_power_div == 0)
4101 {
4102 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4103 }
4104 }
4105
4106 if (data.kernel_power_div)
4107 {
4108 if (device_param->kernel_power == device_param->kernel_power_user)
4109 {
4110 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4111
4112 if (kernel_power_new < device_param->kernel_power)
4113 {
4114 device_param->kernel_power = kernel_power_new;
4115 }
4116 }
4117 }
4118
4119 const uint kernel_power = device_param->kernel_power;
4120
4121 uint work = MIN (words_left, kernel_power);
4122
4123 work = MIN (work, max);
4124
4125 data.words_cur += work;
4126
4127 hc_thread_mutex_unlock (mux_dispatcher);
4128
4129 return work;
4130 }
4131
4132 static void *thread_calc_stdin (void *p)
4133 {
4134 hc_device_param_t *device_param = (hc_device_param_t *) p;
4135
4136 if (device_param->skipped) return NULL;
4137
4138 const uint attack_kern = data.attack_kern;
4139
4140 const uint kernel_power = device_param->kernel_power;
4141
4142 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4143 {
4144 hc_thread_mutex_lock (mux_dispatcher);
4145
4146 if (feof (stdin) != 0)
4147 {
4148 hc_thread_mutex_unlock (mux_dispatcher);
4149
4150 break;
4151 }
4152
4153 uint words_cur = 0;
4154
4155 while (words_cur < kernel_power)
4156 {
4157 char buf[BUFSIZ] = { 0 };
4158
4159 char *line_buf = fgets (buf, sizeof (buf), stdin);
4160
4161 if (line_buf == NULL) break;
4162
4163 uint line_len = in_superchop (line_buf);
4164
4165 line_len = convert_from_hex (line_buf, line_len);
4166
4167 // post-process rule engine
4168
4169 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4170 {
4171 char rule_buf_out[BLOCK_SIZE] = { 0 };
4172
4173 int rule_len_out = -1;
4174
4175 if (line_len < BLOCK_SIZE)
4176 {
4177 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4178 }
4179
4180 if (rule_len_out < 0) continue;
4181
4182 line_buf = rule_buf_out;
4183 line_len = rule_len_out;
4184 }
4185
4186 if (line_len > PW_MAX)
4187 {
4188 continue;
4189 }
4190
4191 if (attack_kern == ATTACK_KERN_STRAIGHT)
4192 {
4193 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4194 {
4195 hc_thread_mutex_lock (mux_counter);
4196
4197 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4198 {
4199 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4200 }
4201
4202 hc_thread_mutex_unlock (mux_counter);
4203
4204 continue;
4205 }
4206 }
4207 else if (attack_kern == ATTACK_KERN_COMBI)
4208 {
4209 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4210 // since we still need to combine the plains
4211
4212 if (line_len > data.pw_max)
4213 {
4214 hc_thread_mutex_lock (mux_counter);
4215
4216 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4217 {
4218 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4219 }
4220
4221 hc_thread_mutex_unlock (mux_counter);
4222
4223 continue;
4224 }
4225 }
4226
4227 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4228
4229 words_cur++;
4230
4231 if (data.devices_status == STATUS_CRACKED) break;
4232 if (data.devices_status == STATUS_ABORTED) break;
4233 if (data.devices_status == STATUS_QUIT) break;
4234 if (data.devices_status == STATUS_BYPASS) break;
4235 }
4236
4237 hc_thread_mutex_unlock (mux_dispatcher);
4238
4239 if (data.devices_status == STATUS_CRACKED) break;
4240 if (data.devices_status == STATUS_ABORTED) break;
4241 if (data.devices_status == STATUS_QUIT) break;
4242 if (data.devices_status == STATUS_BYPASS) break;
4243
4244 // we need 2 flushing because we have two independant caches and it can occur
4245 // that one buffer is already at threshold plus for that length also exists
4246 // more data in the 2nd buffer so it would overflow
4247
4248 // flush session 1
4249
4250 {
4251 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4252 {
4253 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4254
4255 const uint pw_cache_cnt = pw_cache->cnt;
4256
4257 if (pw_cache_cnt == 0) continue;
4258
4259 pw_cache->cnt = 0;
4260
4261 uint pws_cnt = device_param->pws_cnt;
4262
4263 pw_t *pw = device_param->pws_buf + pws_cnt;
4264
4265 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4266
4267 pw->pw_len = pw_len;
4268
4269 uint pw_cnt = device_param->pw_cnt;
4270
4271 pw_cnt += pw_cache_cnt;
4272
4273 device_param->pw_cnt = pw_cnt;
4274
4275 pws_cnt++;
4276
4277 device_param->pws_cnt = pws_cnt;
4278
4279 if (pws_cnt == device_param->kernel_power_user) break;
4280 }
4281
4282 const uint pw_cnt = device_param->pw_cnt;
4283 const uint pws_cnt = device_param->pws_cnt;
4284
4285 if (pws_cnt)
4286 {
4287 run_copy (device_param, pws_cnt);
4288
4289 run_cracker (device_param, pw_cnt, pws_cnt);
4290
4291 device_param->pw_cnt = 0;
4292 device_param->pws_cnt = 0;
4293 }
4294 }
4295
4296 // flush session 2
4297
4298 {
4299 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4300 {
4301 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4302
4303 const uint pw_cache_cnt = pw_cache->cnt;
4304
4305 if (pw_cache_cnt == 0) continue;
4306
4307 pw_cache->cnt = 0;
4308
4309 uint pws_cnt = device_param->pws_cnt;
4310
4311 pw_t *pw = device_param->pws_buf + pws_cnt;
4312
4313 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4314
4315 pw->pw_len = pw_len;
4316
4317 uint pw_cnt = device_param->pw_cnt;
4318
4319 pw_cnt += pw_cache_cnt;
4320
4321 device_param->pw_cnt = pw_cnt;
4322
4323 pws_cnt++;
4324
4325 device_param->pws_cnt = pws_cnt;
4326 }
4327
4328 const uint pw_cnt = device_param->pw_cnt;
4329 const uint pws_cnt = device_param->pws_cnt;
4330
4331 if (pws_cnt)
4332 {
4333 run_copy (device_param, pws_cnt);
4334
4335 run_cracker (device_param, pw_cnt, pws_cnt);
4336
4337 device_param->pw_cnt = 0;
4338 device_param->pws_cnt = 0;
4339 }
4340 }
4341 }
4342
4343 return NULL;
4344 }
4345
4346 static void *thread_calc (void *p)
4347 {
4348 hc_device_param_t *device_param = (hc_device_param_t *) p;
4349
4350 if (device_param->skipped) return NULL;
4351
4352 const uint attack_mode = data.attack_mode;
4353 const uint attack_kern = data.attack_kern;
4354
4355 if (attack_mode == ATTACK_MODE_BF)
4356 {
4357 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4358 {
4359 const uint work = get_work (device_param, -1);
4360
4361 if (work == 0) break;
4362
4363 const u64 words_off = device_param->words_off;
4364 const u64 words_fin = words_off + work;
4365
4366 const uint pw_cnt = work;
4367 const uint pws_cnt = work;
4368
4369 device_param->pw_cnt = pw_cnt;
4370 device_param->pws_cnt = pws_cnt;
4371
4372 if (pws_cnt)
4373 {
4374 run_copy (device_param, pws_cnt);
4375
4376 run_cracker (device_param, pw_cnt, pws_cnt);
4377
4378 device_param->pw_cnt = 0;
4379 device_param->pws_cnt = 0;
4380 }
4381
4382 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4383
4384 if (data.devices_status == STATUS_CRACKED) break;
4385 if (data.devices_status == STATUS_ABORTED) break;
4386 if (data.devices_status == STATUS_QUIT) break;
4387 if (data.devices_status == STATUS_BYPASS) break;
4388
4389 device_param->words_done = words_fin;
4390
4391 // first adjust kernel_accel
4392
4393 /*
4394 if (data.kernel_power_div) continue;
4395
4396 double exec_ms_total = get_avg_exec_time (device_param);
4397
4398 #define WL1_MS_ACCEL 8
4399 #define WL2_MS_ACCEL 24
4400 #define WL3_MS_ACCEL 72
4401
4402 if ((data.workload_profile == 3) || (data.benchmark == 1))
4403 {
4404 #define MIN_ACCEL 0
4405 #define MAX_ACCEL device_param->kernel_accel_max
4406
4407 if (exec_ms_total < WL3_MS_ACCEL)
4408 {
4409 u32 adj = device_param->kernel_accel * (WL3_MS_ACCEL / exec_ms_total);
4410
4411 if (device_param->kernel_accel <= (MAX_ACCEL - adj))
4412 {
4413 device_param->kernel_accel += adj;
4414
4415 uint kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
4416
4417 device_param->kernel_power = kernel_power;
4418 }
4419
4420 clean_from_pos (device_param, 1);
4421 }
4422 }
4423 */
4424 }
4425 }
4426 else
4427 {
4428 const uint segment_size = data.segment_size;
4429
4430 char *dictfile = data.dictfile;
4431
4432 if (attack_mode == ATTACK_MODE_COMBI)
4433 {
4434 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4435 {
4436 dictfile = data.dictfile2;
4437 }
4438 }
4439
4440 FILE *fd = fopen (dictfile, "rb");
4441
4442 if (fd == NULL)
4443 {
4444 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4445
4446 return NULL;
4447 }
4448
4449 if (attack_mode == ATTACK_MODE_COMBI)
4450 {
4451 const uint combs_mode = data.combs_mode;
4452
4453 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4454 {
4455 const char *dictfilec = data.dictfile2;
4456
4457 FILE *combs_fp = fopen (dictfilec, "rb");
4458
4459 if (combs_fp == NULL)
4460 {
4461 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4462
4463 fclose (fd);
4464
4465 return NULL;
4466 }
4467
4468 device_param->combs_fp = combs_fp;
4469 }
4470 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4471 {
4472 const char *dictfilec = data.dictfile;
4473
4474 FILE *combs_fp = fopen (dictfilec, "rb");
4475
4476 if (combs_fp == NULL)
4477 {
4478 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4479
4480 fclose (fd);
4481
4482 return NULL;
4483 }
4484
4485 device_param->combs_fp = combs_fp;
4486 }
4487 }
4488
4489 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4490
4491 wl_data->buf = (char *) mymalloc (segment_size);
4492 wl_data->avail = segment_size;
4493 wl_data->incr = segment_size;
4494 wl_data->cnt = 0;
4495 wl_data->pos = 0;
4496
4497 u64 words_cur = 0;
4498
4499 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4500 {
4501 u64 words_off = 0;
4502 u64 words_fin = 0;
4503
4504 u64 max = -1;
4505
4506 while (max)
4507 {
4508 const uint work = get_work (device_param, max);
4509
4510 if (work == 0) break;
4511
4512 words_off = device_param->words_off;
4513 words_fin = words_off + work;
4514
4515 char *line_buf;
4516 uint line_len;
4517
4518 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4519
4520 max = 0;
4521
4522 for ( ; words_cur < words_fin; words_cur++)
4523 {
4524 get_next_word (wl_data, fd, &line_buf, &line_len);
4525
4526 line_len = convert_from_hex (line_buf, line_len);
4527
4528 // post-process rule engine
4529
4530 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4531 {
4532 char rule_buf_out[BLOCK_SIZE] = { 0 };
4533
4534 int rule_len_out = -1;
4535
4536 if (line_len < BLOCK_SIZE)
4537 {
4538 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4539 }
4540
4541 if (rule_len_out < 0) continue;
4542
4543 line_buf = rule_buf_out;
4544 line_len = rule_len_out;
4545 }
4546
4547 if (attack_kern == ATTACK_KERN_STRAIGHT)
4548 {
4549 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4550 {
4551 max++;
4552
4553 hc_thread_mutex_lock (mux_counter);
4554
4555 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4556 {
4557 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4558 }
4559
4560 hc_thread_mutex_unlock (mux_counter);
4561
4562 continue;
4563 }
4564 }
4565 else if (attack_kern == ATTACK_KERN_COMBI)
4566 {
4567 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4568 // since we still need to combine the plains
4569
4570 if (line_len > data.pw_max)
4571 {
4572 max++;
4573
4574 hc_thread_mutex_lock (mux_counter);
4575
4576 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4577 {
4578 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4579 }
4580
4581 hc_thread_mutex_unlock (mux_counter);
4582
4583 continue;
4584 }
4585 }
4586
4587 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4588
4589 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4590
4591 if (data.devices_status == STATUS_CRACKED) break;
4592 if (data.devices_status == STATUS_ABORTED) break;
4593 if (data.devices_status == STATUS_QUIT) break;
4594 if (data.devices_status == STATUS_BYPASS) break;
4595 }
4596
4597 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4598
4599 if (data.devices_status == STATUS_CRACKED) break;
4600 if (data.devices_status == STATUS_ABORTED) break;
4601 if (data.devices_status == STATUS_QUIT) break;
4602 if (data.devices_status == STATUS_BYPASS) break;
4603 }
4604
4605 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4606
4607 if (data.devices_status == STATUS_CRACKED) break;
4608 if (data.devices_status == STATUS_ABORTED) break;
4609 if (data.devices_status == STATUS_QUIT) break;
4610 if (data.devices_status == STATUS_BYPASS) break;
4611
4612 // we need 2 flushing because we have two independant caches and it can occur
4613 // that one buffer is already at threshold plus for that length also exists
4614 // more data in the 2nd buffer so it would overflow
4615
4616 //
4617 // flush session 1
4618 //
4619
4620 {
4621 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4622 {
4623 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4624
4625 const uint pw_cache_cnt = pw_cache->cnt;
4626
4627 if (pw_cache_cnt == 0) continue;
4628
4629 pw_cache->cnt = 0;
4630
4631 uint pws_cnt = device_param->pws_cnt;
4632
4633 pw_t *pw = device_param->pws_buf + pws_cnt;
4634
4635 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4636
4637 pw->pw_len = pw_len;
4638
4639 uint pw_cnt = device_param->pw_cnt;
4640
4641 pw_cnt += pw_cache_cnt;
4642
4643 device_param->pw_cnt = pw_cnt;
4644
4645 pws_cnt++;
4646
4647 device_param->pws_cnt = pws_cnt;
4648
4649 if (pws_cnt == device_param->kernel_power_user) break;
4650 }
4651
4652 const uint pw_cnt = device_param->pw_cnt;
4653 const uint pws_cnt = device_param->pws_cnt;
4654
4655 if (pws_cnt)
4656 {
4657 run_copy (device_param, pws_cnt);
4658
4659 run_cracker (device_param, pw_cnt, pws_cnt);
4660
4661 device_param->pw_cnt = 0;
4662 device_param->pws_cnt = 0;
4663 }
4664
4665 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4666
4667 if (data.devices_status == STATUS_CRACKED) break;
4668 if (data.devices_status == STATUS_ABORTED) break;
4669 if (data.devices_status == STATUS_QUIT) break;
4670 if (data.devices_status == STATUS_BYPASS) break;
4671 }
4672
4673 //
4674 // flush session 2
4675 //
4676
4677 {
4678 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4679 {
4680 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4681
4682 const uint pw_cache_cnt = pw_cache->cnt;
4683
4684 if (pw_cache_cnt == 0) continue;
4685
4686 pw_cache->cnt = 0;
4687
4688 uint pws_cnt = device_param->pws_cnt;
4689
4690 pw_t *pw = device_param->pws_buf + pws_cnt;
4691
4692 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4693
4694 pw->pw_len = pw_len;
4695
4696 uint pw_cnt = device_param->pw_cnt;
4697
4698 pw_cnt += pw_cache_cnt;
4699
4700 device_param->pw_cnt = pw_cnt;
4701
4702 pws_cnt++;
4703
4704 device_param->pws_cnt = pws_cnt;
4705 }
4706
4707 const uint pw_cnt = device_param->pw_cnt;
4708 const uint pws_cnt = device_param->pws_cnt;
4709
4710 if (pws_cnt)
4711 {
4712 run_copy (device_param, pws_cnt);
4713
4714 run_cracker (device_param, pw_cnt, pws_cnt);
4715
4716 device_param->pw_cnt = 0;
4717 device_param->pws_cnt = 0;
4718 }
4719
4720 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4721
4722 if (data.devices_status == STATUS_CRACKED) break;
4723 if (data.devices_status == STATUS_ABORTED) break;
4724 if (data.devices_status == STATUS_QUIT) break;
4725 if (data.devices_status == STATUS_BYPASS) break;
4726 }
4727
4728 if (words_fin == 0) break;
4729
4730 device_param->words_done = words_fin;
4731 }
4732
4733 if (attack_mode == ATTACK_MODE_COMBI)
4734 {
4735 fclose (device_param->combs_fp);
4736 }
4737
4738 free (wl_data->buf);
4739 free (wl_data);
4740
4741 fclose (fd);
4742 }
4743
4744 return NULL;
4745 }
4746
4747 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4748 {
4749 if (!device_param)
4750 {
4751 log_error ("ERROR: %s : Invalid argument", __func__);
4752
4753 exit (-1);
4754 }
4755
4756 salt_t *salt_buf = &data.salts_buf[salt_pos];
4757
4758 device_param->kernel_params_buf32[24] = salt_pos;
4759 device_param->kernel_params_buf32[27] = 1;
4760 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4761 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4762 device_param->kernel_params_buf32[30] = 0;
4763 device_param->kernel_params_buf32[31] = 1;
4764
4765 char *dictfile_old = data.dictfile;
4766
4767 const char *weak_hash_check = "weak-hash-check";
4768
4769 data.dictfile = (char *) weak_hash_check;
4770
4771 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4772
4773 data.kernel_rules_buf[0].cmds[0] = 0;
4774
4775 /**
4776 * run the kernel
4777 */
4778
4779 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4780 {
4781 run_kernel (KERN_RUN_1, device_param, 1, false);
4782 }
4783 else
4784 {
4785 run_kernel (KERN_RUN_1, device_param, 1, false);
4786
4787 uint loop_step = device_param->kernel_loops;
4788
4789 const uint iter = salt_buf->salt_iter;
4790
4791 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4792 {
4793 // autotune start
4794
4795 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL) loop_step = device_param->kernel_loops;
4796
4797 // autotune stop
4798
4799 uint loop_left = iter - loop_pos;
4800
4801 loop_left = MIN (loop_left, loop_step);
4802
4803 device_param->kernel_params_buf32[25] = loop_pos;
4804 device_param->kernel_params_buf32[26] = loop_left;
4805
4806 run_kernel (KERN_RUN_2, device_param, 1, false);
4807 }
4808
4809 run_kernel (KERN_RUN_3, device_param, 1, false);
4810 }
4811
4812 /**
4813 * result
4814 */
4815
4816 check_cracked (device_param, salt_pos);
4817
4818 /**
4819 * cleanup
4820 */
4821
4822 device_param->kernel_params_buf32[24] = 0;
4823 device_param->kernel_params_buf32[25] = 0;
4824 device_param->kernel_params_buf32[26] = 0;
4825 device_param->kernel_params_buf32[27] = 0;
4826 device_param->kernel_params_buf32[28] = 0;
4827 device_param->kernel_params_buf32[29] = 0;
4828 device_param->kernel_params_buf32[30] = 0;
4829 device_param->kernel_params_buf32[31] = 0;
4830
4831 data.dictfile = dictfile_old;
4832
4833 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4834 }
4835
4836 // hlfmt hashcat
4837
4838 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4839 {
4840 if (data.username == 0)
4841 {
4842 *hashbuf_pos = line_buf;
4843 *hashbuf_len = line_len;
4844 }
4845 else
4846 {
4847 char *pos = line_buf;
4848 int len = line_len;
4849
4850 for (int i = 0; i < line_len; i++, pos++, len--)
4851 {
4852 if (line_buf[i] == data.separator)
4853 {
4854 pos++;
4855
4856 len--;
4857
4858 break;
4859 }
4860 }
4861
4862 *hashbuf_pos = pos;
4863 *hashbuf_len = len;
4864 }
4865 }
4866
4867 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4868 {
4869 char *pos = NULL;
4870 int len = 0;
4871
4872 int sep_cnt = 0;
4873
4874 for (int i = 0; i < line_len; i++)
4875 {
4876 if (line_buf[i] == data.separator)
4877 {
4878 sep_cnt++;
4879
4880 continue;
4881 }
4882
4883 if (sep_cnt == 0)
4884 {
4885 if (pos == NULL) pos = line_buf + i;
4886
4887 len++;
4888 }
4889 }
4890
4891 *userbuf_pos = pos;
4892 *userbuf_len = len;
4893 }
4894
4895 // hlfmt pwdump
4896
4897 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4898 {
4899 int sep_cnt = 0;
4900
4901 int sep2_len = 0;
4902 int sep3_len = 0;
4903
4904 for (int i = 0; i < line_len; i++)
4905 {
4906 if (line_buf[i] == ':')
4907 {
4908 sep_cnt++;
4909
4910 continue;
4911 }
4912
4913 if (sep_cnt == 2) sep2_len++;
4914 if (sep_cnt == 3) sep3_len++;
4915 }
4916
4917 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4918
4919 return 0;
4920 }
4921
4922 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4923 {
4924 char *pos = NULL;
4925 int len = 0;
4926
4927 int sep_cnt = 0;
4928
4929 for (int i = 0; i < line_len; i++)
4930 {
4931 if (line_buf[i] == ':')
4932 {
4933 sep_cnt++;
4934
4935 continue;
4936 }
4937
4938 if (data.hash_mode == 1000)
4939 {
4940 if (sep_cnt == 3)
4941 {
4942 if (pos == NULL) pos = line_buf + i;
4943
4944 len++;
4945 }
4946 }
4947 else if (data.hash_mode == 3000)
4948 {
4949 if (sep_cnt == 2)
4950 {
4951 if (pos == NULL) pos = line_buf + i;
4952
4953 len++;
4954 }
4955 }
4956 }
4957
4958 *hashbuf_pos = pos;
4959 *hashbuf_len = len;
4960 }
4961
4962 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4963 {
4964 char *pos = NULL;
4965 int len = 0;
4966
4967 int sep_cnt = 0;
4968
4969 for (int i = 0; i < line_len; i++)
4970 {
4971 if (line_buf[i] == ':')
4972 {
4973 sep_cnt++;
4974
4975 continue;
4976 }
4977
4978 if (sep_cnt == 0)
4979 {
4980 if (pos == NULL) pos = line_buf + i;
4981
4982 len++;
4983 }
4984 }
4985
4986 *userbuf_pos = pos;
4987 *userbuf_len = len;
4988 }
4989
4990 // hlfmt passwd
4991
4992 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4993 {
4994 int sep_cnt = 0;
4995
4996 char sep5_first = 0;
4997 char sep6_first = 0;
4998
4999 for (int i = 0; i < line_len; i++)
5000 {
5001 if (line_buf[i] == ':')
5002 {
5003 sep_cnt++;
5004
5005 continue;
5006 }
5007
5008 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5009 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5010 }
5011
5012 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5013
5014 return 0;
5015 }
5016
5017 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5018 {
5019 char *pos = NULL;
5020 int len = 0;
5021
5022 int sep_cnt = 0;
5023
5024 for (int i = 0; i < line_len; i++)
5025 {
5026 if (line_buf[i] == ':')
5027 {
5028 sep_cnt++;
5029
5030 continue;
5031 }
5032
5033 if (sep_cnt == 1)
5034 {
5035 if (pos == NULL) pos = line_buf + i;
5036
5037 len++;
5038 }
5039 }
5040
5041 *hashbuf_pos = pos;
5042 *hashbuf_len = len;
5043 }
5044
5045 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5046 {
5047 char *pos = NULL;
5048 int len = 0;
5049
5050 int sep_cnt = 0;
5051
5052 for (int i = 0; i < line_len; i++)
5053 {
5054 if (line_buf[i] == ':')
5055 {
5056 sep_cnt++;
5057
5058 continue;
5059 }
5060
5061 if (sep_cnt == 0)
5062 {
5063 if (pos == NULL) pos = line_buf + i;
5064
5065 len++;
5066 }
5067 }
5068
5069 *userbuf_pos = pos;
5070 *userbuf_len = len;
5071 }
5072
5073 // hlfmt shadow
5074
5075 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5076 {
5077 int sep_cnt = 0;
5078
5079 for (int i = 0; i < line_len; i++)
5080 {
5081 if (line_buf[i] == ':') sep_cnt++;
5082 }
5083
5084 if (sep_cnt == 8) return 1;
5085
5086 return 0;
5087 }
5088
5089 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5090 {
5091 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5092 }
5093
5094 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5095 {
5096 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5097 }
5098
5099 // hlfmt main
5100
5101 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5102 {
5103 switch (hashfile_format)
5104 {
5105 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5106 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5107 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5108 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5109 }
5110 }
5111
5112 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5113 {
5114 switch (hashfile_format)
5115 {
5116 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5117 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5118 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5119 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5120 }
5121 }
5122
5123 static uint hlfmt_detect (FILE *fp, uint max_check)
5124 {
5125 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5126
5127 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5128 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5129
5130 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5131
5132 uint num_check = 0;
5133
5134 while (!feof (fp))
5135 {
5136 char line_buf[BUFSIZ] = { 0 };
5137
5138 int line_len = fgetl (fp, line_buf);
5139
5140 if (line_len == 0) continue;
5141
5142 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5143 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5144 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5145
5146 if (num_check == max_check) break;
5147
5148 num_check++;
5149 }
5150
5151 uint hashlist_format = HLFMT_HASHCAT;
5152
5153 for (int i = 1; i < HLFMTS_CNT; i++)
5154 {
5155 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5156
5157 hashlist_format = i;
5158 }
5159
5160 free (formats_cnt);
5161
5162 return hashlist_format;
5163 }
5164
5165 /**
5166 * some further helper function
5167 */
5168
5169 // wrapper around mymalloc for ADL
5170
5171 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5172 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5173 {
5174 return mymalloc (iSize);
5175 }
5176 #endif
5177
5178 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)
5179 {
5180 u64 collisions = 0;
5181
5182 const uint dgst_pos0 = data.dgst_pos0;
5183 const uint dgst_pos1 = data.dgst_pos1;
5184 const uint dgst_pos2 = data.dgst_pos2;
5185 const uint dgst_pos3 = data.dgst_pos3;
5186
5187 memset (bitmap_a, 0, bitmap_size);
5188 memset (bitmap_b, 0, bitmap_size);
5189 memset (bitmap_c, 0, bitmap_size);
5190 memset (bitmap_d, 0, bitmap_size);
5191
5192 for (uint i = 0; i < digests_cnt; i++)
5193 {
5194 uint *digest_ptr = (uint *) digests_buf_ptr;
5195
5196 digests_buf_ptr += dgst_size;
5197
5198 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5199 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5200 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5201 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5202
5203 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5204 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5205 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5206 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5207
5208 if (bitmap_a[idx0] & val0) collisions++;
5209 if (bitmap_b[idx1] & val1) collisions++;
5210 if (bitmap_c[idx2] & val2) collisions++;
5211 if (bitmap_d[idx3] & val3) collisions++;
5212
5213 bitmap_a[idx0] |= val0;
5214 bitmap_b[idx1] |= val1;
5215 bitmap_c[idx2] |= val2;
5216 bitmap_d[idx3] |= val3;
5217
5218 if (collisions >= collisions_max) return 0x7fffffff;
5219 }
5220
5221 return collisions;
5222 }
5223
5224 /**
5225 * main
5226 */
5227
5228 int main (int argc, char **argv)
5229 {
5230 /**
5231 * To help users a bit
5232 */
5233
5234 char *compute = getenv ("COMPUTE");
5235
5236 if (compute)
5237 {
5238 static char display[100];
5239
5240 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5241
5242 putenv (display);
5243 }
5244 else
5245 {
5246 if (getenv ("DISPLAY") == NULL)
5247 putenv ((char *) "DISPLAY=:0");
5248 }
5249
5250 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5251 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5252
5253 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5254 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5255
5256 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5257 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5258
5259 /**
5260 * Real init
5261 */
5262
5263 memset (&data, 0, sizeof (hc_global_data_t));
5264
5265 time_t proc_start;
5266
5267 time (&proc_start);
5268
5269 data.proc_start = proc_start;
5270
5271 int myargc = argc;
5272 char **myargv = argv;
5273
5274 hc_thread_mutex_init (mux_dispatcher);
5275 hc_thread_mutex_init (mux_counter);
5276 hc_thread_mutex_init (mux_display);
5277 hc_thread_mutex_init (mux_adl);
5278
5279 /**
5280 * commandline parameters
5281 */
5282
5283 uint usage = USAGE;
5284 uint version = VERSION;
5285 uint quiet = QUIET;
5286 uint benchmark = BENCHMARK;
5287 uint show = SHOW;
5288 uint left = LEFT;
5289 uint username = USERNAME;
5290 uint remove = REMOVE;
5291 uint remove_timer = REMOVE_TIMER;
5292 u64 skip = SKIP;
5293 u64 limit = LIMIT;
5294 uint keyspace = KEYSPACE;
5295 uint potfile_disable = POTFILE_DISABLE;
5296 uint debug_mode = DEBUG_MODE;
5297 char *debug_file = NULL;
5298 char *induction_dir = NULL;
5299 char *outfile_check_dir = NULL;
5300 uint force = FORCE;
5301 uint runtime = RUNTIME;
5302 uint hash_mode = HASH_MODE;
5303 uint attack_mode = ATTACK_MODE;
5304 uint markov_disable = MARKOV_DISABLE;
5305 uint markov_classic = MARKOV_CLASSIC;
5306 uint markov_threshold = MARKOV_THRESHOLD;
5307 char *markov_hcstat = NULL;
5308 char *outfile = NULL;
5309 uint outfile_format = OUTFILE_FORMAT;
5310 uint outfile_autohex = OUTFILE_AUTOHEX;
5311 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5312 uint restore = RESTORE;
5313 uint restore_timer = RESTORE_TIMER;
5314 uint restore_disable = RESTORE_DISABLE;
5315 uint status = STATUS;
5316 uint status_timer = STATUS_TIMER;
5317 uint status_automat = STATUS_AUTOMAT;
5318 uint loopback = LOOPBACK;
5319 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5320 char *session = NULL;
5321 uint hex_charset = HEX_CHARSET;
5322 uint hex_salt = HEX_SALT;
5323 uint hex_wordlist = HEX_WORDLIST;
5324 uint rp_gen = RP_GEN;
5325 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5326 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5327 uint rp_gen_seed = RP_GEN_SEED;
5328 char *rule_buf_l = (char *) RULE_BUF_L;
5329 char *rule_buf_r = (char *) RULE_BUF_R;
5330 uint increment = INCREMENT;
5331 uint increment_min = INCREMENT_MIN;
5332 uint increment_max = INCREMENT_MAX;
5333 char *cpu_affinity = NULL;
5334 OCL_PTR *ocl = NULL;
5335 char *opencl_devices = NULL;
5336 char *opencl_platforms = NULL;
5337 char *opencl_device_types = NULL;
5338 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5339 char *truecrypt_keyfiles = NULL;
5340 uint workload_profile = WORKLOAD_PROFILE;
5341 uint kernel_accel = KERNEL_ACCEL;
5342 uint kernel_loops = KERNEL_LOOPS;
5343 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5344 #ifdef HAVE_HWMON
5345 uint gpu_temp_abort = GPU_TEMP_ABORT;
5346 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5347 #ifdef HAVE_ADL
5348 uint powertune_enable = POWERTUNE_ENABLE;
5349 #endif
5350 #endif
5351 uint logfile_disable = LOGFILE_DISABLE;
5352 uint segment_size = SEGMENT_SIZE;
5353 uint scrypt_tmto = SCRYPT_TMTO;
5354 char separator = SEPARATOR;
5355 uint bitmap_min = BITMAP_MIN;
5356 uint bitmap_max = BITMAP_MAX;
5357 char *custom_charset_1 = NULL;
5358 char *custom_charset_2 = NULL;
5359 char *custom_charset_3 = NULL;
5360 char *custom_charset_4 = NULL;
5361
5362 #define IDX_HELP 'h'
5363 #define IDX_VERSION 'V'
5364 #define IDX_VERSION_LOWER 'v'
5365 #define IDX_QUIET 0xff02
5366 #define IDX_SHOW 0xff03
5367 #define IDX_LEFT 0xff04
5368 #define IDX_REMOVE 0xff05
5369 #define IDX_REMOVE_TIMER 0xff37
5370 #define IDX_SKIP 's'
5371 #define IDX_LIMIT 'l'
5372 #define IDX_KEYSPACE 0xff35
5373 #define IDX_POTFILE_DISABLE 0xff06
5374 #define IDX_DEBUG_MODE 0xff43
5375 #define IDX_DEBUG_FILE 0xff44
5376 #define IDX_INDUCTION_DIR 0xff46
5377 #define IDX_OUTFILE_CHECK_DIR 0xff47
5378 #define IDX_USERNAME 0xff07
5379 #define IDX_FORCE 0xff08
5380 #define IDX_RUNTIME 0xff09
5381 #define IDX_BENCHMARK 'b'
5382 #define IDX_HASH_MODE 'm'
5383 #define IDX_ATTACK_MODE 'a'
5384 #define IDX_RP_FILE 'r'
5385 #define IDX_RP_GEN 'g'
5386 #define IDX_RP_GEN_FUNC_MIN 0xff10
5387 #define IDX_RP_GEN_FUNC_MAX 0xff11
5388 #define IDX_RP_GEN_SEED 0xff34
5389 #define IDX_RULE_BUF_L 'j'
5390 #define IDX_RULE_BUF_R 'k'
5391 #define IDX_INCREMENT 'i'
5392 #define IDX_INCREMENT_MIN 0xff12
5393 #define IDX_INCREMENT_MAX 0xff13
5394 #define IDX_OUTFILE 'o'
5395 #define IDX_OUTFILE_FORMAT 0xff14
5396 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5397 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5398 #define IDX_RESTORE 0xff15
5399 #define IDX_RESTORE_DISABLE 0xff27
5400 #define IDX_STATUS 0xff17
5401 #define IDX_STATUS_TIMER 0xff18
5402 #define IDX_STATUS_AUTOMAT 0xff50
5403 #define IDX_LOOPBACK 0xff38
5404 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5405 #define IDX_SESSION 0xff19
5406 #define IDX_HEX_CHARSET 0xff20
5407 #define IDX_HEX_SALT 0xff21
5408 #define IDX_HEX_WORDLIST 0xff40
5409 #define IDX_MARKOV_DISABLE 0xff22
5410 #define IDX_MARKOV_CLASSIC 0xff23
5411 #define IDX_MARKOV_THRESHOLD 't'
5412 #define IDX_MARKOV_HCSTAT 0xff24
5413 #define IDX_CPU_AFFINITY 0xff25
5414 #define IDX_OPENCL_DEVICES 'd'
5415 #define IDX_OPENCL_PLATFORMS 0xff72
5416 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5417 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5418 #define IDX_WORKLOAD_PROFILE 'w'
5419 #define IDX_KERNEL_ACCEL 'n'
5420 #define IDX_KERNEL_LOOPS 'u'
5421 #define IDX_GPU_TEMP_DISABLE 0xff29
5422 #define IDX_GPU_TEMP_ABORT 0xff30
5423 #define IDX_GPU_TEMP_RETAIN 0xff31
5424 #define IDX_POWERTUNE_ENABLE 0xff41
5425 #define IDX_LOGFILE_DISABLE 0xff51
5426 #define IDX_TRUECRYPT_KEYFILES 0xff52
5427 #define IDX_SCRYPT_TMTO 0xff61
5428 #define IDX_SEGMENT_SIZE 'c'
5429 #define IDX_SEPARATOR 'p'
5430 #define IDX_BITMAP_MIN 0xff70
5431 #define IDX_BITMAP_MAX 0xff71
5432 #define IDX_CUSTOM_CHARSET_1 '1'
5433 #define IDX_CUSTOM_CHARSET_2 '2'
5434 #define IDX_CUSTOM_CHARSET_3 '3'
5435 #define IDX_CUSTOM_CHARSET_4 '4'
5436
5437 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5438
5439 struct option long_options[] =
5440 {
5441 {"help", no_argument, 0, IDX_HELP},
5442 {"version", no_argument, 0, IDX_VERSION},
5443 {"quiet", no_argument, 0, IDX_QUIET},
5444 {"show", no_argument, 0, IDX_SHOW},
5445 {"left", no_argument, 0, IDX_LEFT},
5446 {"username", no_argument, 0, IDX_USERNAME},
5447 {"remove", no_argument, 0, IDX_REMOVE},
5448 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5449 {"skip", required_argument, 0, IDX_SKIP},
5450 {"limit", required_argument, 0, IDX_LIMIT},
5451 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5452 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5453 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5454 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5455 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5456 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5457 {"force", no_argument, 0, IDX_FORCE},
5458 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5459 {"restore", no_argument, 0, IDX_RESTORE},
5460 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5461 {"status", no_argument, 0, IDX_STATUS},
5462 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5463 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5464 {"loopback", no_argument, 0, IDX_LOOPBACK},
5465 {"weak-hash-threshold",
5466 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5467 {"session", required_argument, 0, IDX_SESSION},
5468 {"runtime", required_argument, 0, IDX_RUNTIME},
5469 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5470 {"generate-rules-func-min",
5471 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5472 {"generate-rules-func-max",
5473 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5474 {"generate-rules-seed",
5475 required_argument, 0, IDX_RP_GEN_SEED},
5476 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5477 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5478 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5479 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5480 {"rules-file", required_argument, 0, IDX_RP_FILE},
5481 {"outfile", required_argument, 0, IDX_OUTFILE},
5482 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5483 {"outfile-autohex-disable",
5484 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5485 {"outfile-check-timer",
5486 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5487 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5488 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5489 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5490 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5491 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5492 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5493 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5494 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5495 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5496 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5497 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5498 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5499 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5500 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5501 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5502 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5503 #ifdef HAVE_HWMON
5504 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5505 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5506 #ifdef HAVE_ADL
5507 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5508 #endif
5509 #endif // HAVE_HWMON
5510 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5511 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5512 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5513 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5514 // deprecated
5515 {"seperator", required_argument, 0, IDX_SEPARATOR},
5516 {"separator", required_argument, 0, IDX_SEPARATOR},
5517 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5518 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5519 {"increment", no_argument, 0, IDX_INCREMENT},
5520 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5521 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5522 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5523 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5524 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5525 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5526
5527 {0, 0, 0, 0}
5528 };
5529
5530 uint rp_files_cnt = 0;
5531
5532 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5533
5534 int option_index = 0;
5535 int c = -1;
5536
5537 optind = 1;
5538 optopt = 0;
5539
5540 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5541 {
5542 switch (c)
5543 {
5544 case IDX_HELP: usage = 1; break;
5545 case IDX_VERSION:
5546 case IDX_VERSION_LOWER: version = 1; break;
5547 case IDX_RESTORE: restore = 1; break;
5548 case IDX_SESSION: session = optarg; break;
5549 case IDX_SHOW: show = 1; break;
5550 case IDX_LEFT: left = 1; break;
5551 case '?': return (-1);
5552 }
5553 }
5554
5555 if (optopt != 0)
5556 {
5557 log_error ("ERROR: Invalid argument specified");
5558
5559 return (-1);
5560 }
5561
5562 /**
5563 * exit functions
5564 */
5565
5566 if (version)
5567 {
5568 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5569
5570 return (0);
5571 }
5572
5573 if (usage)
5574 {
5575 usage_big_print (PROGNAME);
5576
5577 return (0);
5578 }
5579
5580 /**
5581 * session needs to be set, always!
5582 */
5583
5584 if (session == NULL) session = (char *) PROGNAME;
5585
5586 /**
5587 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5588 */
5589
5590 char *exec_path = get_exec_path ();
5591
5592 #ifdef LINUX
5593
5594 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5595 char *resolved_exec_path = realpath (exec_path, NULL);
5596
5597 char *install_dir = get_install_dir (resolved_exec_path);
5598 char *profile_dir = NULL;
5599 char *session_dir = NULL;
5600 char *shared_dir = NULL;
5601
5602 if (strcmp (install_dir, resolved_install_folder) == 0)
5603 {
5604 struct passwd *pw = getpwuid (getuid ());
5605
5606 const char *homedir = pw->pw_dir;
5607
5608 profile_dir = get_profile_dir (homedir);
5609 session_dir = get_session_dir (profile_dir);
5610 shared_dir = strdup (SHARED_FOLDER);
5611
5612 mkdir (profile_dir, 0700);
5613 mkdir (session_dir, 0700);
5614 }
5615 else
5616 {
5617 profile_dir = install_dir;
5618 session_dir = install_dir;
5619 shared_dir = install_dir;
5620 }
5621
5622 myfree (resolved_install_folder);
5623 myfree (resolved_exec_path);
5624
5625 #else
5626
5627 char *install_dir = get_install_dir (exec_path);
5628 char *profile_dir = install_dir;
5629 char *session_dir = install_dir;
5630 char *shared_dir = install_dir;
5631
5632 #endif
5633
5634 data.install_dir = install_dir;
5635 data.profile_dir = profile_dir;
5636 data.session_dir = session_dir;
5637 data.shared_dir = shared_dir;
5638
5639 myfree (exec_path);
5640
5641 /**
5642 * kernel cache, we need to make sure folder exist
5643 */
5644
5645 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5646
5647 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5648
5649 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5650
5651 mkdir (kernels_folder, 0700);
5652
5653 myfree (kernels_folder);
5654
5655 /**
5656 * session
5657 */
5658
5659 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5660
5661 data.session = session;
5662
5663 char *eff_restore_file = (char *) mymalloc (session_size);
5664 char *new_restore_file = (char *) mymalloc (session_size);
5665
5666 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5667 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5668
5669 data.eff_restore_file = eff_restore_file;
5670 data.new_restore_file = new_restore_file;
5671
5672 if (((show == 1) || (left == 1)) && (restore == 1))
5673 {
5674 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5675 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5676
5677 return (-1);
5678 }
5679
5680 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5681 if ((show == 1) || (left == 1))
5682 {
5683 restore_disable = 1;
5684
5685 restore = 0;
5686 }
5687
5688 data.restore_disable = restore_disable;
5689
5690 restore_data_t *rd = init_restore (argc, argv);
5691
5692 data.rd = rd;
5693
5694 /**
5695 * restore file
5696 */
5697
5698 if (restore == 1)
5699 {
5700 read_restore (eff_restore_file, rd);
5701
5702 if (rd->version_bin < RESTORE_MIN)
5703 {
5704 log_error ("ERROR: Incompatible restore-file version");
5705
5706 return (-1);
5707 }
5708
5709 myargc = rd->argc;
5710 myargv = rd->argv;
5711
5712 #ifdef _POSIX
5713 rd->pid = getpid ();
5714 #elif _WIN
5715 rd->pid = GetCurrentProcessId ();
5716 #endif
5717 }
5718
5719 uint hash_mode_chgd = 0;
5720 uint runtime_chgd = 0;
5721 uint kernel_loops_chgd = 0;
5722 uint kernel_accel_chgd = 0;
5723 uint attack_mode_chgd = 0;
5724 uint outfile_format_chgd = 0;
5725 uint rp_gen_seed_chgd = 0;
5726 uint remove_timer_chgd = 0;
5727 uint increment_min_chgd = 0;
5728 uint increment_max_chgd = 0;
5729 uint workload_profile_chgd = 0;
5730
5731 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5732 uint gpu_temp_retain_chgd = 0;
5733 uint gpu_temp_abort_chgd = 0;
5734 #endif
5735
5736 optind = 1;
5737 optopt = 0;
5738 option_index = 0;
5739
5740 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5741 {
5742 switch (c)
5743 {
5744 //case IDX_HELP: usage = 1; break;
5745 //case IDX_VERSION: version = 1; break;
5746 //case IDX_RESTORE: restore = 1; break;
5747 case IDX_QUIET: quiet = 1; break;
5748 //case IDX_SHOW: show = 1; break;
5749 case IDX_SHOW: break;
5750 //case IDX_LEFT: left = 1; break;
5751 case IDX_LEFT: break;
5752 case IDX_USERNAME: username = 1; break;
5753 case IDX_REMOVE: remove = 1; break;
5754 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5755 remove_timer_chgd = 1; break;
5756 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5757 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5758 case IDX_DEBUG_FILE: debug_file = optarg; break;
5759 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5760 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5761 case IDX_FORCE: force = 1; break;
5762 case IDX_SKIP: skip = atoll (optarg); break;
5763 case IDX_LIMIT: limit = atoll (optarg); break;
5764 case IDX_KEYSPACE: keyspace = 1; break;
5765 case IDX_BENCHMARK: benchmark = 1; break;
5766 case IDX_RESTORE: break;
5767 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5768 case IDX_STATUS: status = 1; break;
5769 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5770 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5771 case IDX_LOOPBACK: loopback = 1; break;
5772 case IDX_WEAK_HASH_THRESHOLD:
5773 weak_hash_threshold = atoi (optarg); break;
5774 //case IDX_SESSION: session = optarg; break;
5775 case IDX_SESSION: break;
5776 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5777 hash_mode_chgd = 1; break;
5778 case IDX_RUNTIME: runtime = atoi (optarg);
5779 runtime_chgd = 1; break;
5780 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5781 attack_mode_chgd = 1; break;
5782 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5783 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5784 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5785 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5786 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5787 rp_gen_seed_chgd = 1; break;
5788 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5789 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5790 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5791 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5792 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5793 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5794 case IDX_OUTFILE: outfile = optarg; break;
5795 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5796 outfile_format_chgd = 1; break;
5797 case IDX_OUTFILE_AUTOHEX_DISABLE:
5798 outfile_autohex = 0; break;
5799 case IDX_OUTFILE_CHECK_TIMER:
5800 outfile_check_timer = atoi (optarg); break;
5801 case IDX_HEX_CHARSET: hex_charset = 1; break;
5802 case IDX_HEX_SALT: hex_salt = 1; break;
5803 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5804 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5805 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5806 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5807 case IDX_OPENCL_DEVICE_TYPES:
5808 opencl_device_types = optarg; break;
5809 case IDX_OPENCL_VECTOR_WIDTH:
5810 opencl_vector_width = atoi (optarg); break;
5811 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5812 workload_profile_chgd = 1; break;
5813 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5814 kernel_accel_chgd = 1; break;
5815 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5816 kernel_loops_chgd = 1; break;
5817 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5818 #ifdef HAVE_HWMON
5819 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5820 #ifdef HAVE_ADL
5821 gpu_temp_abort_chgd = 1;
5822 #endif
5823 break;
5824 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5825 #ifdef HAVE_ADL
5826 gpu_temp_retain_chgd = 1;
5827 #endif
5828 break;
5829 #ifdef HAVE_ADL
5830 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5831 #endif
5832 #endif // HAVE_HWMON
5833 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5834 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5835 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5836 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5837 case IDX_SEPARATOR: separator = optarg[0]; break;
5838 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5839 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5840 case IDX_INCREMENT: increment = 1; break;
5841 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5842 increment_min_chgd = 1; break;
5843 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5844 increment_max_chgd = 1; break;
5845 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5846 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5847 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5848 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5849
5850 default:
5851 log_error ("ERROR: Invalid argument specified");
5852 return (-1);
5853 }
5854 }
5855
5856 if (optopt != 0)
5857 {
5858 log_error ("ERROR: Invalid argument specified");
5859
5860 return (-1);
5861 }
5862
5863 /**
5864 * Inform user things getting started,
5865 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5866 * - we do not need to check algorithm_pos
5867 */
5868
5869 if (quiet == 0)
5870 {
5871 if (benchmark == 1)
5872 {
5873 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5874
5875 log_info ("");
5876 }
5877 else if (restore == 1)
5878 {
5879 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5880
5881 log_info ("");
5882 }
5883 else
5884 {
5885 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5886
5887 log_info ("");
5888 }
5889 }
5890
5891 /**
5892 * sanity check
5893 */
5894
5895 if (attack_mode > 7)
5896 {
5897 log_error ("ERROR: Invalid attack-mode specified");
5898
5899 return (-1);
5900 }
5901
5902 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5903 {
5904 log_error ("ERROR: Invalid runtime specified");
5905
5906 return (-1);
5907 }
5908
5909 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5910 {
5911 log_error ("ERROR: Invalid hash-type specified");
5912
5913 return (-1);
5914 }
5915
5916 // renamed hash modes
5917
5918 if (hash_mode_chgd)
5919 {
5920 int n = -1;
5921
5922 switch (hash_mode)
5923 {
5924 case 123: n = 124;
5925 break;
5926 }
5927
5928 if (n >= 0)
5929 {
5930 log_error ("Old -m specified, use -m %d instead", n);
5931
5932 return (-1);
5933 }
5934 }
5935
5936 if (username == 1)
5937 {
5938 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5939 {
5940 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5941
5942 return (-1);
5943 }
5944 }
5945
5946 if (outfile_format > 16)
5947 {
5948 log_error ("ERROR: Invalid outfile-format specified");
5949
5950 return (-1);
5951 }
5952
5953 if (left == 1)
5954 {
5955 if (outfile_format_chgd == 1)
5956 {
5957 if (outfile_format > 1)
5958 {
5959 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5960
5961 return (-1);
5962 }
5963 }
5964 else
5965 {
5966 outfile_format = OUTFILE_FMT_HASH;
5967 }
5968 }
5969
5970 if (show == 1)
5971 {
5972 if (outfile_format_chgd == 1)
5973 {
5974 if ((outfile_format > 7) && (outfile_format < 16))
5975 {
5976 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5977
5978 return (-1);
5979 }
5980 }
5981 }
5982
5983 if (increment_min < INCREMENT_MIN)
5984 {
5985 log_error ("ERROR: Invalid increment-min specified");
5986
5987 return (-1);
5988 }
5989
5990 if (increment_max > INCREMENT_MAX)
5991 {
5992 log_error ("ERROR: Invalid increment-max specified");
5993
5994 return (-1);
5995 }
5996
5997 if (increment_min > increment_max)
5998 {
5999 log_error ("ERROR: Invalid increment-min specified");
6000
6001 return (-1);
6002 }
6003
6004 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6005 {
6006 log_error ("ERROR: increment is not allowed in attack-mode 0");
6007
6008 return (-1);
6009 }
6010
6011 if ((increment == 0) && (increment_min_chgd == 1))
6012 {
6013 log_error ("ERROR: increment-min is only supported together with increment switch");
6014
6015 return (-1);
6016 }
6017
6018 if ((increment == 0) && (increment_max_chgd == 1))
6019 {
6020 log_error ("ERROR: increment-max is only supported together with increment switch");
6021
6022 return (-1);
6023 }
6024
6025 if (rp_files_cnt && rp_gen)
6026 {
6027 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6028
6029 return (-1);
6030 }
6031
6032 if (rp_files_cnt || rp_gen)
6033 {
6034 if (attack_mode != ATTACK_MODE_STRAIGHT)
6035 {
6036 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6037
6038 return (-1);
6039 }
6040 }
6041
6042 if (rp_gen_func_min > rp_gen_func_max)
6043 {
6044 log_error ("ERROR: Invalid rp-gen-func-min specified");
6045
6046 return (-1);
6047 }
6048
6049 if (kernel_accel_chgd == 1)
6050 {
6051 if (kernel_accel < 1)
6052 {
6053 log_error ("ERROR: Invalid kernel-accel specified");
6054
6055 return (-1);
6056 }
6057
6058 if (kernel_accel > 1024)
6059 {
6060 log_error ("ERROR: Invalid kernel-accel specified");
6061
6062 return (-1);
6063 }
6064 }
6065
6066 if (kernel_loops_chgd == 1)
6067 {
6068 if (kernel_loops < 1)
6069 {
6070 log_error ("ERROR: Invalid kernel-loops specified");
6071
6072 return (-1);
6073 }
6074
6075 if (kernel_loops > 1024)
6076 {
6077 log_error ("ERROR: Invalid kernel-loops specified");
6078
6079 return (-1);
6080 }
6081 }
6082
6083 if ((workload_profile < 1) || (workload_profile > 3))
6084 {
6085 log_error ("ERROR: workload-profile %i not available", workload_profile);
6086
6087 return (-1);
6088 }
6089
6090 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6091 {
6092 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6093
6094 return (-1);
6095 }
6096
6097 if (show == 1 || left == 1)
6098 {
6099 attack_mode = ATTACK_MODE_NONE;
6100
6101 if (remove == 1)
6102 {
6103 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6104
6105 return (-1);
6106 }
6107
6108 if (potfile_disable == 1)
6109 {
6110 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6111
6112 return (-1);
6113 }
6114 }
6115
6116 uint attack_kern = ATTACK_KERN_NONE;
6117
6118 switch (attack_mode)
6119 {
6120 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6121 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6122 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6123 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6124 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6125 }
6126
6127 if (benchmark == 0)
6128 {
6129 if (keyspace == 1)
6130 {
6131 int num_additional_params = 1;
6132
6133 if (attack_kern == ATTACK_KERN_COMBI)
6134 {
6135 num_additional_params = 2;
6136 }
6137
6138 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6139
6140 if (keyspace_wordlist_specified == 0) optind--;
6141 }
6142
6143 if (attack_kern == ATTACK_KERN_NONE)
6144 {
6145 if ((optind + 1) != myargc)
6146 {
6147 usage_mini_print (myargv[0]);
6148
6149 return (-1);
6150 }
6151 }
6152 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6153 {
6154 if ((optind + 1) > myargc)
6155 {
6156 usage_mini_print (myargv[0]);
6157
6158 return (-1);
6159 }
6160 }
6161 else if (attack_kern == ATTACK_KERN_COMBI)
6162 {
6163 if ((optind + 3) != myargc)
6164 {
6165 usage_mini_print (myargv[0]);
6166
6167 return (-1);
6168 }
6169 }
6170 else if (attack_kern == ATTACK_KERN_BF)
6171 {
6172 if ((optind + 1) > myargc)
6173 {
6174 usage_mini_print (myargv[0]);
6175
6176 return (-1);
6177 }
6178 }
6179 else
6180 {
6181 usage_mini_print (myargv[0]);
6182
6183 return (-1);
6184 }
6185 }
6186 else
6187 {
6188 if (myargv[optind] != 0)
6189 {
6190 log_error ("ERROR: Invalid argument for benchmark mode specified");
6191
6192 return (-1);
6193 }
6194
6195 if (attack_mode_chgd == 1)
6196 {
6197 if (attack_mode != ATTACK_MODE_BF)
6198 {
6199 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6200
6201 return (-1);
6202 }
6203 }
6204 }
6205
6206 if (skip != 0 && limit != 0)
6207 {
6208 limit += skip;
6209 }
6210
6211 if (keyspace == 1)
6212 {
6213 if (show == 1)
6214 {
6215 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6216
6217 return (-1);
6218 }
6219 else if (left == 1)
6220 {
6221 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6222
6223 return (-1);
6224 }
6225
6226 potfile_disable = 1;
6227
6228 restore_disable = 1;
6229
6230 restore = 0;
6231
6232 weak_hash_threshold = 0;
6233
6234 quiet = 1;
6235 }
6236
6237 if (remove_timer_chgd == 1)
6238 {
6239 if (remove == 0)
6240 {
6241 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6242
6243 return (-1);
6244 }
6245
6246 if (remove_timer < 1)
6247 {
6248 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6249
6250 return (-1);
6251 }
6252 }
6253
6254 if (loopback == 1)
6255 {
6256 if (attack_mode == ATTACK_MODE_BF)
6257 {
6258 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6259
6260 return (-1);
6261 }
6262 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6263 {
6264 if ((rp_files_cnt == 0) && (rp_gen == 0))
6265 {
6266 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6267
6268 return (-1);
6269 }
6270 }
6271 }
6272
6273 if (debug_mode > 0)
6274 {
6275 if (attack_mode != ATTACK_MODE_STRAIGHT)
6276 {
6277 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6278
6279 return (-1);
6280 }
6281
6282 if ((rp_files_cnt == 0) && (rp_gen == 0))
6283 {
6284 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6285
6286 return (-1);
6287 }
6288 }
6289
6290 if (debug_mode > 4)
6291 {
6292 log_error ("ERROR: Invalid debug-mode specified");
6293
6294 return (-1);
6295 }
6296
6297 if (debug_file != NULL)
6298 {
6299 if (debug_mode < 1)
6300 {
6301 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6302
6303 return (-1);
6304 }
6305 }
6306
6307 if (induction_dir != NULL)
6308 {
6309 if (attack_mode == ATTACK_MODE_BF)
6310 {
6311 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6312
6313 return (-1);
6314 }
6315 }
6316
6317 if (attack_mode != ATTACK_MODE_STRAIGHT)
6318 {
6319 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6320 {
6321 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6322
6323 return (-1);
6324 }
6325
6326 weak_hash_threshold = 0;
6327 }
6328
6329 /**
6330 * induction directory
6331 */
6332
6333 char *induction_directory = NULL;
6334
6335 if (attack_mode != ATTACK_MODE_BF)
6336 {
6337 if (induction_dir == NULL)
6338 {
6339 induction_directory = (char *) mymalloc (session_size);
6340
6341 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6342
6343 // create induction folder if it does not already exist
6344
6345 if (keyspace == 0)
6346 {
6347 if (rmdir (induction_directory) == -1)
6348 {
6349 if (errno == ENOENT)
6350 {
6351 // good, we can ignore
6352 }
6353 else if (errno == ENOTEMPTY)
6354 {
6355 char *induction_directory_mv = (char *) mymalloc (session_size);
6356
6357 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6358
6359 if (rename (induction_directory, induction_directory_mv) != 0)
6360 {
6361 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6362
6363 return (-1);
6364 }
6365 }
6366 else
6367 {
6368 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6369
6370 return (-1);
6371 }
6372 }
6373
6374 if (mkdir (induction_directory, 0700) == -1)
6375 {
6376 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6377
6378 return (-1);
6379 }
6380 }
6381 }
6382 else
6383 {
6384 induction_directory = induction_dir;
6385 }
6386 }
6387
6388 data.induction_directory = induction_directory;
6389
6390 /**
6391 * loopback
6392 */
6393
6394 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6395
6396 char *loopback_file = (char *) mymalloc (loopback_size);
6397
6398 /**
6399 * tuning db
6400 */
6401
6402 char tuning_db_file[256] = { 0 };
6403
6404 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6405
6406 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6407
6408 /**
6409 * outfile-check directory
6410 */
6411
6412 char *outfile_check_directory = NULL;
6413
6414 if (outfile_check_dir == NULL)
6415 {
6416 outfile_check_directory = (char *) mymalloc (session_size);
6417
6418 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6419 }
6420 else
6421 {
6422 outfile_check_directory = outfile_check_dir;
6423 }
6424
6425 data.outfile_check_directory = outfile_check_directory;
6426
6427 if (keyspace == 0)
6428 {
6429 struct stat outfile_check_stat;
6430
6431 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6432 {
6433 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6434
6435 if (is_dir == 0)
6436 {
6437 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6438
6439 return (-1);
6440 }
6441 }
6442 else if (outfile_check_dir == NULL)
6443 {
6444 if (mkdir (outfile_check_directory, 0700) == -1)
6445 {
6446 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6447
6448 return (-1);
6449 }
6450 }
6451 }
6452
6453 /**
6454 * special other stuff
6455 */
6456
6457 if (hash_mode == 9710)
6458 {
6459 outfile_format = 5;
6460 outfile_format_chgd = 1;
6461 }
6462
6463 if (hash_mode == 9810)
6464 {
6465 outfile_format = 5;
6466 outfile_format_chgd = 1;
6467 }
6468
6469 if (hash_mode == 10410)
6470 {
6471 outfile_format = 5;
6472 outfile_format_chgd = 1;
6473 }
6474
6475 /**
6476 * store stuff
6477 */
6478
6479 data.hash_mode = hash_mode;
6480 data.restore = restore;
6481 data.restore_timer = restore_timer;
6482 data.restore_disable = restore_disable;
6483 data.status = status;
6484 data.status_timer = status_timer;
6485 data.status_automat = status_automat;
6486 data.loopback = loopback;
6487 data.runtime = runtime;
6488 data.remove = remove;
6489 data.remove_timer = remove_timer;
6490 data.debug_mode = debug_mode;
6491 data.debug_file = debug_file;
6492 data.username = username;
6493 data.quiet = quiet;
6494 data.outfile = outfile;
6495 data.outfile_format = outfile_format;
6496 data.outfile_autohex = outfile_autohex;
6497 data.hex_charset = hex_charset;
6498 data.hex_salt = hex_salt;
6499 data.hex_wordlist = hex_wordlist;
6500 data.separator = separator;
6501 data.rp_files = rp_files;
6502 data.rp_files_cnt = rp_files_cnt;
6503 data.rp_gen = rp_gen;
6504 data.rp_gen_seed = rp_gen_seed;
6505 data.force = force;
6506 data.benchmark = benchmark;
6507 data.skip = skip;
6508 data.limit = limit;
6509 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6510 data.powertune_enable = powertune_enable;
6511 #endif
6512 data.logfile_disable = logfile_disable;
6513 data.truecrypt_keyfiles = truecrypt_keyfiles;
6514 data.scrypt_tmto = scrypt_tmto;
6515 data.workload_profile = workload_profile;
6516
6517 /**
6518 * cpu affinity
6519 */
6520
6521 if (cpu_affinity)
6522 {
6523 set_cpu_affinity (cpu_affinity);
6524 }
6525
6526 if (rp_gen_seed_chgd == 0)
6527 {
6528 srand (proc_start);
6529 }
6530 else
6531 {
6532 srand (rp_gen_seed);
6533 }
6534
6535 /**
6536 * logfile init
6537 */
6538
6539 if (logfile_disable == 0)
6540 {
6541 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6542
6543 char *logfile = (char *) mymalloc (logfile_size);
6544
6545 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6546
6547 data.logfile = logfile;
6548
6549 char *topid = logfile_generate_topid ();
6550
6551 data.topid = topid;
6552 }
6553
6554 // logfile_append() checks for logfile_disable internally to make it easier from here
6555
6556 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6557 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6558 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6559 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6560 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6561 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6562 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6563 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6564 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6565 #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));
6566
6567 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6568 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6569 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6570 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6571 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6572 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6573 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6574 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6575
6576 logfile_top_msg ("START");
6577
6578 logfile_top_uint (attack_mode);
6579 logfile_top_uint (attack_kern);
6580 logfile_top_uint (benchmark);
6581 logfile_top_uint (bitmap_min);
6582 logfile_top_uint (bitmap_max);
6583 logfile_top_uint (debug_mode);
6584 logfile_top_uint (force);
6585 logfile_top_uint (kernel_accel);
6586 logfile_top_uint (kernel_loops);
6587 logfile_top_uint (gpu_temp_disable);
6588 #ifdef HAVE_HWMON
6589 logfile_top_uint (gpu_temp_abort);
6590 logfile_top_uint (gpu_temp_retain);
6591 #endif
6592 logfile_top_uint (hash_mode);
6593 logfile_top_uint (hex_charset);
6594 logfile_top_uint (hex_salt);
6595 logfile_top_uint (hex_wordlist);
6596 logfile_top_uint (increment);
6597 logfile_top_uint (increment_max);
6598 logfile_top_uint (increment_min);
6599 logfile_top_uint (keyspace);
6600 logfile_top_uint (left);
6601 logfile_top_uint (logfile_disable);
6602 logfile_top_uint (loopback);
6603 logfile_top_uint (markov_classic);
6604 logfile_top_uint (markov_disable);
6605 logfile_top_uint (markov_threshold);
6606 logfile_top_uint (outfile_autohex);
6607 logfile_top_uint (outfile_check_timer);
6608 logfile_top_uint (outfile_format);
6609 logfile_top_uint (potfile_disable);
6610 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6611 logfile_top_uint (powertune_enable);
6612 #endif
6613 logfile_top_uint (scrypt_tmto);
6614 logfile_top_uint (quiet);
6615 logfile_top_uint (remove);
6616 logfile_top_uint (remove_timer);
6617 logfile_top_uint (restore);
6618 logfile_top_uint (restore_disable);
6619 logfile_top_uint (restore_timer);
6620 logfile_top_uint (rp_gen);
6621 logfile_top_uint (rp_gen_func_max);
6622 logfile_top_uint (rp_gen_func_min);
6623 logfile_top_uint (rp_gen_seed);
6624 logfile_top_uint (runtime);
6625 logfile_top_uint (segment_size);
6626 logfile_top_uint (show);
6627 logfile_top_uint (status);
6628 logfile_top_uint (status_automat);
6629 logfile_top_uint (status_timer);
6630 logfile_top_uint (usage);
6631 logfile_top_uint (username);
6632 logfile_top_uint (version);
6633 logfile_top_uint (weak_hash_threshold);
6634 logfile_top_uint (workload_profile);
6635 logfile_top_uint64 (limit);
6636 logfile_top_uint64 (skip);
6637 logfile_top_char (separator);
6638 logfile_top_string (cpu_affinity);
6639 logfile_top_string (custom_charset_1);
6640 logfile_top_string (custom_charset_2);
6641 logfile_top_string (custom_charset_3);
6642 logfile_top_string (custom_charset_4);
6643 logfile_top_string (debug_file);
6644 logfile_top_string (opencl_devices);
6645 logfile_top_string (opencl_platforms);
6646 logfile_top_string (opencl_device_types);
6647 logfile_top_uint (opencl_vector_width);
6648 logfile_top_string (induction_dir);
6649 logfile_top_string (markov_hcstat);
6650 logfile_top_string (outfile);
6651 logfile_top_string (outfile_check_dir);
6652 logfile_top_string (rule_buf_l);
6653 logfile_top_string (rule_buf_r);
6654 logfile_top_string (session);
6655 logfile_top_string (truecrypt_keyfiles);
6656
6657 /**
6658 * Init OpenCL library loader
6659 */
6660
6661 if (keyspace == 0)
6662 {
6663 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6664
6665 ocl_init (ocl);
6666
6667 data.ocl = ocl;
6668 }
6669
6670 /**
6671 * OpenCL platform selection
6672 */
6673
6674 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6675
6676 /**
6677 * OpenCL device selection
6678 */
6679
6680 u32 devices_filter = setup_devices_filter (opencl_devices);
6681
6682 /**
6683 * OpenCL device type selection
6684 */
6685
6686 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6687
6688 /**
6689 * benchmark
6690 */
6691
6692 if (benchmark == 1)
6693 {
6694 /**
6695 * disable useless stuff for benchmark
6696 */
6697
6698 status_timer = 0;
6699 restore_timer = 0;
6700 restore_disable = 1;
6701 potfile_disable = 1;
6702 weak_hash_threshold = 0;
6703
6704 data.status_timer = status_timer;
6705 data.restore_timer = restore_timer;
6706 data.restore_disable = restore_disable;
6707
6708 /**
6709 * force attack mode to be bruteforce
6710 */
6711
6712 attack_mode = ATTACK_MODE_BF;
6713 attack_kern = ATTACK_KERN_BF;
6714
6715 if (workload_profile_chgd == 0)
6716 {
6717 workload_profile = 3;
6718
6719 data.workload_profile = workload_profile;
6720 }
6721
6722 if (runtime_chgd == 0)
6723 {
6724 runtime = 17;
6725
6726 data.runtime = runtime;
6727 }
6728 }
6729
6730 /**
6731 * config
6732 */
6733
6734 uint hash_type = 0;
6735 uint salt_type = 0;
6736 uint attack_exec = 0;
6737 uint opts_type = 0;
6738 uint kern_type = 0;
6739 uint dgst_size = 0;
6740 uint esalt_size = 0;
6741 uint opti_type = 0;
6742 uint dgst_pos0 = -1;
6743 uint dgst_pos1 = -1;
6744 uint dgst_pos2 = -1;
6745 uint dgst_pos3 = -1;
6746
6747 int (*parse_func) (char *, uint, hash_t *);
6748 int (*sort_by_digest) (const void *, const void *);
6749
6750 uint algorithm_pos = 0;
6751 uint algorithm_max = 1;
6752
6753 uint *algorithms = default_benchmark_algorithms;
6754
6755 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6756
6757 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6758 {
6759 /*
6760 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6761 * the following algos are skipped entirely
6762 */
6763
6764 if (algorithm_pos > 0)
6765 {
6766 local_free (rd);
6767
6768 rd = init_restore (argc, argv);
6769
6770 data.rd = rd;
6771 }
6772
6773 /**
6774 * update hash_mode in case of multihash benchmark
6775 */
6776
6777 if (benchmark == 1)
6778 {
6779 if (hash_mode_chgd == 0)
6780 {
6781 hash_mode = algorithms[algorithm_pos];
6782
6783 data.hash_mode = hash_mode;
6784 }
6785
6786 quiet = 1;
6787
6788 data.quiet = quiet;
6789 }
6790
6791 switch (hash_mode)
6792 {
6793 case 0: hash_type = HASH_TYPE_MD5;
6794 salt_type = SALT_TYPE_NONE;
6795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6796 opts_type = OPTS_TYPE_PT_GENERATE_LE
6797 | OPTS_TYPE_PT_ADD80
6798 | OPTS_TYPE_PT_ADDBITS14;
6799 kern_type = KERN_TYPE_MD5;
6800 dgst_size = DGST_SIZE_4_4;
6801 parse_func = md5_parse_hash;
6802 sort_by_digest = sort_by_digest_4_4;
6803 opti_type = OPTI_TYPE_ZERO_BYTE
6804 | OPTI_TYPE_PRECOMPUTE_INIT
6805 | OPTI_TYPE_PRECOMPUTE_MERKLE
6806 | OPTI_TYPE_MEET_IN_MIDDLE
6807 | OPTI_TYPE_EARLY_SKIP
6808 | OPTI_TYPE_NOT_ITERATED
6809 | OPTI_TYPE_NOT_SALTED
6810 | OPTI_TYPE_RAW_HASH;
6811 dgst_pos0 = 0;
6812 dgst_pos1 = 3;
6813 dgst_pos2 = 2;
6814 dgst_pos3 = 1;
6815 break;
6816
6817 case 10: hash_type = HASH_TYPE_MD5;
6818 salt_type = SALT_TYPE_INTERN;
6819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6820 opts_type = OPTS_TYPE_PT_GENERATE_LE
6821 | OPTS_TYPE_ST_ADD80
6822 | OPTS_TYPE_ST_ADDBITS14;
6823 kern_type = KERN_TYPE_MD5_PWSLT;
6824 dgst_size = DGST_SIZE_4_4;
6825 parse_func = md5s_parse_hash;
6826 sort_by_digest = sort_by_digest_4_4;
6827 opti_type = OPTI_TYPE_ZERO_BYTE
6828 | OPTI_TYPE_PRECOMPUTE_INIT
6829 | OPTI_TYPE_PRECOMPUTE_MERKLE
6830 | OPTI_TYPE_MEET_IN_MIDDLE
6831 | OPTI_TYPE_EARLY_SKIP
6832 | OPTI_TYPE_NOT_ITERATED
6833 | OPTI_TYPE_APPENDED_SALT
6834 | OPTI_TYPE_RAW_HASH;
6835 dgst_pos0 = 0;
6836 dgst_pos1 = 3;
6837 dgst_pos2 = 2;
6838 dgst_pos3 = 1;
6839 break;
6840
6841 case 11: hash_type = HASH_TYPE_MD5;
6842 salt_type = SALT_TYPE_INTERN;
6843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6844 opts_type = OPTS_TYPE_PT_GENERATE_LE
6845 | OPTS_TYPE_ST_ADD80
6846 | OPTS_TYPE_ST_ADDBITS14;
6847 kern_type = KERN_TYPE_MD5_PWSLT;
6848 dgst_size = DGST_SIZE_4_4;
6849 parse_func = joomla_parse_hash;
6850 sort_by_digest = sort_by_digest_4_4;
6851 opti_type = OPTI_TYPE_ZERO_BYTE
6852 | OPTI_TYPE_PRECOMPUTE_INIT
6853 | OPTI_TYPE_PRECOMPUTE_MERKLE
6854 | OPTI_TYPE_MEET_IN_MIDDLE
6855 | OPTI_TYPE_EARLY_SKIP
6856 | OPTI_TYPE_NOT_ITERATED
6857 | OPTI_TYPE_APPENDED_SALT
6858 | OPTI_TYPE_RAW_HASH;
6859 dgst_pos0 = 0;
6860 dgst_pos1 = 3;
6861 dgst_pos2 = 2;
6862 dgst_pos3 = 1;
6863 break;
6864
6865 case 12: hash_type = HASH_TYPE_MD5;
6866 salt_type = SALT_TYPE_INTERN;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_LE
6869 | OPTS_TYPE_ST_ADD80
6870 | OPTS_TYPE_ST_ADDBITS14;
6871 kern_type = KERN_TYPE_MD5_PWSLT;
6872 dgst_size = DGST_SIZE_4_4;
6873 parse_func = postgresql_parse_hash;
6874 sort_by_digest = sort_by_digest_4_4;
6875 opti_type = OPTI_TYPE_ZERO_BYTE
6876 | OPTI_TYPE_PRECOMPUTE_INIT
6877 | OPTI_TYPE_PRECOMPUTE_MERKLE
6878 | OPTI_TYPE_MEET_IN_MIDDLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_APPENDED_SALT
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 0;
6884 dgst_pos1 = 3;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 20: hash_type = HASH_TYPE_MD5;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_LE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS14;
6895 kern_type = KERN_TYPE_MD5_SLTPW;
6896 dgst_size = DGST_SIZE_4_4;
6897 parse_func = md5s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_4;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_PREPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 0;
6907 dgst_pos1 = 3;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 21: hash_type = HASH_TYPE_MD5;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_LE
6916 | OPTS_TYPE_PT_ADD80
6917 | OPTS_TYPE_PT_ADDBITS14;
6918 kern_type = KERN_TYPE_MD5_SLTPW;
6919 dgst_size = DGST_SIZE_4_4;
6920 parse_func = osc_parse_hash;
6921 sort_by_digest = sort_by_digest_4_4;
6922 opti_type = OPTI_TYPE_ZERO_BYTE
6923 | OPTI_TYPE_PRECOMPUTE_INIT
6924 | OPTI_TYPE_PRECOMPUTE_MERKLE
6925 | OPTI_TYPE_EARLY_SKIP
6926 | OPTI_TYPE_NOT_ITERATED
6927 | OPTI_TYPE_PREPENDED_SALT
6928 | OPTI_TYPE_RAW_HASH;
6929 dgst_pos0 = 0;
6930 dgst_pos1 = 3;
6931 dgst_pos2 = 2;
6932 dgst_pos3 = 1;
6933 break;
6934
6935 case 22: hash_type = HASH_TYPE_MD5;
6936 salt_type = SALT_TYPE_EMBEDDED;
6937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6938 opts_type = OPTS_TYPE_PT_GENERATE_LE
6939 | OPTS_TYPE_PT_ADD80
6940 | OPTS_TYPE_PT_ADDBITS14;
6941 kern_type = KERN_TYPE_MD5_SLTPW;
6942 dgst_size = DGST_SIZE_4_4;
6943 parse_func = netscreen_parse_hash;
6944 sort_by_digest = sort_by_digest_4_4;
6945 opti_type = OPTI_TYPE_ZERO_BYTE
6946 | OPTI_TYPE_PRECOMPUTE_INIT
6947 | OPTI_TYPE_PRECOMPUTE_MERKLE
6948 | OPTI_TYPE_EARLY_SKIP
6949 | OPTI_TYPE_NOT_ITERATED
6950 | OPTI_TYPE_PREPENDED_SALT
6951 | OPTI_TYPE_RAW_HASH;
6952 dgst_pos0 = 0;
6953 dgst_pos1 = 3;
6954 dgst_pos2 = 2;
6955 dgst_pos3 = 1;
6956 break;
6957
6958 case 23: hash_type = HASH_TYPE_MD5;
6959 salt_type = SALT_TYPE_EMBEDDED;
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_MD5_SLTPW;
6965 dgst_size = DGST_SIZE_4_4;
6966 parse_func = skype_parse_hash;
6967 sort_by_digest = sort_by_digest_4_4;
6968 opti_type = OPTI_TYPE_ZERO_BYTE
6969 | OPTI_TYPE_PRECOMPUTE_INIT
6970 | OPTI_TYPE_PRECOMPUTE_MERKLE
6971 | OPTI_TYPE_EARLY_SKIP
6972 | OPTI_TYPE_NOT_ITERATED
6973 | OPTI_TYPE_PREPENDED_SALT
6974 | OPTI_TYPE_RAW_HASH;
6975 dgst_pos0 = 0;
6976 dgst_pos1 = 3;
6977 dgst_pos2 = 2;
6978 dgst_pos3 = 1;
6979 break;
6980
6981 case 30: hash_type = HASH_TYPE_MD5;
6982 salt_type = SALT_TYPE_INTERN;
6983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6984 opts_type = OPTS_TYPE_PT_GENERATE_LE
6985 | OPTS_TYPE_PT_UNICODE
6986 | OPTS_TYPE_ST_ADD80
6987 | OPTS_TYPE_ST_ADDBITS14;
6988 kern_type = KERN_TYPE_MD5_PWUSLT;
6989 dgst_size = DGST_SIZE_4_4;
6990 parse_func = md5s_parse_hash;
6991 sort_by_digest = sort_by_digest_4_4;
6992 opti_type = OPTI_TYPE_ZERO_BYTE
6993 | OPTI_TYPE_PRECOMPUTE_INIT
6994 | OPTI_TYPE_PRECOMPUTE_MERKLE
6995 | OPTI_TYPE_MEET_IN_MIDDLE
6996 | OPTI_TYPE_EARLY_SKIP
6997 | OPTI_TYPE_NOT_ITERATED
6998 | OPTI_TYPE_APPENDED_SALT
6999 | OPTI_TYPE_RAW_HASH;
7000 dgst_pos0 = 0;
7001 dgst_pos1 = 3;
7002 dgst_pos2 = 2;
7003 dgst_pos3 = 1;
7004 break;
7005
7006 case 40: hash_type = HASH_TYPE_MD5;
7007 salt_type = SALT_TYPE_INTERN;
7008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7009 opts_type = OPTS_TYPE_PT_GENERATE_LE
7010 | OPTS_TYPE_PT_ADD80
7011 | OPTS_TYPE_PT_ADDBITS14
7012 | OPTS_TYPE_PT_UNICODE;
7013 kern_type = KERN_TYPE_MD5_SLTPWU;
7014 dgst_size = DGST_SIZE_4_4;
7015 parse_func = md5s_parse_hash;
7016 sort_by_digest = sort_by_digest_4_4;
7017 opti_type = OPTI_TYPE_ZERO_BYTE
7018 | OPTI_TYPE_PRECOMPUTE_INIT
7019 | OPTI_TYPE_PRECOMPUTE_MERKLE
7020 | OPTI_TYPE_EARLY_SKIP
7021 | OPTI_TYPE_NOT_ITERATED
7022 | OPTI_TYPE_PREPENDED_SALT
7023 | OPTI_TYPE_RAW_HASH;
7024 dgst_pos0 = 0;
7025 dgst_pos1 = 3;
7026 dgst_pos2 = 2;
7027 dgst_pos3 = 1;
7028 break;
7029
7030 case 50: hash_type = HASH_TYPE_MD5;
7031 salt_type = SALT_TYPE_INTERN;
7032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7033 opts_type = OPTS_TYPE_PT_GENERATE_LE
7034 | OPTS_TYPE_ST_ADD80
7035 | OPTS_TYPE_ST_ADDBITS14;
7036 kern_type = KERN_TYPE_HMACMD5_PW;
7037 dgst_size = DGST_SIZE_4_4;
7038 parse_func = hmacmd5_parse_hash;
7039 sort_by_digest = sort_by_digest_4_4;
7040 opti_type = OPTI_TYPE_ZERO_BYTE
7041 | OPTI_TYPE_NOT_ITERATED;
7042 dgst_pos0 = 0;
7043 dgst_pos1 = 3;
7044 dgst_pos2 = 2;
7045 dgst_pos3 = 1;
7046 break;
7047
7048 case 60: hash_type = HASH_TYPE_MD5;
7049 salt_type = SALT_TYPE_INTERN;
7050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7051 opts_type = OPTS_TYPE_PT_GENERATE_LE
7052 | OPTS_TYPE_PT_ADD80
7053 | OPTS_TYPE_PT_ADDBITS14;
7054 kern_type = KERN_TYPE_HMACMD5_SLT;
7055 dgst_size = DGST_SIZE_4_4;
7056 parse_func = hmacmd5_parse_hash;
7057 sort_by_digest = sort_by_digest_4_4;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_NOT_ITERATED;
7060 dgst_pos0 = 0;
7061 dgst_pos1 = 3;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 100: hash_type = HASH_TYPE_SHA1;
7067 salt_type = SALT_TYPE_NONE;
7068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7069 opts_type = OPTS_TYPE_PT_GENERATE_BE
7070 | OPTS_TYPE_PT_ADD80
7071 | OPTS_TYPE_PT_ADDBITS15;
7072 kern_type = KERN_TYPE_SHA1;
7073 dgst_size = DGST_SIZE_4_5;
7074 parse_func = sha1_parse_hash;
7075 sort_by_digest = sort_by_digest_4_5;
7076 opti_type = OPTI_TYPE_ZERO_BYTE
7077 | OPTI_TYPE_PRECOMPUTE_INIT
7078 | OPTI_TYPE_PRECOMPUTE_MERKLE
7079 | OPTI_TYPE_EARLY_SKIP
7080 | OPTI_TYPE_NOT_ITERATED
7081 | OPTI_TYPE_NOT_SALTED
7082 | OPTI_TYPE_RAW_HASH;
7083 dgst_pos0 = 3;
7084 dgst_pos1 = 4;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 1;
7087 break;
7088
7089 case 101: hash_type = HASH_TYPE_SHA1;
7090 salt_type = SALT_TYPE_NONE;
7091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7092 opts_type = OPTS_TYPE_PT_GENERATE_BE
7093 | OPTS_TYPE_PT_ADD80
7094 | OPTS_TYPE_PT_ADDBITS15;
7095 kern_type = KERN_TYPE_SHA1;
7096 dgst_size = DGST_SIZE_4_5;
7097 parse_func = sha1b64_parse_hash;
7098 sort_by_digest = sort_by_digest_4_5;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_EARLY_SKIP
7103 | OPTI_TYPE_NOT_ITERATED
7104 | OPTI_TYPE_NOT_SALTED
7105 | OPTI_TYPE_RAW_HASH;
7106 dgst_pos0 = 3;
7107 dgst_pos1 = 4;
7108 dgst_pos2 = 2;
7109 dgst_pos3 = 1;
7110 break;
7111
7112 case 110: hash_type = HASH_TYPE_SHA1;
7113 salt_type = SALT_TYPE_INTERN;
7114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7115 opts_type = OPTS_TYPE_PT_GENERATE_BE
7116 | OPTS_TYPE_ST_ADD80
7117 | OPTS_TYPE_ST_ADDBITS15;
7118 kern_type = KERN_TYPE_SHA1_PWSLT;
7119 dgst_size = DGST_SIZE_4_5;
7120 parse_func = sha1s_parse_hash;
7121 sort_by_digest = sort_by_digest_4_5;
7122 opti_type = OPTI_TYPE_ZERO_BYTE
7123 | OPTI_TYPE_PRECOMPUTE_INIT
7124 | OPTI_TYPE_PRECOMPUTE_MERKLE
7125 | OPTI_TYPE_EARLY_SKIP
7126 | OPTI_TYPE_NOT_ITERATED
7127 | OPTI_TYPE_APPENDED_SALT
7128 | OPTI_TYPE_RAW_HASH;
7129 dgst_pos0 = 3;
7130 dgst_pos1 = 4;
7131 dgst_pos2 = 2;
7132 dgst_pos3 = 1;
7133 break;
7134
7135 case 111: hash_type = HASH_TYPE_SHA1;
7136 salt_type = SALT_TYPE_EMBEDDED;
7137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7138 opts_type = OPTS_TYPE_PT_GENERATE_BE
7139 | OPTS_TYPE_ST_ADD80
7140 | OPTS_TYPE_ST_ADDBITS15;
7141 kern_type = KERN_TYPE_SHA1_PWSLT;
7142 dgst_size = DGST_SIZE_4_5;
7143 parse_func = sha1b64s_parse_hash;
7144 sort_by_digest = sort_by_digest_4_5;
7145 opti_type = OPTI_TYPE_ZERO_BYTE
7146 | OPTI_TYPE_PRECOMPUTE_INIT
7147 | OPTI_TYPE_PRECOMPUTE_MERKLE
7148 | OPTI_TYPE_EARLY_SKIP
7149 | OPTI_TYPE_NOT_ITERATED
7150 | OPTI_TYPE_APPENDED_SALT
7151 | OPTI_TYPE_RAW_HASH;
7152 dgst_pos0 = 3;
7153 dgst_pos1 = 4;
7154 dgst_pos2 = 2;
7155 dgst_pos3 = 1;
7156 break;
7157
7158 case 112: hash_type = HASH_TYPE_SHA1;
7159 salt_type = SALT_TYPE_INTERN;
7160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7161 opts_type = OPTS_TYPE_PT_GENERATE_BE
7162 | OPTS_TYPE_ST_ADD80
7163 | OPTS_TYPE_ST_ADDBITS15
7164 | OPTS_TYPE_ST_HEX;
7165 kern_type = KERN_TYPE_SHA1_PWSLT;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = oracles_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_APPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 120: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_INTERN;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_PT_ADD80
7187 | OPTS_TYPE_PT_ADDBITS15;
7188 kern_type = KERN_TYPE_SHA1_SLTPW;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = sha1s_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_PREPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 121: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_PT_ADD80
7210 | OPTS_TYPE_PT_ADDBITS15
7211 | OPTS_TYPE_ST_LOWER;
7212 kern_type = KERN_TYPE_SHA1_SLTPW;
7213 dgst_size = DGST_SIZE_4_5;
7214 parse_func = smf_parse_hash;
7215 sort_by_digest = sort_by_digest_4_5;
7216 opti_type = OPTI_TYPE_ZERO_BYTE
7217 | OPTI_TYPE_PRECOMPUTE_INIT
7218 | OPTI_TYPE_PRECOMPUTE_MERKLE
7219 | OPTI_TYPE_EARLY_SKIP
7220 | OPTI_TYPE_NOT_ITERATED
7221 | OPTI_TYPE_PREPENDED_SALT
7222 | OPTI_TYPE_RAW_HASH;
7223 dgst_pos0 = 3;
7224 dgst_pos1 = 4;
7225 dgst_pos2 = 2;
7226 dgst_pos3 = 1;
7227 break;
7228
7229 case 122: hash_type = HASH_TYPE_SHA1;
7230 salt_type = SALT_TYPE_EMBEDDED;
7231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7232 opts_type = OPTS_TYPE_PT_GENERATE_BE
7233 | OPTS_TYPE_PT_ADD80
7234 | OPTS_TYPE_PT_ADDBITS15
7235 | OPTS_TYPE_ST_HEX;
7236 kern_type = KERN_TYPE_SHA1_SLTPW;
7237 dgst_size = DGST_SIZE_4_5;
7238 parse_func = osx1_parse_hash;
7239 sort_by_digest = sort_by_digest_4_5;
7240 opti_type = OPTI_TYPE_ZERO_BYTE
7241 | OPTI_TYPE_PRECOMPUTE_INIT
7242 | OPTI_TYPE_PRECOMPUTE_MERKLE
7243 | OPTI_TYPE_EARLY_SKIP
7244 | OPTI_TYPE_NOT_ITERATED
7245 | OPTI_TYPE_PREPENDED_SALT
7246 | OPTI_TYPE_RAW_HASH;
7247 dgst_pos0 = 3;
7248 dgst_pos1 = 4;
7249 dgst_pos2 = 2;
7250 dgst_pos3 = 1;
7251 break;
7252
7253 case 124: hash_type = HASH_TYPE_SHA1;
7254 salt_type = SALT_TYPE_EMBEDDED;
7255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7256 opts_type = OPTS_TYPE_PT_GENERATE_BE
7257 | OPTS_TYPE_PT_ADD80
7258 | OPTS_TYPE_PT_ADDBITS15;
7259 kern_type = KERN_TYPE_SHA1_SLTPW;
7260 dgst_size = DGST_SIZE_4_5;
7261 parse_func = djangosha1_parse_hash;
7262 sort_by_digest = sort_by_digest_4_5;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_PREPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 130: hash_type = HASH_TYPE_SHA1;
7277 salt_type = SALT_TYPE_INTERN;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_BE
7280 | OPTS_TYPE_PT_UNICODE
7281 | OPTS_TYPE_ST_ADD80
7282 | OPTS_TYPE_ST_ADDBITS15;
7283 kern_type = KERN_TYPE_SHA1_PWUSLT;
7284 dgst_size = DGST_SIZE_4_5;
7285 parse_func = sha1s_parse_hash;
7286 sort_by_digest = sort_by_digest_4_5;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_APPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 3;
7295 dgst_pos1 = 4;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 131: hash_type = HASH_TYPE_SHA1;
7301 salt_type = SALT_TYPE_EMBEDDED;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_BE
7304 | OPTS_TYPE_PT_UNICODE
7305 | OPTS_TYPE_PT_UPPER
7306 | OPTS_TYPE_ST_ADD80
7307 | OPTS_TYPE_ST_ADDBITS15
7308 | OPTS_TYPE_ST_HEX;
7309 kern_type = KERN_TYPE_SHA1_PWUSLT;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = mssql2000_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_APPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 4;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 132: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_EMBEDDED;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_UNICODE
7331 | OPTS_TYPE_ST_ADD80
7332 | OPTS_TYPE_ST_ADDBITS15
7333 | OPTS_TYPE_ST_HEX;
7334 kern_type = KERN_TYPE_SHA1_PWUSLT;
7335 dgst_size = DGST_SIZE_4_5;
7336 parse_func = mssql2005_parse_hash;
7337 sort_by_digest = sort_by_digest_4_5;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_APPENDED_SALT
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 3;
7346 dgst_pos1 = 4;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 1;
7349 break;
7350
7351 case 133: hash_type = HASH_TYPE_SHA1;
7352 salt_type = SALT_TYPE_EMBEDDED;
7353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7354 opts_type = OPTS_TYPE_PT_GENERATE_BE
7355 | OPTS_TYPE_PT_UNICODE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS15;
7358 kern_type = KERN_TYPE_SHA1_PWUSLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = peoplesoft_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 140: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_INTERN;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_ADD80
7380 | OPTS_TYPE_PT_ADDBITS15
7381 | OPTS_TYPE_PT_UNICODE;
7382 kern_type = KERN_TYPE_SHA1_SLTPWU;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = sha1s_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_PREPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 141: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_EMBEDDED;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_ADD80
7404 | OPTS_TYPE_PT_ADDBITS15
7405 | OPTS_TYPE_PT_UNICODE
7406 | OPTS_TYPE_ST_BASE64;
7407 kern_type = KERN_TYPE_SHA1_SLTPWU;
7408 dgst_size = DGST_SIZE_4_5;
7409 parse_func = episerver_parse_hash;
7410 sort_by_digest = sort_by_digest_4_5;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_EARLY_SKIP
7415 | OPTI_TYPE_NOT_ITERATED
7416 | OPTI_TYPE_PREPENDED_SALT
7417 | OPTI_TYPE_RAW_HASH;
7418 dgst_pos0 = 3;
7419 dgst_pos1 = 4;
7420 dgst_pos2 = 2;
7421 dgst_pos3 = 1;
7422 break;
7423
7424 case 150: hash_type = HASH_TYPE_SHA1;
7425 salt_type = SALT_TYPE_INTERN;
7426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7427 opts_type = OPTS_TYPE_PT_GENERATE_BE
7428 | OPTS_TYPE_ST_ADD80
7429 | OPTS_TYPE_ST_ADDBITS15;
7430 kern_type = KERN_TYPE_HMACSHA1_PW;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = hmacsha1_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_NOT_ITERATED;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 4;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 1;
7440 break;
7441
7442 case 160: hash_type = HASH_TYPE_SHA1;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15;
7448 kern_type = KERN_TYPE_HMACSHA1_SLT;
7449 dgst_size = DGST_SIZE_4_5;
7450 parse_func = hmacsha1_parse_hash;
7451 sort_by_digest = sort_by_digest_4_5;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_NOT_ITERATED;
7454 dgst_pos0 = 3;
7455 dgst_pos1 = 4;
7456 dgst_pos2 = 2;
7457 dgst_pos3 = 1;
7458 break;
7459
7460 case 190: hash_type = HASH_TYPE_SHA1;
7461 salt_type = SALT_TYPE_NONE;
7462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7463 opts_type = OPTS_TYPE_PT_GENERATE_BE
7464 | OPTS_TYPE_PT_ADD80
7465 | OPTS_TYPE_PT_ADDBITS15;
7466 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7467 dgst_size = DGST_SIZE_4_5;
7468 parse_func = sha1linkedin_parse_hash;
7469 sort_by_digest = sort_by_digest_4_5;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_PRECOMPUTE_INIT
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_NOT_SALTED;
7475 dgst_pos0 = 0;
7476 dgst_pos1 = 4;
7477 dgst_pos2 = 3;
7478 dgst_pos3 = 2;
7479 break;
7480
7481 case 200: hash_type = HASH_TYPE_MYSQL;
7482 salt_type = SALT_TYPE_NONE;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = 0;
7485 kern_type = KERN_TYPE_MYSQL;
7486 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7487 parse_func = mysql323_parse_hash;
7488 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7489 opti_type = OPTI_TYPE_ZERO_BYTE;
7490 dgst_pos0 = 0;
7491 dgst_pos1 = 1;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 3;
7494 break;
7495
7496 case 300: hash_type = HASH_TYPE_SHA1;
7497 salt_type = SALT_TYPE_NONE;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_BE
7500 | OPTS_TYPE_PT_ADD80
7501 | OPTS_TYPE_PT_ADDBITS15;
7502 kern_type = KERN_TYPE_MYSQL41;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = sha1_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_NOT_SALTED;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 400: hash_type = HASH_TYPE_MD5;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7522 kern_type = KERN_TYPE_PHPASS;
7523 dgst_size = DGST_SIZE_4_4;
7524 parse_func = phpass_parse_hash;
7525 sort_by_digest = sort_by_digest_4_4;
7526 opti_type = OPTI_TYPE_ZERO_BYTE;
7527 dgst_pos0 = 0;
7528 dgst_pos1 = 1;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 3;
7531 break;
7532
7533 case 500: hash_type = HASH_TYPE_MD5;
7534 salt_type = SALT_TYPE_EMBEDDED;
7535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7537 kern_type = KERN_TYPE_MD5CRYPT;
7538 dgst_size = DGST_SIZE_4_4;
7539 parse_func = md5crypt_parse_hash;
7540 sort_by_digest = sort_by_digest_4_4;
7541 opti_type = OPTI_TYPE_ZERO_BYTE;
7542 dgst_pos0 = 0;
7543 dgst_pos1 = 1;
7544 dgst_pos2 = 2;
7545 dgst_pos3 = 3;
7546 break;
7547
7548 case 501: hash_type = HASH_TYPE_MD5;
7549 salt_type = SALT_TYPE_EMBEDDED;
7550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7551 opts_type = OPTS_TYPE_PT_GENERATE_LE
7552 | OPTS_TYPE_HASH_COPY;
7553 kern_type = KERN_TYPE_MD5CRYPT;
7554 dgst_size = DGST_SIZE_4_4;
7555 parse_func = juniper_parse_hash;
7556 sort_by_digest = sort_by_digest_4_4;
7557 opti_type = OPTI_TYPE_ZERO_BYTE;
7558 dgst_pos0 = 0;
7559 dgst_pos1 = 1;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 3;
7562 break;
7563
7564 case 900: hash_type = HASH_TYPE_MD4;
7565 salt_type = SALT_TYPE_NONE;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_LE
7568 | OPTS_TYPE_PT_ADD80
7569 | OPTS_TYPE_PT_ADDBITS14;
7570 kern_type = KERN_TYPE_MD4;
7571 dgst_size = DGST_SIZE_4_4;
7572 parse_func = md4_parse_hash;
7573 sort_by_digest = sort_by_digest_4_4;
7574 opti_type = OPTI_TYPE_ZERO_BYTE
7575 | OPTI_TYPE_PRECOMPUTE_INIT
7576 | OPTI_TYPE_PRECOMPUTE_MERKLE
7577 | OPTI_TYPE_MEET_IN_MIDDLE
7578 | OPTI_TYPE_EARLY_SKIP
7579 | OPTI_TYPE_NOT_ITERATED
7580 | OPTI_TYPE_NOT_SALTED
7581 | OPTI_TYPE_RAW_HASH;
7582 dgst_pos0 = 0;
7583 dgst_pos1 = 3;
7584 dgst_pos2 = 2;
7585 dgst_pos3 = 1;
7586 break;
7587
7588 case 1000: hash_type = HASH_TYPE_MD4;
7589 salt_type = SALT_TYPE_NONE;
7590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7591 opts_type = OPTS_TYPE_PT_GENERATE_LE
7592 | OPTS_TYPE_PT_ADD80
7593 | OPTS_TYPE_PT_ADDBITS14
7594 | OPTS_TYPE_PT_UNICODE;
7595 kern_type = KERN_TYPE_MD4_PWU;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = md4_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE
7600 | OPTI_TYPE_PRECOMPUTE_INIT
7601 | OPTI_TYPE_PRECOMPUTE_MERKLE
7602 | OPTI_TYPE_MEET_IN_MIDDLE
7603 | OPTI_TYPE_EARLY_SKIP
7604 | OPTI_TYPE_NOT_ITERATED
7605 | OPTI_TYPE_NOT_SALTED
7606 | OPTI_TYPE_RAW_HASH;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 3;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 1;
7611 break;
7612
7613 case 1100: hash_type = HASH_TYPE_MD4;
7614 salt_type = SALT_TYPE_INTERN;
7615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE
7617 | OPTS_TYPE_PT_ADD80
7618 | OPTS_TYPE_PT_ADDBITS14
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_UNICODE
7622 | OPTS_TYPE_ST_LOWER;
7623 kern_type = KERN_TYPE_MD44_PWUSLT;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = dcc_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
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 dgst_pos0 = 0;
7633 dgst_pos1 = 3;
7634 dgst_pos2 = 2;
7635 dgst_pos3 = 1;
7636 break;
7637
7638 case 1400: hash_type = HASH_TYPE_SHA256;
7639 salt_type = SALT_TYPE_NONE;
7640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7641 opts_type = OPTS_TYPE_PT_GENERATE_BE
7642 | OPTS_TYPE_PT_ADD80
7643 | OPTS_TYPE_PT_ADDBITS15;
7644 kern_type = KERN_TYPE_SHA256;
7645 dgst_size = DGST_SIZE_4_8;
7646 parse_func = sha256_parse_hash;
7647 sort_by_digest = sort_by_digest_4_8;
7648 opti_type = OPTI_TYPE_ZERO_BYTE
7649 | OPTI_TYPE_PRECOMPUTE_INIT
7650 | OPTI_TYPE_PRECOMPUTE_MERKLE
7651 | OPTI_TYPE_EARLY_SKIP
7652 | OPTI_TYPE_NOT_ITERATED
7653 | OPTI_TYPE_NOT_SALTED
7654 | OPTI_TYPE_RAW_HASH;
7655 dgst_pos0 = 3;
7656 dgst_pos1 = 7;
7657 dgst_pos2 = 2;
7658 dgst_pos3 = 6;
7659 break;
7660
7661 case 1410: hash_type = HASH_TYPE_SHA256;
7662 salt_type = SALT_TYPE_INTERN;
7663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7664 opts_type = OPTS_TYPE_PT_GENERATE_BE
7665 | OPTS_TYPE_ST_ADD80
7666 | OPTS_TYPE_ST_ADDBITS15;
7667 kern_type = KERN_TYPE_SHA256_PWSLT;
7668 dgst_size = DGST_SIZE_4_8;
7669 parse_func = sha256s_parse_hash;
7670 sort_by_digest = sort_by_digest_4_8;
7671 opti_type = OPTI_TYPE_ZERO_BYTE
7672 | OPTI_TYPE_PRECOMPUTE_INIT
7673 | OPTI_TYPE_PRECOMPUTE_MERKLE
7674 | OPTI_TYPE_EARLY_SKIP
7675 | OPTI_TYPE_NOT_ITERATED
7676 | OPTI_TYPE_APPENDED_SALT
7677 | OPTI_TYPE_RAW_HASH;
7678 dgst_pos0 = 3;
7679 dgst_pos1 = 7;
7680 dgst_pos2 = 2;
7681 dgst_pos3 = 6;
7682 break;
7683
7684 case 1420: hash_type = HASH_TYPE_SHA256;
7685 salt_type = SALT_TYPE_INTERN;
7686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7687 opts_type = OPTS_TYPE_PT_GENERATE_BE
7688 | OPTS_TYPE_PT_ADD80
7689 | OPTS_TYPE_PT_ADDBITS15;
7690 kern_type = KERN_TYPE_SHA256_SLTPW;
7691 dgst_size = DGST_SIZE_4_8;
7692 parse_func = sha256s_parse_hash;
7693 sort_by_digest = sort_by_digest_4_8;
7694 opti_type = OPTI_TYPE_ZERO_BYTE
7695 | OPTI_TYPE_PRECOMPUTE_INIT
7696 | OPTI_TYPE_PRECOMPUTE_MERKLE
7697 | OPTI_TYPE_EARLY_SKIP
7698 | OPTI_TYPE_NOT_ITERATED
7699 | OPTI_TYPE_PREPENDED_SALT
7700 | OPTI_TYPE_RAW_HASH;
7701 dgst_pos0 = 3;
7702 dgst_pos1 = 7;
7703 dgst_pos2 = 2;
7704 dgst_pos3 = 6;
7705 break;
7706
7707 case 1421: hash_type = HASH_TYPE_SHA256;
7708 salt_type = SALT_TYPE_EMBEDDED;
7709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7710 opts_type = OPTS_TYPE_PT_GENERATE_BE
7711 | OPTS_TYPE_PT_ADD80
7712 | OPTS_TYPE_PT_ADDBITS15;
7713 kern_type = KERN_TYPE_SHA256_SLTPW;
7714 dgst_size = DGST_SIZE_4_8;
7715 parse_func = hmailserver_parse_hash;
7716 sort_by_digest = sort_by_digest_4_8;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_PREPENDED_SALT
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 7;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 6;
7728 break;
7729
7730 case 1430: 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_UNICODE
7735 | OPTS_TYPE_ST_ADD80
7736 | OPTS_TYPE_ST_ADDBITS15;
7737 kern_type = KERN_TYPE_SHA256_PWUSLT;
7738 dgst_size = DGST_SIZE_4_8;
7739 parse_func = sha256s_parse_hash;
7740 sort_by_digest = sort_by_digest_4_8;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_PRECOMPUTE_INIT
7743 | OPTI_TYPE_PRECOMPUTE_MERKLE
7744 | OPTI_TYPE_EARLY_SKIP
7745 | OPTI_TYPE_NOT_ITERATED
7746 | OPTI_TYPE_APPENDED_SALT
7747 | OPTI_TYPE_RAW_HASH;
7748 dgst_pos0 = 3;
7749 dgst_pos1 = 7;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 6;
7752 break;
7753
7754 case 1440: hash_type = HASH_TYPE_SHA256;
7755 salt_type = SALT_TYPE_INTERN;
7756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_BE
7758 | OPTS_TYPE_PT_ADD80
7759 | OPTS_TYPE_PT_ADDBITS15
7760 | OPTS_TYPE_PT_UNICODE;
7761 kern_type = KERN_TYPE_SHA256_SLTPWU;
7762 dgst_size = DGST_SIZE_4_8;
7763 parse_func = sha256s_parse_hash;
7764 sort_by_digest = sort_by_digest_4_8;
7765 opti_type = OPTI_TYPE_ZERO_BYTE
7766 | OPTI_TYPE_PRECOMPUTE_INIT
7767 | OPTI_TYPE_PRECOMPUTE_MERKLE
7768 | OPTI_TYPE_EARLY_SKIP
7769 | OPTI_TYPE_NOT_ITERATED
7770 | OPTI_TYPE_PREPENDED_SALT
7771 | OPTI_TYPE_RAW_HASH;
7772 dgst_pos0 = 3;
7773 dgst_pos1 = 7;
7774 dgst_pos2 = 2;
7775 dgst_pos3 = 6;
7776 break;
7777
7778 case 1441: hash_type = HASH_TYPE_SHA256;
7779 salt_type = SALT_TYPE_EMBEDDED;
7780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7781 opts_type = OPTS_TYPE_PT_GENERATE_BE
7782 | OPTS_TYPE_PT_ADD80
7783 | OPTS_TYPE_PT_ADDBITS15
7784 | OPTS_TYPE_PT_UNICODE
7785 | OPTS_TYPE_ST_BASE64;
7786 kern_type = KERN_TYPE_SHA256_SLTPWU;
7787 dgst_size = DGST_SIZE_4_8;
7788 parse_func = episerver4_parse_hash;
7789 sort_by_digest = sort_by_digest_4_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_PREPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 7;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 6;
7801 break;
7802
7803 case 1450: hash_type = HASH_TYPE_SHA256;
7804 salt_type = SALT_TYPE_INTERN;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_ST_ADD80;
7808 kern_type = KERN_TYPE_HMACSHA256_PW;
7809 dgst_size = DGST_SIZE_4_8;
7810 parse_func = hmacsha256_parse_hash;
7811 sort_by_digest = sort_by_digest_4_8;
7812 opti_type = OPTI_TYPE_ZERO_BYTE
7813 | OPTI_TYPE_NOT_ITERATED;
7814 dgst_pos0 = 3;
7815 dgst_pos1 = 7;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 6;
7818 break;
7819
7820 case 1460: hash_type = HASH_TYPE_SHA256;
7821 salt_type = SALT_TYPE_INTERN;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_BE
7824 | OPTS_TYPE_PT_ADD80
7825 | OPTS_TYPE_PT_ADDBITS15;
7826 kern_type = KERN_TYPE_HMACSHA256_SLT;
7827 dgst_size = DGST_SIZE_4_8;
7828 parse_func = hmacsha256_parse_hash;
7829 sort_by_digest = sort_by_digest_4_8;
7830 opti_type = OPTI_TYPE_ZERO_BYTE
7831 | OPTI_TYPE_NOT_ITERATED;
7832 dgst_pos0 = 3;
7833 dgst_pos1 = 7;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 6;
7836 break;
7837
7838 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_LE
7842 | OPTS_TYPE_PT_BITSLICE;
7843 kern_type = KERN_TYPE_DESCRYPT;
7844 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7845 parse_func = descrypt_parse_hash;
7846 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7849 dgst_pos0 = 0;
7850 dgst_pos1 = 1;
7851 dgst_pos2 = 2;
7852 dgst_pos3 = 3;
7853 break;
7854
7855 case 1600: hash_type = HASH_TYPE_MD5;
7856 salt_type = SALT_TYPE_EMBEDDED;
7857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7859 kern_type = KERN_TYPE_APR1CRYPT;
7860 dgst_size = DGST_SIZE_4_4;
7861 parse_func = md5apr1_parse_hash;
7862 sort_by_digest = sort_by_digest_4_4;
7863 opti_type = OPTI_TYPE_ZERO_BYTE;
7864 dgst_pos0 = 0;
7865 dgst_pos1 = 1;
7866 dgst_pos2 = 2;
7867 dgst_pos3 = 3;
7868 break;
7869
7870 case 1700: hash_type = HASH_TYPE_SHA512;
7871 salt_type = SALT_TYPE_NONE;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_ADD80
7875 | OPTS_TYPE_PT_ADDBITS15;
7876 kern_type = KERN_TYPE_SHA512;
7877 dgst_size = DGST_SIZE_8_8;
7878 parse_func = sha512_parse_hash;
7879 sort_by_digest = sort_by_digest_8_8;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_PRECOMPUTE_INIT
7882 | OPTI_TYPE_PRECOMPUTE_MERKLE
7883 | OPTI_TYPE_EARLY_SKIP
7884 | OPTI_TYPE_NOT_ITERATED
7885 | OPTI_TYPE_NOT_SALTED
7886 | OPTI_TYPE_USES_BITS_64
7887 | OPTI_TYPE_RAW_HASH;
7888 dgst_pos0 = 14;
7889 dgst_pos1 = 15;
7890 dgst_pos2 = 6;
7891 dgst_pos3 = 7;
7892 break;
7893
7894 case 1710: hash_type = HASH_TYPE_SHA512;
7895 salt_type = SALT_TYPE_INTERN;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_BE
7898 | OPTS_TYPE_ST_ADD80
7899 | OPTS_TYPE_ST_ADDBITS15;
7900 kern_type = KERN_TYPE_SHA512_PWSLT;
7901 dgst_size = DGST_SIZE_8_8;
7902 parse_func = sha512s_parse_hash;
7903 sort_by_digest = sort_by_digest_8_8;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED
7909 | OPTI_TYPE_APPENDED_SALT
7910 | OPTI_TYPE_USES_BITS_64
7911 | OPTI_TYPE_RAW_HASH;
7912 dgst_pos0 = 14;
7913 dgst_pos1 = 15;
7914 dgst_pos2 = 6;
7915 dgst_pos3 = 7;
7916 break;
7917
7918 case 1711: hash_type = HASH_TYPE_SHA512;
7919 salt_type = SALT_TYPE_EMBEDDED;
7920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7921 opts_type = OPTS_TYPE_PT_GENERATE_BE
7922 | OPTS_TYPE_ST_ADD80
7923 | OPTS_TYPE_ST_ADDBITS15;
7924 kern_type = KERN_TYPE_SHA512_PWSLT;
7925 dgst_size = DGST_SIZE_8_8;
7926 parse_func = sha512b64s_parse_hash;
7927 sort_by_digest = sort_by_digest_8_8;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_PRECOMPUTE_INIT
7930 | OPTI_TYPE_PRECOMPUTE_MERKLE
7931 | OPTI_TYPE_EARLY_SKIP
7932 | OPTI_TYPE_NOT_ITERATED
7933 | OPTI_TYPE_APPENDED_SALT
7934 | OPTI_TYPE_USES_BITS_64
7935 | OPTI_TYPE_RAW_HASH;
7936 dgst_pos0 = 14;
7937 dgst_pos1 = 15;
7938 dgst_pos2 = 6;
7939 dgst_pos3 = 7;
7940 break;
7941
7942 case 1720: hash_type = HASH_TYPE_SHA512;
7943 salt_type = SALT_TYPE_INTERN;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_BE
7946 | OPTS_TYPE_PT_ADD80
7947 | OPTS_TYPE_PT_ADDBITS15;
7948 kern_type = KERN_TYPE_SHA512_SLTPW;
7949 dgst_size = DGST_SIZE_8_8;
7950 parse_func = sha512s_parse_hash;
7951 sort_by_digest = sort_by_digest_8_8;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_PRECOMPUTE_INIT
7954 | OPTI_TYPE_PRECOMPUTE_MERKLE
7955 | OPTI_TYPE_EARLY_SKIP
7956 | OPTI_TYPE_NOT_ITERATED
7957 | OPTI_TYPE_PREPENDED_SALT
7958 | OPTI_TYPE_USES_BITS_64
7959 | OPTI_TYPE_RAW_HASH;
7960 dgst_pos0 = 14;
7961 dgst_pos1 = 15;
7962 dgst_pos2 = 6;
7963 dgst_pos3 = 7;
7964 break;
7965
7966 case 1722: hash_type = HASH_TYPE_SHA512;
7967 salt_type = SALT_TYPE_EMBEDDED;
7968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7969 opts_type = OPTS_TYPE_PT_GENERATE_BE
7970 | OPTS_TYPE_PT_ADD80
7971 | OPTS_TYPE_PT_ADDBITS15
7972 | OPTS_TYPE_ST_HEX;
7973 kern_type = KERN_TYPE_SHA512_SLTPW;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = osx512_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_PREPENDED_SALT
7983 | OPTI_TYPE_USES_BITS_64
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 14;
7986 dgst_pos1 = 15;
7987 dgst_pos2 = 6;
7988 dgst_pos3 = 7;
7989 break;
7990
7991 case 1730: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_INTERN;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_UNICODE
7996 | OPTS_TYPE_ST_ADD80
7997 | OPTS_TYPE_ST_ADDBITS15;
7998 kern_type = KERN_TYPE_SHA512_PWSLTU;
7999 dgst_size = DGST_SIZE_8_8;
8000 parse_func = sha512s_parse_hash;
8001 sort_by_digest = sort_by_digest_8_8;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_APPENDED_SALT
8008 | OPTI_TYPE_USES_BITS_64
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 14;
8011 dgst_pos1 = 15;
8012 dgst_pos2 = 6;
8013 dgst_pos3 = 7;
8014 break;
8015
8016 case 1731: hash_type = HASH_TYPE_SHA512;
8017 salt_type = SALT_TYPE_EMBEDDED;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15
8023 | OPTS_TYPE_ST_HEX;
8024 kern_type = KERN_TYPE_SHA512_PWSLTU;
8025 dgst_size = DGST_SIZE_8_8;
8026 parse_func = mssql2012_parse_hash;
8027 sort_by_digest = sort_by_digest_8_8;
8028 opti_type = OPTI_TYPE_ZERO_BYTE
8029 | OPTI_TYPE_PRECOMPUTE_INIT
8030 | OPTI_TYPE_PRECOMPUTE_MERKLE
8031 | OPTI_TYPE_EARLY_SKIP
8032 | OPTI_TYPE_NOT_ITERATED
8033 | OPTI_TYPE_APPENDED_SALT
8034 | OPTI_TYPE_USES_BITS_64
8035 | OPTI_TYPE_RAW_HASH;
8036 dgst_pos0 = 14;
8037 dgst_pos1 = 15;
8038 dgst_pos2 = 6;
8039 dgst_pos3 = 7;
8040 break;
8041
8042 case 1740: hash_type = HASH_TYPE_SHA512;
8043 salt_type = SALT_TYPE_INTERN;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_BE
8046 | OPTS_TYPE_PT_ADD80
8047 | OPTS_TYPE_PT_ADDBITS15
8048 | OPTS_TYPE_PT_UNICODE;
8049 kern_type = KERN_TYPE_SHA512_SLTPWU;
8050 dgst_size = DGST_SIZE_8_8;
8051 parse_func = sha512s_parse_hash;
8052 sort_by_digest = sort_by_digest_8_8;
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_INIT
8055 | OPTI_TYPE_PRECOMPUTE_MERKLE
8056 | OPTI_TYPE_EARLY_SKIP
8057 | OPTI_TYPE_NOT_ITERATED
8058 | OPTI_TYPE_PREPENDED_SALT
8059 | OPTI_TYPE_USES_BITS_64
8060 | OPTI_TYPE_RAW_HASH;
8061 dgst_pos0 = 14;
8062 dgst_pos1 = 15;
8063 dgst_pos2 = 6;
8064 dgst_pos3 = 7;
8065 break;
8066
8067 case 1750: hash_type = HASH_TYPE_SHA512;
8068 salt_type = SALT_TYPE_INTERN;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_BE
8071 | OPTS_TYPE_ST_ADD80;
8072 kern_type = KERN_TYPE_HMACSHA512_PW;
8073 dgst_size = DGST_SIZE_8_8;
8074 parse_func = hmacsha512_parse_hash;
8075 sort_by_digest = sort_by_digest_8_8;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_USES_BITS_64
8078 | OPTI_TYPE_NOT_ITERATED;
8079 dgst_pos0 = 14;
8080 dgst_pos1 = 15;
8081 dgst_pos2 = 6;
8082 dgst_pos3 = 7;
8083 break;
8084
8085 case 1760: hash_type = HASH_TYPE_SHA512;
8086 salt_type = SALT_TYPE_INTERN;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS15;
8091 kern_type = KERN_TYPE_HMACSHA512_SLT;
8092 dgst_size = DGST_SIZE_8_8;
8093 parse_func = hmacsha512_parse_hash;
8094 sort_by_digest = sort_by_digest_8_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_USES_BITS_64
8097 | OPTI_TYPE_NOT_ITERATED;
8098 dgst_pos0 = 14;
8099 dgst_pos1 = 15;
8100 dgst_pos2 = 6;
8101 dgst_pos3 = 7;
8102 break;
8103
8104 case 1800: hash_type = HASH_TYPE_SHA512;
8105 salt_type = SALT_TYPE_EMBEDDED;
8106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8107 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8108 kern_type = KERN_TYPE_SHA512CRYPT;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = sha512crypt_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_USES_BITS_64;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 1;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 3;
8118 break;
8119
8120 case 2100: hash_type = HASH_TYPE_DCC2;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8124 | OPTS_TYPE_ST_LOWER
8125 | OPTS_TYPE_ST_UNICODE;
8126 kern_type = KERN_TYPE_DCC2;
8127 dgst_size = DGST_SIZE_4_4;
8128 parse_func = dcc2_parse_hash;
8129 sort_by_digest = sort_by_digest_4_4;
8130 opti_type = OPTI_TYPE_ZERO_BYTE;
8131 dgst_pos0 = 0;
8132 dgst_pos1 = 1;
8133 dgst_pos2 = 2;
8134 dgst_pos3 = 3;
8135 break;
8136
8137 case 2400: hash_type = HASH_TYPE_MD5;
8138 salt_type = SALT_TYPE_NONE;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8141 kern_type = KERN_TYPE_MD5PIX;
8142 dgst_size = DGST_SIZE_4_4;
8143 parse_func = md5pix_parse_hash;
8144 sort_by_digest = sort_by_digest_4_4;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_ITERATED
8150 | OPTI_TYPE_NOT_SALTED;
8151 dgst_pos0 = 0;
8152 dgst_pos1 = 3;
8153 dgst_pos2 = 2;
8154 dgst_pos3 = 1;
8155 break;
8156
8157 case 2410: hash_type = HASH_TYPE_MD5;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8161 kern_type = KERN_TYPE_MD5ASA;
8162 dgst_size = DGST_SIZE_4_4;
8163 parse_func = md5asa_parse_hash;
8164 sort_by_digest = sort_by_digest_4_4;
8165 opti_type = OPTI_TYPE_ZERO_BYTE
8166 | OPTI_TYPE_PRECOMPUTE_INIT
8167 | OPTI_TYPE_PRECOMPUTE_MERKLE
8168 | OPTI_TYPE_EARLY_SKIP
8169 | OPTI_TYPE_NOT_ITERATED;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 3;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 2500: hash_type = HASH_TYPE_WPA;
8177 salt_type = SALT_TYPE_EMBEDDED;
8178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8180 kern_type = KERN_TYPE_WPA;
8181 dgst_size = DGST_SIZE_4_4;
8182 parse_func = wpa_parse_hash;
8183 sort_by_digest = sort_by_digest_4_4;
8184 opti_type = OPTI_TYPE_ZERO_BYTE;
8185 dgst_pos0 = 0;
8186 dgst_pos1 = 1;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 3;
8189 break;
8190
8191 case 2600: hash_type = HASH_TYPE_MD5;
8192 salt_type = SALT_TYPE_VIRTUAL;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_ADD80
8196 | OPTS_TYPE_PT_ADDBITS14
8197 | OPTS_TYPE_ST_ADD80;
8198 kern_type = KERN_TYPE_MD55_PWSLT1;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = md5md5_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP;
8206 dgst_pos0 = 0;
8207 dgst_pos1 = 3;
8208 dgst_pos2 = 2;
8209 dgst_pos3 = 1;
8210 break;
8211
8212 case 2611: hash_type = HASH_TYPE_MD5;
8213 salt_type = SALT_TYPE_INTERN;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_LE
8216 | OPTS_TYPE_PT_ADD80
8217 | OPTS_TYPE_PT_ADDBITS14
8218 | OPTS_TYPE_ST_ADD80;
8219 kern_type = KERN_TYPE_MD55_PWSLT1;
8220 dgst_size = DGST_SIZE_4_4;
8221 parse_func = vb3_parse_hash;
8222 sort_by_digest = sort_by_digest_4_4;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 3;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 1;
8231 break;
8232
8233 case 2612: hash_type = HASH_TYPE_MD5;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS14
8239 | OPTS_TYPE_ST_ADD80
8240 | OPTS_TYPE_ST_HEX;
8241 kern_type = KERN_TYPE_MD55_PWSLT1;
8242 dgst_size = DGST_SIZE_4_4;
8243 parse_func = phps_parse_hash;
8244 sort_by_digest = sort_by_digest_4_4;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 3;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 1;
8253 break;
8254
8255 case 2711: 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 | OPTS_TYPE_ST_ADD80;
8262 kern_type = KERN_TYPE_MD55_PWSLT2;
8263 dgst_size = DGST_SIZE_4_4;
8264 parse_func = vb30_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4;
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_INIT
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 2811: hash_type = HASH_TYPE_MD5;
8276 salt_type = SALT_TYPE_INTERN;
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_MD55_SLTPW;
8282 dgst_size = DGST_SIZE_4_4;
8283 parse_func = ipb2_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_EARLY_SKIP;
8288 dgst_pos0 = 0;
8289 dgst_pos1 = 3;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 1;
8292 break;
8293
8294 case 3000: hash_type = HASH_TYPE_LM;
8295 salt_type = SALT_TYPE_NONE;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_LE
8298 | OPTS_TYPE_PT_UPPER
8299 | OPTS_TYPE_PT_BITSLICE;
8300 kern_type = KERN_TYPE_LM;
8301 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8302 parse_func = lm_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 1;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 3;
8310 break;
8311
8312 case 3100: hash_type = HASH_TYPE_ORACLEH;
8313 salt_type = SALT_TYPE_INTERN;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE
8316 | OPTS_TYPE_PT_UPPER
8317 | OPTS_TYPE_ST_UPPER;
8318 kern_type = KERN_TYPE_ORACLEH;
8319 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8320 parse_func = oracleh_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8322 opti_type = OPTI_TYPE_ZERO_BYTE;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 1;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 3;
8327 break;
8328
8329 case 3200: hash_type = HASH_TYPE_BCRYPT;
8330 salt_type = SALT_TYPE_EMBEDDED;
8331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_ST_GENERATE_LE;
8334 kern_type = KERN_TYPE_BCRYPT;
8335 dgst_size = DGST_SIZE_4_6;
8336 parse_func = bcrypt_parse_hash;
8337 sort_by_digest = sort_by_digest_4_6;
8338 opti_type = OPTI_TYPE_ZERO_BYTE;
8339 dgst_pos0 = 0;
8340 dgst_pos1 = 1;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 3;
8343 break;
8344
8345 case 3710: hash_type = HASH_TYPE_MD5;
8346 salt_type = SALT_TYPE_INTERN;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_LE
8349 | OPTS_TYPE_PT_ADD80
8350 | OPTS_TYPE_PT_ADDBITS14;
8351 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8352 dgst_size = DGST_SIZE_4_4;
8353 parse_func = md5s_parse_hash;
8354 sort_by_digest = sort_by_digest_4_4;
8355 opti_type = OPTI_TYPE_ZERO_BYTE
8356 | OPTI_TYPE_PRECOMPUTE_INIT
8357 | OPTI_TYPE_PRECOMPUTE_MERKLE
8358 | OPTI_TYPE_EARLY_SKIP;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 3;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 1;
8363 break;
8364
8365 case 3711: hash_type = HASH_TYPE_MD5;
8366 salt_type = SALT_TYPE_EMBEDDED;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_PT_ADD80
8370 | OPTS_TYPE_PT_ADDBITS14;
8371 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8372 dgst_size = DGST_SIZE_4_4;
8373 parse_func = mediawiki_b_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_PRECOMPUTE_MERKLE
8378 | OPTI_TYPE_EARLY_SKIP;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 3;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 1;
8383 break;
8384
8385 case 3800: hash_type = HASH_TYPE_MD5;
8386 salt_type = SALT_TYPE_INTERN;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE
8389 | OPTS_TYPE_ST_ADDBITS14;
8390 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8391 dgst_size = DGST_SIZE_4_4;
8392 parse_func = md5s_parse_hash;
8393 sort_by_digest = sort_by_digest_4_4;
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_PRECOMPUTE_INIT
8396 | OPTI_TYPE_PRECOMPUTE_MERKLE
8397 | OPTI_TYPE_EARLY_SKIP
8398 | OPTI_TYPE_NOT_ITERATED
8399 | OPTI_TYPE_RAW_HASH;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 3;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 1;
8404 break;
8405
8406 case 4300: hash_type = HASH_TYPE_MD5;
8407 salt_type = SALT_TYPE_VIRTUAL;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE
8410 | OPTS_TYPE_PT_ADD80
8411 | OPTS_TYPE_PT_ADDBITS14
8412 | OPTS_TYPE_ST_ADD80;
8413 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8414 dgst_size = DGST_SIZE_4_4;
8415 parse_func = md5md5_parse_hash;
8416 sort_by_digest = sort_by_digest_4_4;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP;
8421 dgst_pos0 = 0;
8422 dgst_pos1 = 3;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 1;
8425 break;
8426
8427
8428 case 4400: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_NONE;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_BE
8432 | OPTS_TYPE_PT_ADD80
8433 | OPTS_TYPE_PT_ADDBITS15;
8434 kern_type = KERN_TYPE_MD5_SHA1;
8435 dgst_size = DGST_SIZE_4_4;
8436 parse_func = md5_parse_hash;
8437 sort_by_digest = sort_by_digest_4_4;
8438 opti_type = OPTI_TYPE_ZERO_BYTE
8439 | OPTI_TYPE_PRECOMPUTE_INIT
8440 | OPTI_TYPE_PRECOMPUTE_MERKLE
8441 | OPTI_TYPE_EARLY_SKIP
8442 | OPTI_TYPE_NOT_ITERATED
8443 | OPTI_TYPE_NOT_SALTED
8444 | OPTI_TYPE_RAW_HASH;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 4500: hash_type = HASH_TYPE_SHA1;
8452 salt_type = SALT_TYPE_NONE;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_BE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS15;
8457 kern_type = KERN_TYPE_SHA11;
8458 dgst_size = DGST_SIZE_4_5;
8459 parse_func = sha1_parse_hash;
8460 sort_by_digest = sort_by_digest_4_5;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP
8465 | OPTI_TYPE_NOT_SALTED;
8466 dgst_pos0 = 3;
8467 dgst_pos1 = 4;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 1;
8470 break;
8471
8472 case 4700: hash_type = HASH_TYPE_SHA1;
8473 salt_type = SALT_TYPE_NONE;
8474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE
8476 | OPTS_TYPE_PT_ADD80
8477 | OPTS_TYPE_PT_ADDBITS14;
8478 kern_type = KERN_TYPE_SHA1_MD5;
8479 dgst_size = DGST_SIZE_4_5;
8480 parse_func = sha1_parse_hash;
8481 sort_by_digest = sort_by_digest_4_5;
8482 opti_type = OPTI_TYPE_ZERO_BYTE
8483 | OPTI_TYPE_PRECOMPUTE_INIT
8484 | OPTI_TYPE_PRECOMPUTE_MERKLE
8485 | OPTI_TYPE_EARLY_SKIP
8486 | OPTI_TYPE_NOT_ITERATED
8487 | OPTI_TYPE_NOT_SALTED
8488 | OPTI_TYPE_RAW_HASH;
8489 dgst_pos0 = 3;
8490 dgst_pos1 = 4;
8491 dgst_pos2 = 2;
8492 dgst_pos3 = 1;
8493 break;
8494
8495 case 4800: hash_type = HASH_TYPE_MD5;
8496 salt_type = SALT_TYPE_EMBEDDED;
8497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8498 opts_type = OPTS_TYPE_PT_GENERATE_LE
8499 | OPTS_TYPE_PT_ADDBITS14;
8500 kern_type = KERN_TYPE_MD5_CHAP;
8501 dgst_size = DGST_SIZE_4_4;
8502 parse_func = chap_parse_hash;
8503 sort_by_digest = sort_by_digest_4_4;
8504 opti_type = OPTI_TYPE_ZERO_BYTE
8505 | OPTI_TYPE_PRECOMPUTE_INIT
8506 | OPTI_TYPE_PRECOMPUTE_MERKLE
8507 | OPTI_TYPE_MEET_IN_MIDDLE
8508 | OPTI_TYPE_EARLY_SKIP
8509 | OPTI_TYPE_NOT_ITERATED
8510 | OPTI_TYPE_RAW_HASH;
8511 dgst_pos0 = 0;
8512 dgst_pos1 = 3;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 1;
8515 break;
8516
8517 case 4900: hash_type = HASH_TYPE_SHA1;
8518 salt_type = SALT_TYPE_INTERN;
8519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8521 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8522 dgst_size = DGST_SIZE_4_5;
8523 parse_func = sha1s_parse_hash;
8524 sort_by_digest = sort_by_digest_4_5;
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_PRECOMPUTE_INIT
8527 | OPTI_TYPE_PRECOMPUTE_MERKLE
8528 | OPTI_TYPE_EARLY_SKIP;
8529 dgst_pos0 = 3;
8530 dgst_pos1 = 4;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 1;
8533 break;
8534
8535 case 5000: hash_type = HASH_TYPE_KECCAK;
8536 salt_type = SALT_TYPE_EMBEDDED;
8537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_LE
8539 | OPTS_TYPE_PT_ADD01;
8540 kern_type = KERN_TYPE_KECCAK;
8541 dgst_size = DGST_SIZE_8_25;
8542 parse_func = keccak_parse_hash;
8543 sort_by_digest = sort_by_digest_8_25;
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_USES_BITS_64
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 2;
8548 dgst_pos1 = 3;
8549 dgst_pos2 = 4;
8550 dgst_pos3 = 5;
8551 break;
8552
8553 case 5100: hash_type = HASH_TYPE_MD5H;
8554 salt_type = SALT_TYPE_NONE;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_LE
8557 | OPTS_TYPE_PT_ADD80
8558 | OPTS_TYPE_PT_ADDBITS14;
8559 kern_type = KERN_TYPE_MD5H;
8560 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8561 parse_func = md5half_parse_hash;
8562 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_RAW_HASH;
8565 dgst_pos0 = 0;
8566 dgst_pos1 = 1;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 3;
8569 break;
8570
8571 case 5200: hash_type = HASH_TYPE_SHA256;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8575 kern_type = KERN_TYPE_PSAFE3;
8576 dgst_size = DGST_SIZE_4_8;
8577 parse_func = psafe3_parse_hash;
8578 sort_by_digest = sort_by_digest_4_8;
8579 opti_type = OPTI_TYPE_ZERO_BYTE;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 1;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 3;
8584 break;
8585
8586 case 5300: hash_type = HASH_TYPE_MD5;
8587 salt_type = SALT_TYPE_EMBEDDED;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE
8590 | OPTS_TYPE_ST_ADD80;
8591 kern_type = KERN_TYPE_IKEPSK_MD5;
8592 dgst_size = DGST_SIZE_4_4;
8593 parse_func = ikepsk_md5_parse_hash;
8594 sort_by_digest = sort_by_digest_4_4;
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 3;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 1;
8600 break;
8601
8602 case 5400: hash_type = HASH_TYPE_SHA1;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_BE
8606 | OPTS_TYPE_ST_ADD80;
8607 kern_type = KERN_TYPE_IKEPSK_SHA1;
8608 dgst_size = DGST_SIZE_4_5;
8609 parse_func = ikepsk_sha1_parse_hash;
8610 sort_by_digest = sort_by_digest_4_5;
8611 opti_type = OPTI_TYPE_ZERO_BYTE;
8612 dgst_pos0 = 3;
8613 dgst_pos1 = 4;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 1;
8616 break;
8617
8618 case 5500: hash_type = HASH_TYPE_NETNTLM;
8619 salt_type = SALT_TYPE_EMBEDDED;
8620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_LE
8622 | OPTS_TYPE_PT_ADD80
8623 | OPTS_TYPE_PT_ADDBITS14
8624 | OPTS_TYPE_PT_UNICODE
8625 | OPTS_TYPE_ST_HEX;
8626 kern_type = KERN_TYPE_NETNTLMv1;
8627 dgst_size = DGST_SIZE_4_4;
8628 parse_func = netntlmv1_parse_hash;
8629 sort_by_digest = sort_by_digest_4_4;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 1;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 3;
8636 break;
8637
8638 case 5600: hash_type = HASH_TYPE_MD5;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE
8642 | OPTS_TYPE_PT_ADD80
8643 | OPTS_TYPE_PT_ADDBITS14
8644 | OPTS_TYPE_PT_UNICODE;
8645 kern_type = KERN_TYPE_NETNTLMv2;
8646 dgst_size = DGST_SIZE_4_4;
8647 parse_func = netntlmv2_parse_hash;
8648 sort_by_digest = sort_by_digest_4_4;
8649 opti_type = OPTI_TYPE_ZERO_BYTE;
8650 dgst_pos0 = 0;
8651 dgst_pos1 = 3;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 1;
8654 break;
8655
8656 case 5700: hash_type = HASH_TYPE_SHA256;
8657 salt_type = SALT_TYPE_NONE;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_BE
8660 | OPTS_TYPE_PT_ADD80
8661 | OPTS_TYPE_PT_ADDBITS15;
8662 kern_type = KERN_TYPE_SHA256;
8663 dgst_size = DGST_SIZE_4_8;
8664 parse_func = cisco4_parse_hash;
8665 sort_by_digest = sort_by_digest_4_8;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_INIT
8668 | OPTI_TYPE_PRECOMPUTE_MERKLE
8669 | OPTI_TYPE_EARLY_SKIP
8670 | OPTI_TYPE_NOT_ITERATED
8671 | OPTI_TYPE_NOT_SALTED
8672 | OPTI_TYPE_RAW_HASH;
8673 dgst_pos0 = 3;
8674 dgst_pos1 = 7;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 6;
8677 break;
8678
8679 case 5800: hash_type = HASH_TYPE_SHA1;
8680 salt_type = SALT_TYPE_INTERN;
8681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8683 | OPTS_TYPE_ST_ADD80;
8684 kern_type = KERN_TYPE_ANDROIDPIN;
8685 dgst_size = DGST_SIZE_4_5;
8686 parse_func = androidpin_parse_hash;
8687 sort_by_digest = sort_by_digest_4_5;
8688 opti_type = OPTI_TYPE_ZERO_BYTE;
8689 dgst_pos0 = 0;
8690 dgst_pos1 = 1;
8691 dgst_pos2 = 2;
8692 dgst_pos3 = 3;
8693 break;
8694
8695 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8696 salt_type = SALT_TYPE_NONE;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_LE
8699 | OPTS_TYPE_PT_ADD80;
8700 kern_type = KERN_TYPE_RIPEMD160;
8701 dgst_size = DGST_SIZE_4_5;
8702 parse_func = ripemd160_parse_hash;
8703 sort_by_digest = sort_by_digest_4_5;
8704 opti_type = OPTI_TYPE_ZERO_BYTE;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 1;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 3;
8709 break;
8710
8711 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8712 salt_type = SALT_TYPE_NONE;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_BE
8715 | OPTS_TYPE_PT_ADD80;
8716 kern_type = KERN_TYPE_WHIRLPOOL;
8717 dgst_size = DGST_SIZE_4_16;
8718 parse_func = whirlpool_parse_hash;
8719 sort_by_digest = sort_by_digest_4_16;
8720 opti_type = OPTI_TYPE_ZERO_BYTE;
8721 dgst_pos0 = 0;
8722 dgst_pos1 = 1;
8723 dgst_pos2 = 2;
8724 dgst_pos3 = 3;
8725 break;
8726
8727 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8728 salt_type = SALT_TYPE_EMBEDDED;
8729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8731 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8732 dgst_size = DGST_SIZE_4_5;
8733 parse_func = truecrypt_parse_hash_2k;
8734 sort_by_digest = sort_by_digest_4_5;
8735 opti_type = OPTI_TYPE_ZERO_BYTE;
8736 dgst_pos0 = 0;
8737 dgst_pos1 = 1;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 3;
8740 break;
8741
8742 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8743 salt_type = SALT_TYPE_EMBEDDED;
8744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8746 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8747 dgst_size = DGST_SIZE_4_5;
8748 parse_func = truecrypt_parse_hash_2k;
8749 sort_by_digest = sort_by_digest_4_5;
8750 opti_type = OPTI_TYPE_ZERO_BYTE;
8751 dgst_pos0 = 0;
8752 dgst_pos1 = 1;
8753 dgst_pos2 = 2;
8754 dgst_pos3 = 3;
8755 break;
8756
8757 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8758 salt_type = SALT_TYPE_EMBEDDED;
8759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8761 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8762 dgst_size = DGST_SIZE_4_5;
8763 parse_func = truecrypt_parse_hash_2k;
8764 sort_by_digest = sort_by_digest_4_5;
8765 opti_type = OPTI_TYPE_ZERO_BYTE;
8766 dgst_pos0 = 0;
8767 dgst_pos1 = 1;
8768 dgst_pos2 = 2;
8769 dgst_pos3 = 3;
8770 break;
8771
8772 case 6221: hash_type = HASH_TYPE_SHA512;
8773 salt_type = SALT_TYPE_EMBEDDED;
8774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8775 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8776 kern_type = KERN_TYPE_TCSHA512_XTS512;
8777 dgst_size = DGST_SIZE_8_8;
8778 parse_func = truecrypt_parse_hash_1k;
8779 sort_by_digest = sort_by_digest_8_8;
8780 opti_type = OPTI_TYPE_ZERO_BYTE
8781 | OPTI_TYPE_USES_BITS_64;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 6222: hash_type = HASH_TYPE_SHA512;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8792 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8793 dgst_size = DGST_SIZE_8_8;
8794 parse_func = truecrypt_parse_hash_1k;
8795 sort_by_digest = sort_by_digest_8_8;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_USES_BITS_64;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 6223: hash_type = HASH_TYPE_SHA512;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8808 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8809 dgst_size = DGST_SIZE_8_8;
8810 parse_func = truecrypt_parse_hash_1k;
8811 sort_by_digest = sort_by_digest_8_8;
8812 opti_type = OPTI_TYPE_ZERO_BYTE
8813 | OPTI_TYPE_USES_BITS_64;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
8825 dgst_size = DGST_SIZE_4_8;
8826 parse_func = truecrypt_parse_hash_1k;
8827 sort_by_digest = sort_by_digest_4_8;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8839 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8840 dgst_size = DGST_SIZE_4_8;
8841 parse_func = truecrypt_parse_hash_1k;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8854 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8855 dgst_size = DGST_SIZE_4_8;
8856 parse_func = truecrypt_parse_hash_1k;
8857 sort_by_digest = sort_by_digest_4_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8869 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8870 dgst_size = DGST_SIZE_4_5;
8871 parse_func = truecrypt_parse_hash_1k;
8872 sort_by_digest = sort_by_digest_4_5;
8873 opti_type = OPTI_TYPE_ZERO_BYTE;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8885 dgst_size = DGST_SIZE_4_5;
8886 parse_func = truecrypt_parse_hash_1k;
8887 sort_by_digest = sort_by_digest_4_5;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8899 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = truecrypt_parse_hash_1k;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6300: hash_type = HASH_TYPE_MD5;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8914 kern_type = KERN_TYPE_MD5AIX;
8915 dgst_size = DGST_SIZE_4_4;
8916 parse_func = md5aix_parse_hash;
8917 sort_by_digest = sort_by_digest_4_4;
8918 opti_type = OPTI_TYPE_ZERO_BYTE;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 6400: hash_type = HASH_TYPE_SHA256;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8929 kern_type = KERN_TYPE_SHA256AIX;
8930 dgst_size = DGST_SIZE_4_8;
8931 parse_func = sha256aix_parse_hash;
8932 sort_by_digest = sort_by_digest_4_8;
8933 opti_type = OPTI_TYPE_ZERO_BYTE;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 1;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 3;
8938 break;
8939
8940 case 6500: hash_type = HASH_TYPE_SHA512;
8941 salt_type = SALT_TYPE_EMBEDDED;
8942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8944 kern_type = KERN_TYPE_SHA512AIX;
8945 dgst_size = DGST_SIZE_8_8;
8946 parse_func = sha512aix_parse_hash;
8947 sort_by_digest = sort_by_digest_8_8;
8948 opti_type = OPTI_TYPE_ZERO_BYTE
8949 | OPTI_TYPE_USES_BITS_64;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6600: hash_type = HASH_TYPE_AES;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_AGILEKEY;
8961 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8962 parse_func = agilekey_parse_hash;
8963 sort_by_digest = sort_by_digest_4_5;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6700: hash_type = HASH_TYPE_SHA1;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8975 kern_type = KERN_TYPE_SHA1AIX;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = sha1aix_parse_hash;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6800: hash_type = HASH_TYPE_AES;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8990 kern_type = KERN_TYPE_LASTPASS;
8991 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8992 parse_func = lastpass_parse_hash;
8993 sort_by_digest = sort_by_digest_4_8;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6900: hash_type = HASH_TYPE_GOST;
9002 salt_type = SALT_TYPE_NONE;
9003 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9005 kern_type = KERN_TYPE_GOST;
9006 dgst_size = DGST_SIZE_4_8;
9007 parse_func = gost_parse_hash;
9008 sort_by_digest = sort_by_digest_4_8;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 7100: hash_type = HASH_TYPE_SHA512;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9020 kern_type = KERN_TYPE_PBKDF2_SHA512;
9021 dgst_size = DGST_SIZE_8_16;
9022 parse_func = sha512osx_parse_hash;
9023 sort_by_digest = sort_by_digest_8_16;
9024 opti_type = OPTI_TYPE_ZERO_BYTE
9025 | OPTI_TYPE_USES_BITS_64;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 1;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 3;
9030 break;
9031
9032 case 7200: hash_type = HASH_TYPE_SHA512;
9033 salt_type = SALT_TYPE_EMBEDDED;
9034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9036 kern_type = KERN_TYPE_PBKDF2_SHA512;
9037 dgst_size = DGST_SIZE_8_16;
9038 parse_func = sha512grub_parse_hash;
9039 sort_by_digest = sort_by_digest_8_16;
9040 opti_type = OPTI_TYPE_ZERO_BYTE
9041 | OPTI_TYPE_USES_BITS_64;
9042 dgst_pos0 = 0;
9043 dgst_pos1 = 1;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 3;
9046 break;
9047
9048 case 7300: hash_type = HASH_TYPE_SHA1;
9049 salt_type = SALT_TYPE_EMBEDDED;
9050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_BE
9052 | OPTS_TYPE_ST_ADD80
9053 | OPTS_TYPE_ST_ADDBITS15;
9054 kern_type = KERN_TYPE_RAKP;
9055 dgst_size = DGST_SIZE_4_5;
9056 parse_func = rakp_parse_hash;
9057 sort_by_digest = sort_by_digest_4_5;
9058 opti_type = OPTI_TYPE_ZERO_BYTE
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 7400: hash_type = HASH_TYPE_SHA256;
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_SHA256CRYPT;
9071 dgst_size = DGST_SIZE_4_8;
9072 parse_func = sha256crypt_parse_hash;
9073 sort_by_digest = sort_by_digest_4_8;
9074 opti_type = OPTI_TYPE_ZERO_BYTE;
9075 dgst_pos0 = 0;
9076 dgst_pos1 = 1;
9077 dgst_pos2 = 2;
9078 dgst_pos3 = 3;
9079 break;
9080
9081 case 7500: hash_type = HASH_TYPE_KRB5PA;
9082 salt_type = SALT_TYPE_EMBEDDED;
9083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9085 kern_type = KERN_TYPE_KRB5PA;
9086 dgst_size = DGST_SIZE_4_4;
9087 parse_func = krb5pa_parse_hash;
9088 sort_by_digest = sort_by_digest_4_4;
9089 opti_type = OPTI_TYPE_ZERO_BYTE
9090 | OPTI_TYPE_NOT_ITERATED;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 7600: hash_type = HASH_TYPE_SHA1;
9098 salt_type = SALT_TYPE_INTERN;
9099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_BE
9101 | OPTS_TYPE_PT_ADD80
9102 | OPTS_TYPE_PT_ADDBITS15;
9103 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9104 dgst_size = DGST_SIZE_4_5;
9105 parse_func = redmine_parse_hash;
9106 sort_by_digest = sort_by_digest_4_5;
9107 opti_type = OPTI_TYPE_ZERO_BYTE
9108 | OPTI_TYPE_PRECOMPUTE_INIT
9109 | OPTI_TYPE_EARLY_SKIP
9110 | OPTI_TYPE_NOT_ITERATED
9111 | OPTI_TYPE_PREPENDED_SALT;
9112 dgst_pos0 = 3;
9113 dgst_pos1 = 4;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 1;
9116 break;
9117
9118 case 7700: hash_type = HASH_TYPE_SAPB;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE
9122 | OPTS_TYPE_PT_UPPER
9123 | OPTS_TYPE_ST_UPPER;
9124 kern_type = KERN_TYPE_SAPB;
9125 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9126 parse_func = sapb_parse_hash;
9127 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9128 opti_type = OPTI_TYPE_ZERO_BYTE
9129 | OPTI_TYPE_PRECOMPUTE_INIT
9130 | OPTI_TYPE_NOT_ITERATED;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 7800: hash_type = HASH_TYPE_SAPG;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_BE
9141 | OPTS_TYPE_ST_ADD80
9142 | OPTS_TYPE_ST_UPPER;
9143 kern_type = KERN_TYPE_SAPG;
9144 dgst_size = DGST_SIZE_4_5;
9145 parse_func = sapg_parse_hash;
9146 sort_by_digest = sort_by_digest_4_5;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_PRECOMPUTE_INIT
9149 | OPTI_TYPE_NOT_ITERATED;
9150 dgst_pos0 = 3;
9151 dgst_pos1 = 4;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 1;
9154 break;
9155
9156 case 7900: hash_type = HASH_TYPE_SHA512;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9160 kern_type = KERN_TYPE_DRUPAL7;
9161 dgst_size = DGST_SIZE_8_8;
9162 parse_func = drupal7_parse_hash;
9163 sort_by_digest = sort_by_digest_8_8;
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_USES_BITS_64;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 8000: hash_type = HASH_TYPE_SHA256;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_BE
9176 | OPTS_TYPE_PT_UNICODE
9177 | OPTS_TYPE_ST_ADD80
9178 | OPTS_TYPE_ST_HEX;
9179 kern_type = KERN_TYPE_SYBASEASE;
9180 dgst_size = DGST_SIZE_4_8;
9181 parse_func = sybasease_parse_hash;
9182 sort_by_digest = sort_by_digest_4_8;
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_INIT
9185 | OPTI_TYPE_EARLY_SKIP
9186 | OPTI_TYPE_NOT_ITERATED
9187 | OPTI_TYPE_RAW_HASH;
9188 dgst_pos0 = 3;
9189 dgst_pos1 = 7;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 6;
9192 break;
9193
9194 case 8100: hash_type = HASH_TYPE_SHA1;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9198 kern_type = KERN_TYPE_NETSCALER;
9199 dgst_size = DGST_SIZE_4_5;
9200 parse_func = netscaler_parse_hash;
9201 sort_by_digest = sort_by_digest_4_5;
9202 opti_type = OPTI_TYPE_ZERO_BYTE
9203 | OPTI_TYPE_PRECOMPUTE_INIT
9204 | OPTI_TYPE_PRECOMPUTE_MERKLE
9205 | OPTI_TYPE_EARLY_SKIP
9206 | OPTI_TYPE_NOT_ITERATED
9207 | OPTI_TYPE_PREPENDED_SALT
9208 | OPTI_TYPE_RAW_HASH;
9209 dgst_pos0 = 3;
9210 dgst_pos1 = 4;
9211 dgst_pos2 = 2;
9212 dgst_pos3 = 1;
9213 break;
9214
9215 case 8200: hash_type = HASH_TYPE_SHA256;
9216 salt_type = SALT_TYPE_EMBEDDED;
9217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9219 kern_type = KERN_TYPE_CLOUDKEY;
9220 dgst_size = DGST_SIZE_4_8;
9221 parse_func = cloudkey_parse_hash;
9222 sort_by_digest = sort_by_digest_4_8;
9223 opti_type = OPTI_TYPE_ZERO_BYTE;
9224 dgst_pos0 = 0;
9225 dgst_pos1 = 1;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 3;
9228 break;
9229
9230 case 8300: hash_type = HASH_TYPE_SHA1;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_LE
9234 | OPTS_TYPE_ST_HEX
9235 | OPTS_TYPE_ST_ADD80;
9236 kern_type = KERN_TYPE_NSEC3;
9237 dgst_size = DGST_SIZE_4_5;
9238 parse_func = nsec3_parse_hash;
9239 sort_by_digest = sort_by_digest_4_5;
9240 opti_type = OPTI_TYPE_ZERO_BYTE;
9241 dgst_pos0 = 3;
9242 dgst_pos1 = 4;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 1;
9245 break;
9246
9247 case 8400: hash_type = HASH_TYPE_SHA1;
9248 salt_type = SALT_TYPE_INTERN;
9249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_BE
9251 | OPTS_TYPE_PT_ADD80
9252 | OPTS_TYPE_PT_ADDBITS15;
9253 kern_type = KERN_TYPE_WBB3;
9254 dgst_size = DGST_SIZE_4_5;
9255 parse_func = wbb3_parse_hash;
9256 sort_by_digest = sort_by_digest_4_5;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_PRECOMPUTE_INIT
9259 | OPTI_TYPE_NOT_ITERATED;
9260 dgst_pos0 = 3;
9261 dgst_pos1 = 4;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 1;
9264 break;
9265
9266 case 8500: hash_type = HASH_TYPE_DESRACF;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE
9270 | OPTS_TYPE_ST_UPPER;
9271 kern_type = KERN_TYPE_RACF;
9272 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9273 parse_func = racf_parse_hash;
9274 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9277 dgst_pos0 = 0;
9278 dgst_pos1 = 1;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 3;
9281 break;
9282
9283 case 8600: hash_type = HASH_TYPE_LOTUS5;
9284 salt_type = SALT_TYPE_NONE;
9285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9287 kern_type = KERN_TYPE_LOTUS5;
9288 dgst_size = DGST_SIZE_4_4;
9289 parse_func = lotus5_parse_hash;
9290 sort_by_digest = sort_by_digest_4_4;
9291 opti_type = OPTI_TYPE_EARLY_SKIP
9292 | OPTI_TYPE_NOT_ITERATED
9293 | OPTI_TYPE_NOT_SALTED
9294 | OPTI_TYPE_RAW_HASH;
9295 dgst_pos0 = 0;
9296 dgst_pos1 = 1;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 3;
9299 break;
9300
9301 case 8700: hash_type = HASH_TYPE_LOTUS6;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9305 kern_type = KERN_TYPE_LOTUS6;
9306 dgst_size = DGST_SIZE_4_4;
9307 parse_func = lotus6_parse_hash;
9308 sort_by_digest = sort_by_digest_4_4;
9309 opti_type = OPTI_TYPE_EARLY_SKIP
9310 | OPTI_TYPE_NOT_ITERATED
9311 | OPTI_TYPE_RAW_HASH;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_ANDROIDFDE;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = androidfde_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 8900: hash_type = HASH_TYPE_SCRYPT;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9337 kern_type = KERN_TYPE_SCRYPT;
9338 dgst_size = DGST_SIZE_4_8;
9339 parse_func = scrypt_parse_hash;
9340 sort_by_digest = sort_by_digest_4_8;
9341 opti_type = OPTI_TYPE_ZERO_BYTE;
9342 dgst_pos0 = 0;
9343 dgst_pos1 = 1;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 3;
9346 break;
9347
9348 case 9000: hash_type = HASH_TYPE_SHA1;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_LE
9352 | OPTS_TYPE_ST_GENERATE_LE;
9353 kern_type = KERN_TYPE_PSAFE2;
9354 dgst_size = DGST_SIZE_4_5;
9355 parse_func = psafe2_parse_hash;
9356 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9368 kern_type = KERN_TYPE_LOTUS8;
9369 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9370 parse_func = lotus8_parse_hash;
9371 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9372 opti_type = OPTI_TYPE_ZERO_BYTE;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 9200: hash_type = HASH_TYPE_SHA256;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9383 kern_type = KERN_TYPE_PBKDF2_SHA256;
9384 dgst_size = DGST_SIZE_4_32;
9385 parse_func = cisco8_parse_hash;
9386 sort_by_digest = sort_by_digest_4_32;
9387 opti_type = OPTI_TYPE_ZERO_BYTE;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 9300: hash_type = HASH_TYPE_SCRYPT;
9395 salt_type = SALT_TYPE_EMBEDDED;
9396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9398 kern_type = KERN_TYPE_SCRYPT;
9399 dgst_size = DGST_SIZE_4_8;
9400 parse_func = cisco9_parse_hash;
9401 sort_by_digest = sort_by_digest_4_8;
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_OFFICE2007;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = office2007_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_OFFICE2010;
9429 dgst_size = DGST_SIZE_4_4;
9430 parse_func = office2010_parse_hash;
9431 sort_by_digest = sort_by_digest_4_4;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9443 kern_type = KERN_TYPE_OFFICE2013;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = office2013_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE
9458 | OPTS_TYPE_PT_ADD80
9459 | OPTS_TYPE_PT_UNICODE;
9460 kern_type = KERN_TYPE_OLDOFFICE01;
9461 dgst_size = DGST_SIZE_4_4;
9462 parse_func = oldoffice01_parse_hash;
9463 sort_by_digest = sort_by_digest_4_4;
9464 opti_type = OPTI_TYPE_ZERO_BYTE
9465 | OPTI_TYPE_PRECOMPUTE_INIT
9466 | OPTI_TYPE_NOT_ITERATED;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_LE
9477 | OPTS_TYPE_PT_ADD80;
9478 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9479 dgst_size = DGST_SIZE_4_4;
9480 parse_func = oldoffice01cm1_parse_hash;
9481 sort_by_digest = sort_by_digest_4_4;
9482 opti_type = OPTI_TYPE_ZERO_BYTE
9483 | OPTI_TYPE_PRECOMPUTE_INIT
9484 | OPTI_TYPE_NOT_ITERATED;
9485 dgst_pos0 = 0;
9486 dgst_pos1 = 1;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 3;
9489 break;
9490
9491 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_LE
9495 | OPTS_TYPE_PT_ADD80
9496 | OPTS_TYPE_PT_UNICODE
9497 | OPTS_TYPE_PT_NEVERCRACK;
9498 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9499 dgst_size = DGST_SIZE_4_4;
9500 parse_func = oldoffice01cm2_parse_hash;
9501 sort_by_digest = sort_by_digest_4_4;
9502 opti_type = OPTI_TYPE_ZERO_BYTE
9503 | OPTI_TYPE_PRECOMPUTE_INIT
9504 | OPTI_TYPE_NOT_ITERATED;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_BE
9515 | OPTS_TYPE_PT_ADD80
9516 | OPTS_TYPE_PT_UNICODE;
9517 kern_type = KERN_TYPE_OLDOFFICE34;
9518 dgst_size = DGST_SIZE_4_4;
9519 parse_func = oldoffice34_parse_hash;
9520 sort_by_digest = sort_by_digest_4_4;
9521 opti_type = OPTI_TYPE_ZERO_BYTE
9522 | OPTI_TYPE_PRECOMPUTE_INIT
9523 | OPTI_TYPE_NOT_ITERATED;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9531 salt_type = SALT_TYPE_EMBEDDED;
9532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9534 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = oldoffice34cm1_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_PRECOMPUTE_INIT
9540 | OPTI_TYPE_NOT_ITERATED;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_BE
9551 | OPTS_TYPE_PT_ADD80
9552 | OPTS_TYPE_PT_UNICODE
9553 | OPTS_TYPE_PT_NEVERCRACK;
9554 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9555 dgst_size = DGST_SIZE_4_4;
9556 parse_func = oldoffice34cm2_parse_hash;
9557 sort_by_digest = sort_by_digest_4_4;
9558 opti_type = OPTI_TYPE_ZERO_BYTE
9559 | OPTI_TYPE_PRECOMPUTE_INIT
9560 | OPTI_TYPE_NOT_ITERATED;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 9900: hash_type = HASH_TYPE_MD5;
9568 salt_type = SALT_TYPE_NONE;
9569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9570 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9571 kern_type = KERN_TYPE_RADMIN2;
9572 dgst_size = DGST_SIZE_4_4;
9573 parse_func = radmin2_parse_hash;
9574 sort_by_digest = sort_by_digest_4_4;
9575 opti_type = OPTI_TYPE_ZERO_BYTE
9576 | OPTI_TYPE_PRECOMPUTE_INIT
9577 | OPTI_TYPE_EARLY_SKIP
9578 | OPTI_TYPE_NOT_ITERATED
9579 | OPTI_TYPE_NOT_SALTED;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 3;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 1;
9584 break;
9585
9586 case 10000: hash_type = HASH_TYPE_SHA256;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9590 kern_type = KERN_TYPE_PBKDF2_SHA256;
9591 dgst_size = DGST_SIZE_4_32;
9592 parse_func = djangopbkdf2_parse_hash;
9593 sort_by_digest = sort_by_digest_4_32;
9594 opti_type = OPTI_TYPE_ZERO_BYTE;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 10100: hash_type = HASH_TYPE_SIPHASH;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_SIPHASH;
9606 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9607 parse_func = siphash_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9609 opti_type = OPTI_TYPE_ZERO_BYTE
9610 | OPTI_TYPE_NOT_ITERATED
9611 | OPTI_TYPE_RAW_HASH;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 10200: hash_type = HASH_TYPE_MD5;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE
9622 | OPTS_TYPE_ST_ADD80
9623 | OPTS_TYPE_ST_ADDBITS14;
9624 kern_type = KERN_TYPE_HMACMD5_PW;
9625 dgst_size = DGST_SIZE_4_4;
9626 parse_func = crammd5_parse_hash;
9627 sort_by_digest = sort_by_digest_4_4;
9628 opti_type = OPTI_TYPE_ZERO_BYTE
9629 | OPTI_TYPE_NOT_ITERATED;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 3;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 1;
9634 break;
9635
9636 case 10300: hash_type = HASH_TYPE_SHA1;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9640 kern_type = KERN_TYPE_SAPH_SHA1;
9641 dgst_size = DGST_SIZE_4_5;
9642 parse_func = saph_sha1_parse_hash;
9643 sort_by_digest = sort_by_digest_4_5;
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 10400: hash_type = HASH_TYPE_PDFU16;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_PDF11;
9656 dgst_size = DGST_SIZE_4_4;
9657 parse_func = pdf11_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_NOT_ITERATED;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 10410: hash_type = HASH_TYPE_PDFU16;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9671 kern_type = KERN_TYPE_PDF11CM1;
9672 dgst_size = DGST_SIZE_4_4;
9673 parse_func = pdf11cm1_parse_hash;
9674 sort_by_digest = sort_by_digest_4_4;
9675 opti_type = OPTI_TYPE_ZERO_BYTE
9676 | OPTI_TYPE_NOT_ITERATED;
9677 dgst_pos0 = 0;
9678 dgst_pos1 = 1;
9679 dgst_pos2 = 2;
9680 dgst_pos3 = 3;
9681 break;
9682
9683 case 10420: hash_type = HASH_TYPE_PDFU16;
9684 salt_type = SALT_TYPE_EMBEDDED;
9685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9686 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9687 kern_type = KERN_TYPE_PDF11CM2;
9688 dgst_size = DGST_SIZE_4_4;
9689 parse_func = pdf11cm2_parse_hash;
9690 sort_by_digest = sort_by_digest_4_4;
9691 opti_type = OPTI_TYPE_ZERO_BYTE
9692 | OPTI_TYPE_NOT_ITERATED;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 10500: hash_type = HASH_TYPE_PDFU16;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_PDF14;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = pdf14_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 10600: hash_type = HASH_TYPE_SHA256;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_BE
9719 | OPTS_TYPE_ST_ADD80
9720 | OPTS_TYPE_ST_ADDBITS15
9721 | OPTS_TYPE_HASH_COPY;
9722 kern_type = KERN_TYPE_SHA256_PWSLT;
9723 dgst_size = DGST_SIZE_4_8;
9724 parse_func = pdf17l3_parse_hash;
9725 sort_by_digest = sort_by_digest_4_8;
9726 opti_type = OPTI_TYPE_ZERO_BYTE
9727 | OPTI_TYPE_PRECOMPUTE_INIT
9728 | OPTI_TYPE_PRECOMPUTE_MERKLE
9729 | OPTI_TYPE_EARLY_SKIP
9730 | OPTI_TYPE_NOT_ITERATED
9731 | OPTI_TYPE_APPENDED_SALT
9732 | OPTI_TYPE_RAW_HASH;
9733 dgst_pos0 = 3;
9734 dgst_pos1 = 7;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 6;
9737 break;
9738
9739 case 10700: hash_type = HASH_TYPE_PDFU32;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_HASH_COPY;
9744 kern_type = KERN_TYPE_PDF17L8;
9745 dgst_size = DGST_SIZE_4_8;
9746 parse_func = pdf17l8_parse_hash;
9747 sort_by_digest = sort_by_digest_4_8;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_NOT_ITERATED;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 10800: hash_type = HASH_TYPE_SHA384;
9757 salt_type = SALT_TYPE_NONE;
9758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_BE
9760 | OPTS_TYPE_PT_ADD80
9761 | OPTS_TYPE_PT_ADDBITS15;
9762 kern_type = KERN_TYPE_SHA384;
9763 dgst_size = DGST_SIZE_8_8;
9764 parse_func = sha384_parse_hash;
9765 sort_by_digest = sort_by_digest_8_8;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_PRECOMPUTE_INIT
9768 | OPTI_TYPE_PRECOMPUTE_MERKLE
9769 | OPTI_TYPE_EARLY_SKIP
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_NOT_SALTED
9772 | OPTI_TYPE_USES_BITS_64
9773 | OPTI_TYPE_RAW_HASH;
9774 dgst_pos0 = 6;
9775 dgst_pos1 = 7;
9776 dgst_pos2 = 4;
9777 dgst_pos3 = 5;
9778 break;
9779
9780 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9781 salt_type = SALT_TYPE_EMBEDDED;
9782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_LE
9784 | OPTS_TYPE_ST_BASE64
9785 | OPTS_TYPE_HASH_COPY;
9786 kern_type = KERN_TYPE_PBKDF2_SHA256;
9787 dgst_size = DGST_SIZE_4_32;
9788 parse_func = pbkdf2_sha256_parse_hash;
9789 sort_by_digest = sort_by_digest_4_32;
9790 opti_type = OPTI_TYPE_ZERO_BYTE;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 1;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 3;
9795 break;
9796
9797 case 11000: hash_type = HASH_TYPE_MD5;
9798 salt_type = SALT_TYPE_INTERN;
9799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE
9801 | OPTS_TYPE_PT_ADD80;
9802 kern_type = KERN_TYPE_PRESTASHOP;
9803 dgst_size = DGST_SIZE_4_4;
9804 parse_func = prestashop_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_PRECOMPUTE_INIT
9808 | OPTI_TYPE_NOT_ITERATED
9809 | OPTI_TYPE_PREPENDED_SALT;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 3;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 1;
9814 break;
9815
9816 case 11100: hash_type = HASH_TYPE_MD5;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE
9820 | OPTS_TYPE_ST_ADD80;
9821 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9822 dgst_size = DGST_SIZE_4_4;
9823 parse_func = postgresql_auth_parse_hash;
9824 sort_by_digest = sort_by_digest_4_4;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_PRECOMPUTE_INIT
9827 | OPTI_TYPE_PRECOMPUTE_MERKLE
9828 | OPTI_TYPE_EARLY_SKIP;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 3;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 1;
9833 break;
9834
9835 case 11200: hash_type = HASH_TYPE_SHA1;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_BE
9839 | OPTS_TYPE_PT_ADD80
9840 | OPTS_TYPE_ST_HEX;
9841 kern_type = KERN_TYPE_MYSQL_AUTH;
9842 dgst_size = DGST_SIZE_4_5;
9843 parse_func = mysql_auth_parse_hash;
9844 sort_by_digest = sort_by_digest_4_5;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_EARLY_SKIP;
9847 dgst_pos0 = 3;
9848 dgst_pos1 = 4;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 1;
9851 break;
9852
9853 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9854 salt_type = SALT_TYPE_EMBEDDED;
9855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_LE
9857 | OPTS_TYPE_ST_HEX
9858 | OPTS_TYPE_ST_ADD80;
9859 kern_type = KERN_TYPE_BITCOIN_WALLET;
9860 dgst_size = DGST_SIZE_4_4;
9861 parse_func = bitcoin_wallet_parse_hash;
9862 sort_by_digest = sort_by_digest_4_4;
9863 opti_type = OPTI_TYPE_ZERO_BYTE;
9864 dgst_pos0 = 0;
9865 dgst_pos1 = 1;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 3;
9868 break;
9869
9870 case 11400: hash_type = HASH_TYPE_MD5;
9871 salt_type = SALT_TYPE_EMBEDDED;
9872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE
9874 | OPTS_TYPE_PT_ADD80
9875 | OPTS_TYPE_HASH_COPY;
9876 kern_type = KERN_TYPE_SIP_AUTH;
9877 dgst_size = DGST_SIZE_4_4;
9878 parse_func = sip_auth_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4;
9880 opti_type = OPTI_TYPE_ZERO_BYTE;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 3;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 1;
9885 break;
9886
9887 case 11500: hash_type = HASH_TYPE_CRC32;
9888 salt_type = SALT_TYPE_INTERN;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE
9891 | OPTS_TYPE_ST_GENERATE_LE
9892 | OPTS_TYPE_ST_HEX;
9893 kern_type = KERN_TYPE_CRC32;
9894 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9895 parse_func = crc32_parse_hash;
9896 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9897 opti_type = OPTI_TYPE_ZERO_BYTE;
9898 dgst_pos0 = 0;
9899 dgst_pos1 = 1;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 3;
9902 break;
9903
9904 case 11600: hash_type = HASH_TYPE_AES;
9905 salt_type = SALT_TYPE_EMBEDDED;
9906 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_LE
9908 | OPTS_TYPE_PT_NEVERCRACK;
9909 kern_type = KERN_TYPE_SEVEN_ZIP;
9910 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9911 parse_func = seven_zip_parse_hash;
9912 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9913 opti_type = OPTI_TYPE_ZERO_BYTE;
9914 dgst_pos0 = 0;
9915 dgst_pos1 = 1;
9916 dgst_pos2 = 2;
9917 dgst_pos3 = 3;
9918 break;
9919
9920 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9921 salt_type = SALT_TYPE_NONE;
9922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9923 opts_type = OPTS_TYPE_PT_GENERATE_LE
9924 | OPTS_TYPE_PT_ADD01;
9925 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9926 dgst_size = DGST_SIZE_4_8;
9927 parse_func = gost2012sbog_256_parse_hash;
9928 sort_by_digest = sort_by_digest_4_8;
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9937 salt_type = SALT_TYPE_NONE;
9938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE
9940 | OPTS_TYPE_PT_ADD01;
9941 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9942 dgst_size = DGST_SIZE_4_16;
9943 parse_func = gost2012sbog_512_parse_hash;
9944 sort_by_digest = sort_by_digest_4_16;
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_ST_BASE64
9957 | OPTS_TYPE_HASH_COPY;
9958 kern_type = KERN_TYPE_PBKDF2_MD5;
9959 dgst_size = DGST_SIZE_4_32;
9960 parse_func = pbkdf2_md5_parse_hash;
9961 sort_by_digest = sort_by_digest_4_32;
9962 opti_type = OPTI_TYPE_ZERO_BYTE;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE
9973 | OPTS_TYPE_ST_BASE64
9974 | OPTS_TYPE_HASH_COPY;
9975 kern_type = KERN_TYPE_PBKDF2_SHA1;
9976 dgst_size = DGST_SIZE_4_32;
9977 parse_func = pbkdf2_sha1_parse_hash;
9978 sort_by_digest = sort_by_digest_4_32;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_BASE64
9991 | OPTS_TYPE_HASH_COPY;
9992 kern_type = KERN_TYPE_PBKDF2_SHA512;
9993 dgst_size = DGST_SIZE_8_16;
9994 parse_func = pbkdf2_sha512_parse_hash;
9995 sort_by_digest = sort_by_digest_8_16;
9996 opti_type = OPTI_TYPE_ZERO_BYTE
9997 | OPTI_TYPE_USES_BITS_64;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10005 salt_type = SALT_TYPE_EMBEDDED;
10006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10008 kern_type = KERN_TYPE_ECRYPTFS;
10009 dgst_size = DGST_SIZE_8_8;
10010 parse_func = ecryptfs_parse_hash;
10011 sort_by_digest = sort_by_digest_8_8;
10012 opti_type = OPTI_TYPE_ZERO_BYTE
10013 | OPTI_TYPE_USES_BITS_64;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 12300: hash_type = HASH_TYPE_ORACLET;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10024 kern_type = KERN_TYPE_ORACLET;
10025 dgst_size = DGST_SIZE_8_16;
10026 parse_func = oraclet_parse_hash;
10027 sort_by_digest = sort_by_digest_8_16;
10028 opti_type = OPTI_TYPE_ZERO_BYTE
10029 | OPTI_TYPE_USES_BITS_64;
10030 dgst_pos0 = 0;
10031 dgst_pos1 = 1;
10032 dgst_pos2 = 2;
10033 dgst_pos3 = 3;
10034 break;
10035
10036 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10037 salt_type = SALT_TYPE_EMBEDDED;
10038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10040 kern_type = KERN_TYPE_BSDICRYPT;
10041 dgst_size = DGST_SIZE_4_4;
10042 parse_func = bsdicrypt_parse_hash;
10043 sort_by_digest = sort_by_digest_4_4;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 12500: hash_type = HASH_TYPE_RAR3HP;
10053 salt_type = SALT_TYPE_EMBEDDED;
10054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10056 kern_type = KERN_TYPE_RAR3;
10057 dgst_size = DGST_SIZE_4_4;
10058 parse_func = rar3hp_parse_hash;
10059 sort_by_digest = sort_by_digest_4_4;
10060 opti_type = OPTI_TYPE_ZERO_BYTE;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 12600: hash_type = HASH_TYPE_SHA256;
10068 salt_type = SALT_TYPE_INTERN;
10069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_BE
10071 | OPTS_TYPE_PT_ADD80;
10072 kern_type = KERN_TYPE_CF10;
10073 dgst_size = DGST_SIZE_4_8;
10074 parse_func = cf10_parse_hash;
10075 sort_by_digest = sort_by_digest_4_8;
10076 opti_type = OPTI_TYPE_ZERO_BYTE
10077 | OPTI_TYPE_PRECOMPUTE_INIT
10078 | OPTI_TYPE_EARLY_SKIP
10079 | OPTI_TYPE_NOT_ITERATED;
10080 dgst_pos0 = 3;
10081 dgst_pos1 = 7;
10082 dgst_pos2 = 2;
10083 dgst_pos3 = 6;
10084 break;
10085
10086 case 12700: hash_type = HASH_TYPE_AES;
10087 salt_type = SALT_TYPE_EMBEDDED;
10088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10089 opts_type = OPTS_TYPE_PT_GENERATE_LE
10090 | OPTS_TYPE_HASH_COPY;
10091 kern_type = KERN_TYPE_MYWALLET;
10092 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10093 parse_func = mywallet_parse_hash;
10094 sort_by_digest = sort_by_digest_4_5;
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10106 kern_type = KERN_TYPE_MS_DRSR;
10107 dgst_size = DGST_SIZE_4_8;
10108 parse_func = ms_drsr_parse_hash;
10109 sort_by_digest = sort_by_digest_4_8;
10110 opti_type = OPTI_TYPE_ZERO_BYTE;
10111 dgst_pos0 = 0;
10112 dgst_pos1 = 1;
10113 dgst_pos2 = 2;
10114 dgst_pos3 = 3;
10115 break;
10116
10117 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10118 salt_type = SALT_TYPE_EMBEDDED;
10119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10121 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10122 dgst_size = DGST_SIZE_4_8;
10123 parse_func = androidfde_samsung_parse_hash;
10124 sort_by_digest = sort_by_digest_4_8;
10125 opti_type = OPTI_TYPE_ZERO_BYTE;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10136 kern_type = KERN_TYPE_RAR5;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = rar5_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE;
10141 dgst_pos0 = 0;
10142 dgst_pos1 = 1;
10143 dgst_pos2 = 2;
10144 dgst_pos3 = 3;
10145 break;
10146
10147 default: usage_mini_print (PROGNAME); return (-1);
10148 }
10149
10150 /**
10151 * transpose
10152 */
10153
10154 data.parse_func = parse_func;
10155
10156 /**
10157 * misc stuff
10158 */
10159
10160 if (hex_salt)
10161 {
10162 if (salt_type == SALT_TYPE_INTERN)
10163 {
10164 opts_type |= OPTS_TYPE_ST_HEX;
10165 }
10166 else
10167 {
10168 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10169
10170 return (-1);
10171 }
10172 }
10173
10174 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10175 | (salt_type == SALT_TYPE_EXTERN)
10176 | (salt_type == SALT_TYPE_EMBEDDED)
10177 | (salt_type == SALT_TYPE_VIRTUAL));
10178
10179 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10180
10181 data.hash_type = hash_type;
10182 data.attack_mode = attack_mode;
10183 data.attack_kern = attack_kern;
10184 data.attack_exec = attack_exec;
10185 data.kern_type = kern_type;
10186 data.opts_type = opts_type;
10187 data.dgst_size = dgst_size;
10188 data.salt_type = salt_type;
10189 data.isSalted = isSalted;
10190 data.sort_by_digest = sort_by_digest;
10191 data.dgst_pos0 = dgst_pos0;
10192 data.dgst_pos1 = dgst_pos1;
10193 data.dgst_pos2 = dgst_pos2;
10194 data.dgst_pos3 = dgst_pos3;
10195
10196 esalt_size = 0;
10197
10198 switch (hash_mode)
10199 {
10200 case 2500: esalt_size = sizeof (wpa_t); break;
10201 case 5300: esalt_size = sizeof (ikepsk_t); break;
10202 case 5400: esalt_size = sizeof (ikepsk_t); break;
10203 case 5500: esalt_size = sizeof (netntlm_t); break;
10204 case 5600: esalt_size = sizeof (netntlm_t); break;
10205 case 6211: esalt_size = sizeof (tc_t); break;
10206 case 6212: esalt_size = sizeof (tc_t); break;
10207 case 6213: esalt_size = sizeof (tc_t); break;
10208 case 6221: esalt_size = sizeof (tc_t); break;
10209 case 6222: esalt_size = sizeof (tc_t); break;
10210 case 6223: esalt_size = sizeof (tc_t); break;
10211 case 6231: esalt_size = sizeof (tc_t); break;
10212 case 6232: esalt_size = sizeof (tc_t); break;
10213 case 6233: esalt_size = sizeof (tc_t); break;
10214 case 6241: esalt_size = sizeof (tc_t); break;
10215 case 6242: esalt_size = sizeof (tc_t); break;
10216 case 6243: esalt_size = sizeof (tc_t); break;
10217 case 6600: esalt_size = sizeof (agilekey_t); break;
10218 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10219 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10220 case 7300: esalt_size = sizeof (rakp_t); break;
10221 case 7500: esalt_size = sizeof (krb5pa_t); break;
10222 case 8200: esalt_size = sizeof (cloudkey_t); break;
10223 case 8800: esalt_size = sizeof (androidfde_t); break;
10224 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10225 case 9400: esalt_size = sizeof (office2007_t); break;
10226 case 9500: esalt_size = sizeof (office2010_t); break;
10227 case 9600: esalt_size = sizeof (office2013_t); break;
10228 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10229 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10230 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10231 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10232 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10233 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10234 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10235 case 10200: esalt_size = sizeof (cram_md5_t); break;
10236 case 10400: esalt_size = sizeof (pdf_t); break;
10237 case 10410: esalt_size = sizeof (pdf_t); break;
10238 case 10420: esalt_size = sizeof (pdf_t); break;
10239 case 10500: esalt_size = sizeof (pdf_t); break;
10240 case 10600: esalt_size = sizeof (pdf_t); break;
10241 case 10700: esalt_size = sizeof (pdf_t); break;
10242 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10243 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10244 case 11400: esalt_size = sizeof (sip_t); break;
10245 case 11600: esalt_size = sizeof (seven_zip_t); break;
10246 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10247 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10248 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10249 case 13000: esalt_size = sizeof (rar5_t); break;
10250 }
10251
10252 data.esalt_size = esalt_size;
10253
10254 /**
10255 * choose dictionary parser
10256 */
10257
10258 if (hash_type == HASH_TYPE_LM)
10259 {
10260 get_next_word_func = get_next_word_lm;
10261 }
10262 else if (opts_type & OPTS_TYPE_PT_UPPER)
10263 {
10264 get_next_word_func = get_next_word_uc;
10265 }
10266 else
10267 {
10268 get_next_word_func = get_next_word_std;
10269 }
10270
10271 /**
10272 * dictstat
10273 */
10274
10275 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10276
10277 #ifdef _POSIX
10278 size_t dictstat_nmemb = 0;
10279 #endif
10280
10281 #ifdef _WIN
10282 uint dictstat_nmemb = 0;
10283 #endif
10284
10285 char dictstat[256] = { 0 };
10286
10287 FILE *dictstat_fp = NULL;
10288
10289 if (keyspace == 0)
10290 {
10291 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10292
10293 dictstat_fp = fopen (dictstat, "rb");
10294
10295 if (dictstat_fp)
10296 {
10297 #ifdef _POSIX
10298 struct stat tmpstat;
10299
10300 fstat (fileno (dictstat_fp), &tmpstat);
10301 #endif
10302
10303 #ifdef _WIN
10304 struct stat64 tmpstat;
10305
10306 _fstat64 (fileno (dictstat_fp), &tmpstat);
10307 #endif
10308
10309 if (tmpstat.st_mtime < COMPTIME)
10310 {
10311 /* with v0.15 the format changed so we have to ensure user is using a good version
10312 since there is no version-header in the dictstat file */
10313
10314 fclose (dictstat_fp);
10315
10316 unlink (dictstat);
10317 }
10318 else
10319 {
10320 while (!feof (dictstat_fp))
10321 {
10322 dictstat_t d;
10323
10324 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10325
10326 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10327
10328 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10329 {
10330 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10331
10332 return -1;
10333 }
10334 }
10335
10336 fclose (dictstat_fp);
10337 }
10338 }
10339 }
10340
10341 /**
10342 * potfile
10343 */
10344
10345 char potfile[256] = { 0 };
10346
10347 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10348
10349 data.pot_fp = NULL;
10350
10351 FILE *out_fp = NULL;
10352 FILE *pot_fp = NULL;
10353
10354 if (show == 1 || left == 1)
10355 {
10356 pot_fp = fopen (potfile, "rb");
10357
10358 if (pot_fp == NULL)
10359 {
10360 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10361
10362 return (-1);
10363 }
10364
10365 if (outfile != NULL)
10366 {
10367 if ((out_fp = fopen (outfile, "ab")) == NULL)
10368 {
10369 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10370
10371 fclose (pot_fp);
10372
10373 return (-1);
10374 }
10375 }
10376 else
10377 {
10378 out_fp = stdout;
10379 }
10380 }
10381 else
10382 {
10383 if (potfile_disable == 0)
10384 {
10385 pot_fp = fopen (potfile, "ab");
10386
10387 if (pot_fp == NULL)
10388 {
10389 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10390
10391 return (-1);
10392 }
10393
10394 data.pot_fp = pot_fp;
10395 }
10396 }
10397
10398 pot_t *pot = NULL;
10399
10400 uint pot_cnt = 0;
10401 uint pot_avail = 0;
10402
10403 if (show == 1 || left == 1)
10404 {
10405 SUPPRESS_OUTPUT = 1;
10406
10407 pot_avail = count_lines (pot_fp);
10408
10409 rewind (pot_fp);
10410
10411 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10412
10413 uint pot_hashes_avail = 0;
10414
10415 uint line_num = 0;
10416
10417 while (!feof (pot_fp))
10418 {
10419 line_num++;
10420
10421 char line_buf[BUFSIZ] = { 0 };
10422
10423 int line_len = fgetl (pot_fp, line_buf);
10424
10425 if (line_len == 0) continue;
10426
10427 char *plain_buf = line_buf + line_len;
10428
10429 pot_t *pot_ptr = &pot[pot_cnt];
10430
10431 hash_t *hashes_buf = &pot_ptr->hash;
10432
10433 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10434 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10435
10436 if (pot_cnt == pot_hashes_avail)
10437 {
10438 uint pos = 0;
10439
10440 for (pos = 0; pos < INCR_POT; pos++)
10441 {
10442 if ((pot_cnt + pos) >= pot_avail) break;
10443
10444 pot_t *tmp_pot = &pot[pot_cnt + pos];
10445
10446 hash_t *tmp_hash = &tmp_pot->hash;
10447
10448 tmp_hash->digest = mymalloc (dgst_size);
10449
10450 if (isSalted)
10451 {
10452 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10453 }
10454
10455 if (esalt_size)
10456 {
10457 tmp_hash->esalt = mymalloc (esalt_size);
10458 }
10459
10460 pot_hashes_avail++;
10461 }
10462 }
10463
10464 int plain_len = 0;
10465
10466 int parser_status;
10467
10468 int iter = MAX_CUT_TRIES;
10469
10470 do
10471 {
10472 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10473 {
10474 if (line_buf[i] == ':')
10475 {
10476 line_len--;
10477
10478 break;
10479 }
10480 }
10481
10482 if (data.hash_mode != 2500)
10483 {
10484 parser_status = parse_func (line_buf, line_len, hashes_buf);
10485 }
10486 else
10487 {
10488 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10489
10490 if (line_len > max_salt_size)
10491 {
10492 parser_status = PARSER_GLOBAL_LENGTH;
10493 }
10494 else
10495 {
10496 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10497
10498 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10499
10500 hashes_buf->salt->salt_len = line_len;
10501
10502 parser_status = PARSER_OK;
10503 }
10504 }
10505
10506 // if NOT parsed without error, we add the ":" to the plain
10507
10508 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10509 {
10510 plain_len++;
10511 plain_buf--;
10512 }
10513
10514 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10515
10516 if (parser_status < PARSER_GLOBAL_ZERO)
10517 {
10518 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10519
10520 continue;
10521 }
10522
10523 if (plain_len >= 255) continue;
10524
10525 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10526
10527 pot_ptr->plain_len = plain_len;
10528
10529 pot_cnt++;
10530 }
10531
10532 fclose (pot_fp);
10533
10534 SUPPRESS_OUTPUT = 0;
10535
10536 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10537 }
10538
10539 /**
10540 * word len
10541 */
10542
10543 uint pw_min = PW_MIN;
10544 uint pw_max = PW_MAX;
10545
10546 switch (hash_mode)
10547 {
10548 case 400: if (pw_max > 40) pw_max = 40;
10549 break;
10550 case 500: if (pw_max > 16) pw_max = 16;
10551 break;
10552 case 1500: if (pw_max > 8) pw_max = 8;
10553 break;
10554 case 1600: if (pw_max > 16) pw_max = 16;
10555 break;
10556 case 1800: if (pw_max > 16) pw_max = 16;
10557 break;
10558 case 2100: if (pw_max > 16) pw_max = 16;
10559 break;
10560 case 2500: if (pw_min < 8) pw_min = 8;
10561 break;
10562 case 3000: if (pw_max > 7) pw_max = 7;
10563 break;
10564 case 5200: if (pw_max > 24) pw_max = 24;
10565 break;
10566 case 5800: if (pw_max > 16) pw_max = 16;
10567 break;
10568 case 6300: if (pw_max > 16) pw_max = 16;
10569 break;
10570 case 7400: if (pw_max > 16) pw_max = 16;
10571 break;
10572 case 7900: if (pw_max > 48) pw_max = 48;
10573 break;
10574 case 8500: if (pw_max > 8) pw_max = 8;
10575 break;
10576 case 8600: if (pw_max > 16) pw_max = 16;
10577 break;
10578 case 9710: pw_min = 5;
10579 pw_max = 5;
10580 break;
10581 case 9810: pw_min = 5;
10582 pw_max = 5;
10583 break;
10584 case 10410: pw_min = 5;
10585 pw_max = 5;
10586 break;
10587 case 10300: if (pw_max < 3) pw_min = 3;
10588 if (pw_max > 40) pw_max = 40;
10589 break;
10590 case 10500: if (pw_max < 3) pw_min = 3;
10591 if (pw_max > 40) pw_max = 40;
10592 break;
10593 case 10700: if (pw_max > 16) pw_max = 16;
10594 break;
10595 case 11300: if (pw_max > 40) pw_max = 40;
10596 break;
10597 case 12500: if (pw_max > 20) pw_max = 20;
10598 break;
10599 case 12800: if (pw_max > 24) pw_max = 24;
10600 break;
10601 }
10602
10603 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10604 {
10605 switch (attack_kern)
10606 {
10607 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10608 break;
10609 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10610 break;
10611 }
10612 }
10613
10614 /**
10615 * charsets : keep them together for more easy maintainnce
10616 */
10617
10618 cs_t mp_sys[6] = { { { 0 }, 0 } };
10619 cs_t mp_usr[4] = { { { 0 }, 0 } };
10620
10621 mp_setup_sys (mp_sys);
10622
10623 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10624 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10625 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10626 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10627
10628 /**
10629 * load hashes, part I: find input mode, count hashes
10630 */
10631
10632 uint hashlist_mode = 0;
10633 uint hashlist_format = HLFMT_HASHCAT;
10634
10635 uint hashes_avail = 0;
10636
10637 if (benchmark == 0)
10638 {
10639 struct stat f;
10640
10641 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10642
10643 if ((hash_mode == 2500) ||
10644 (hash_mode == 5200) ||
10645 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10646 (hash_mode == 9000))
10647 {
10648 hashlist_mode = HL_MODE_ARG;
10649
10650 char *hashfile = myargv[optind];
10651
10652 data.hashfile = hashfile;
10653
10654 logfile_top_var_string ("target", hashfile);
10655 }
10656
10657 if (hashlist_mode == HL_MODE_ARG)
10658 {
10659 if (hash_mode == 2500)
10660 {
10661 struct stat st;
10662
10663 if (stat (data.hashfile, &st) == -1)
10664 {
10665 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10666
10667 return (-1);
10668 }
10669
10670 hashes_avail = st.st_size / sizeof (hccap_t);
10671 }
10672 else
10673 {
10674 hashes_avail = 1;
10675 }
10676 }
10677 else if (hashlist_mode == HL_MODE_FILE)
10678 {
10679 char *hashfile = myargv[optind];
10680
10681 data.hashfile = hashfile;
10682
10683 logfile_top_var_string ("target", hashfile);
10684
10685 FILE *fp = NULL;
10686
10687 if ((fp = fopen (hashfile, "rb")) == NULL)
10688 {
10689 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10690
10691 return (-1);
10692 }
10693
10694 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10695
10696 hashes_avail = count_lines (fp);
10697
10698 rewind (fp);
10699
10700 if (hashes_avail == 0)
10701 {
10702 log_error ("ERROR: hashfile is empty or corrupt");
10703
10704 fclose (fp);
10705
10706 return (-1);
10707 }
10708
10709 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10710
10711 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10712 {
10713 log_error ("ERROR: remove not supported in native hashfile-format mode");
10714
10715 fclose (fp);
10716
10717 return (-1);
10718 }
10719
10720 fclose (fp);
10721 }
10722 }
10723 else
10724 {
10725 hashlist_mode = HL_MODE_ARG;
10726
10727 hashes_avail = 1;
10728 }
10729
10730 if (hash_mode == 3000) hashes_avail *= 2;
10731
10732 data.hashlist_mode = hashlist_mode;
10733 data.hashlist_format = hashlist_format;
10734
10735 logfile_top_uint (hashlist_mode);
10736 logfile_top_uint (hashlist_format);
10737
10738 /**
10739 * load hashes, part II: allocate required memory, set pointers
10740 */
10741
10742 hash_t *hashes_buf = NULL;
10743 void *digests_buf = NULL;
10744 salt_t *salts_buf = NULL;
10745 void *esalts_buf = NULL;
10746
10747 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10748
10749 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10750
10751 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10752 {
10753 u32 hash_pos;
10754
10755 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10756 {
10757 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10758
10759 hashes_buf[hash_pos].hash_info = hash_info;
10760
10761 if (username && (remove || show || left))
10762 {
10763 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10764 }
10765
10766 if (benchmark)
10767 {
10768 hash_info->orighash = (char *) mymalloc (256);
10769 }
10770 }
10771 }
10772
10773 if (isSalted)
10774 {
10775 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10776
10777 if (esalt_size)
10778 {
10779 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10780 }
10781 }
10782 else
10783 {
10784 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10785 }
10786
10787 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10788 {
10789 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10790
10791 if (isSalted)
10792 {
10793 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10794
10795 if (esalt_size)
10796 {
10797 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10798 }
10799 }
10800 else
10801 {
10802 hashes_buf[hash_pos].salt = &salts_buf[0];
10803 }
10804 }
10805
10806 /**
10807 * load hashes, part III: parse hashes or generate them if benchmark
10808 */
10809
10810 uint hashes_cnt = 0;
10811
10812 if (benchmark == 0)
10813 {
10814 if (keyspace == 1)
10815 {
10816 // useless to read hash file for keyspace, cheat a little bit w/ optind
10817 }
10818 else if (hashes_avail == 0)
10819 {
10820 }
10821 else if (hashlist_mode == HL_MODE_ARG)
10822 {
10823 char *input_buf = myargv[optind];
10824
10825 uint input_len = strlen (input_buf);
10826
10827 logfile_top_var_string ("target", input_buf);
10828
10829 char *hash_buf = NULL;
10830 int hash_len = 0;
10831
10832 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10833
10834 if (hash_len)
10835 {
10836 if (opts_type & OPTS_TYPE_HASH_COPY)
10837 {
10838 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10839
10840 hash_info_tmp->orighash = mystrdup (hash_buf);
10841 }
10842
10843 if (isSalted)
10844 {
10845 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10846 }
10847
10848 int parser_status = PARSER_OK;
10849
10850 if (hash_mode == 2500)
10851 {
10852 if (hash_len == 0)
10853 {
10854 log_error ("ERROR: hccap file not specified");
10855
10856 return (-1);
10857 }
10858
10859 hashlist_mode = HL_MODE_FILE;
10860
10861 data.hashlist_mode = hashlist_mode;
10862
10863 FILE *fp = fopen (hash_buf, "rb");
10864
10865 if (fp == NULL)
10866 {
10867 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10868
10869 return (-1);
10870 }
10871
10872 if (hashes_avail < 1)
10873 {
10874 log_error ("ERROR: hccap file is empty or corrupt");
10875
10876 fclose (fp);
10877
10878 return (-1);
10879 }
10880
10881 uint hccap_size = sizeof (hccap_t);
10882
10883 char *in = (char *) mymalloc (hccap_size);
10884
10885 while (!feof (fp))
10886 {
10887 int n = fread (in, hccap_size, 1, fp);
10888
10889 if (n != 1)
10890 {
10891 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10892
10893 break;
10894 }
10895
10896 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10897
10898 if (parser_status != PARSER_OK)
10899 {
10900 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10901
10902 continue;
10903 }
10904
10905 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10906
10907 if ((show == 1) || (left == 1))
10908 {
10909 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10910
10911 char *salt_ptr = (char *) tmp_salt->salt_buf;
10912
10913 int cur_pos = tmp_salt->salt_len;
10914 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10915
10916 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10917
10918 u8 *pke_ptr = (u8 *) wpa->pke;
10919
10920 // do the appending task
10921
10922 snprintf (salt_ptr + cur_pos,
10923 rem_len,
10924 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10925 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10926 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10927
10928
10929 // memset () the remaining part of the salt
10930
10931 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10932 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10933
10934 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10935
10936 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10937 }
10938
10939 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);
10940 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);
10941
10942 hashes_cnt++;
10943 }
10944
10945 fclose (fp);
10946
10947 myfree (in);
10948 }
10949 else if (hash_mode == 3000)
10950 {
10951 if (hash_len == 32)
10952 {
10953 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10954
10955 hash_t *lm_hash_left = NULL;
10956
10957 if (parser_status == PARSER_OK)
10958 {
10959 lm_hash_left = &hashes_buf[hashes_cnt];
10960
10961 hashes_cnt++;
10962 }
10963 else
10964 {
10965 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10966 }
10967
10968 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10969
10970 hash_t *lm_hash_right = NULL;
10971
10972 if (parser_status == PARSER_OK)
10973 {
10974 lm_hash_right = &hashes_buf[hashes_cnt];
10975
10976 hashes_cnt++;
10977 }
10978 else
10979 {
10980 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10981 }
10982
10983 // show / left
10984
10985 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10986 {
10987 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);
10988 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);
10989 }
10990 }
10991 else
10992 {
10993 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10994
10995 if (parser_status == PARSER_OK)
10996 {
10997 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10998 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10999 }
11000
11001 if (parser_status == PARSER_OK)
11002 {
11003 hashes_cnt++;
11004 }
11005 else
11006 {
11007 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11008 }
11009 }
11010 }
11011 else
11012 {
11013 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11014
11015 if (parser_status == PARSER_OK)
11016 {
11017 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11018 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11019 }
11020
11021 if (parser_status == PARSER_OK)
11022 {
11023 hashes_cnt++;
11024 }
11025 else
11026 {
11027 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11028 }
11029 }
11030 }
11031 }
11032 else if (hashlist_mode == HL_MODE_FILE)
11033 {
11034 char *hashfile = data.hashfile;
11035
11036 FILE *fp;
11037
11038 if ((fp = fopen (hashfile, "rb")) == NULL)
11039 {
11040 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11041
11042 return (-1);
11043 }
11044
11045 uint line_num = 0;
11046
11047 while (!feof (fp))
11048 {
11049 line_num++;
11050
11051 char line_buf[BUFSIZ] = { 0 };
11052
11053 int line_len = fgetl (fp, line_buf);
11054
11055 if (line_len == 0) continue;
11056
11057 char *hash_buf = NULL;
11058 int hash_len = 0;
11059
11060 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11061
11062 if (username)
11063 {
11064 char *user_buf = NULL;
11065 int user_len = 0;
11066
11067 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11068
11069 if (remove || show)
11070 {
11071 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11072
11073 *user = (user_t *) mymalloc (sizeof (user_t));
11074
11075 user_t *user_ptr = *user;
11076
11077 if (user_buf != NULL)
11078 {
11079 user_ptr->user_name = mystrdup (user_buf);
11080 }
11081 else
11082 {
11083 user_ptr->user_name = mystrdup ("");
11084 }
11085
11086 user_ptr->user_len = user_len;
11087 }
11088 }
11089
11090 if (opts_type & OPTS_TYPE_HASH_COPY)
11091 {
11092 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11093
11094 hash_info_tmp->orighash = mystrdup (hash_buf);
11095 }
11096
11097 if (isSalted)
11098 {
11099 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11100 }
11101
11102 if (hash_mode == 3000)
11103 {
11104 if (hash_len == 32)
11105 {
11106 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11107
11108 if (parser_status < PARSER_GLOBAL_ZERO)
11109 {
11110 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11111
11112 continue;
11113 }
11114
11115 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11116
11117 hashes_cnt++;
11118
11119 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11120
11121 if (parser_status < PARSER_GLOBAL_ZERO)
11122 {
11123 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11124
11125 continue;
11126 }
11127
11128 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11129
11130 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);
11131
11132 hashes_cnt++;
11133
11134 // show / left
11135
11136 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);
11137 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);
11138 }
11139 else
11140 {
11141 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11142
11143 if (parser_status < PARSER_GLOBAL_ZERO)
11144 {
11145 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11146
11147 continue;
11148 }
11149
11150 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);
11151
11152 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11153 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11154
11155 hashes_cnt++;
11156 }
11157 }
11158 else
11159 {
11160 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11161
11162 if (parser_status < PARSER_GLOBAL_ZERO)
11163 {
11164 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11165
11166 continue;
11167 }
11168
11169 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);
11170
11171 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11172 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11173
11174 hashes_cnt++;
11175 }
11176 }
11177
11178 fclose (fp);
11179
11180 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11181
11182 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11183 }
11184 }
11185 else
11186 {
11187 if (isSalted)
11188 {
11189 hashes_buf[0].salt->salt_len = 8;
11190
11191 // special salt handling
11192
11193 switch (hash_mode)
11194 {
11195 case 1500: hashes_buf[0].salt->salt_len = 2;
11196 break;
11197 case 1731: hashes_buf[0].salt->salt_len = 4;
11198 break;
11199 case 2410: hashes_buf[0].salt->salt_len = 4;
11200 break;
11201 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11202 break;
11203 case 3100: hashes_buf[0].salt->salt_len = 1;
11204 break;
11205 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11206 break;
11207 case 5800: hashes_buf[0].salt->salt_len = 16;
11208 break;
11209 case 6800: hashes_buf[0].salt->salt_len = 32;
11210 break;
11211 case 8400: hashes_buf[0].salt->salt_len = 40;
11212 break;
11213 case 8800: hashes_buf[0].salt->salt_len = 16;
11214 break;
11215 case 8900: hashes_buf[0].salt->salt_len = 16;
11216 hashes_buf[0].salt->scrypt_N = 1024;
11217 hashes_buf[0].salt->scrypt_r = 1;
11218 hashes_buf[0].salt->scrypt_p = 1;
11219 break;
11220 case 9100: hashes_buf[0].salt->salt_len = 16;
11221 break;
11222 case 9300: hashes_buf[0].salt->salt_len = 14;
11223 hashes_buf[0].salt->scrypt_N = 16384;
11224 hashes_buf[0].salt->scrypt_r = 1;
11225 hashes_buf[0].salt->scrypt_p = 1;
11226 break;
11227 case 9400: hashes_buf[0].salt->salt_len = 16;
11228 break;
11229 case 9500: hashes_buf[0].salt->salt_len = 16;
11230 break;
11231 case 9600: hashes_buf[0].salt->salt_len = 16;
11232 break;
11233 case 9700: hashes_buf[0].salt->salt_len = 16;
11234 break;
11235 case 9710: hashes_buf[0].salt->salt_len = 16;
11236 break;
11237 case 9720: hashes_buf[0].salt->salt_len = 16;
11238 break;
11239 case 9800: hashes_buf[0].salt->salt_len = 16;
11240 break;
11241 case 9810: hashes_buf[0].salt->salt_len = 16;
11242 break;
11243 case 9820: hashes_buf[0].salt->salt_len = 16;
11244 break;
11245 case 10300: hashes_buf[0].salt->salt_len = 12;
11246 break;
11247 case 11500: hashes_buf[0].salt->salt_len = 4;
11248 break;
11249 case 11600: hashes_buf[0].salt->salt_len = 4;
11250 break;
11251 case 12400: hashes_buf[0].salt->salt_len = 4;
11252 break;
11253 case 12500: hashes_buf[0].salt->salt_len = 8;
11254 break;
11255 case 12600: hashes_buf[0].salt->salt_len = 64;
11256 break;
11257 }
11258
11259 // special esalt handling
11260
11261 switch (hash_mode)
11262 {
11263 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11264 break;
11265 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11266 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11267 break;
11268 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11269 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11270 break;
11271 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11272 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11273 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11274 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11275 break;
11276 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11277 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11278 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11279 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11280 break;
11281 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11282 break;
11283 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11284 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11285 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11286 break;
11287 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11288 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11289 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11290 break;
11291 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11292 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11293 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11294 break;
11295 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11296 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11297 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11298 break;
11299 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11300 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11301 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11302 break;
11303 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11304 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11305 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11306 break;
11307 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11308 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11309 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11310 break;
11311 }
11312 }
11313
11314 // set hashfile
11315
11316 switch (hash_mode)
11317 {
11318 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11319 break;
11320 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11321 break;
11322 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11323 break;
11324 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11325 break;
11326 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11327 break;
11328 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11329 break;
11330 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11331 break;
11332 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11333 break;
11334 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11335 break;
11336 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11337 break;
11338 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11339 break;
11340 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11341 break;
11342 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11343 break;
11344 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11345 break;
11346 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11347 break;
11348 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11349 break;
11350 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11351 break;
11352 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11353 break;
11354 }
11355
11356 // set default iterations
11357
11358 switch (hash_mode)
11359 {
11360 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11361 break;
11362 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11363 break;
11364 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11365 break;
11366 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11367 break;
11368 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11369 break;
11370 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11371 break;
11372 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11373 break;
11374 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11375 break;
11376 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11377 break;
11378 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11379 break;
11380 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11381 break;
11382 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11383 break;
11384 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11385 break;
11386 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11387 break;
11388 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11389 break;
11390 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11391 break;
11392 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11393 break;
11394 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11395 break;
11396 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11397 break;
11398 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11399 break;
11400 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11401 break;
11402 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11403 break;
11404 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11405 break;
11406 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11407 break;
11408 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11409 break;
11410 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11411 break;
11412 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11413 break;
11414 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11415 break;
11416 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11417 break;
11418 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11419 break;
11420 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11421 break;
11422 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11423 break;
11424 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11425 break;
11426 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11427 break;
11428 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11429 break;
11430 case 8900: hashes_buf[0].salt->salt_iter = 1;
11431 break;
11432 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11433 break;
11434 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11435 break;
11436 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11437 break;
11438 case 9300: hashes_buf[0].salt->salt_iter = 1;
11439 break;
11440 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11441 break;
11442 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11443 break;
11444 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11445 break;
11446 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11447 break;
11448 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11449 break;
11450 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11451 break;
11452 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11453 break;
11454 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11455 break;
11456 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11457 break;
11458 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11459 break;
11460 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11461 break;
11462 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11463 break;
11464 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11465 break;
11466 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11467 break;
11468 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11469 break;
11470 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11471 break;
11472 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11473 break;
11474 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11475 break;
11476 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11477 break;
11478 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11479 break;
11480 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11481 break;
11482 }
11483
11484 hashes_cnt = 1;
11485 }
11486
11487 if (show == 1 || left == 1)
11488 {
11489 for (uint i = 0; i < pot_cnt; i++)
11490 {
11491 pot_t *pot_ptr = &pot[i];
11492
11493 hash_t *hashes_buf = &pot_ptr->hash;
11494
11495 local_free (hashes_buf->digest);
11496
11497 if (isSalted)
11498 {
11499 local_free (hashes_buf->salt);
11500 }
11501 }
11502
11503 local_free (pot);
11504
11505 if (data.quiet == 0) log_info_nn ("");
11506
11507 return (0);
11508 }
11509
11510 if (keyspace == 0)
11511 {
11512 if (hashes_cnt == 0)
11513 {
11514 log_error ("ERROR: No hashes loaded");
11515
11516 return (-1);
11517 }
11518 }
11519
11520 /**
11521 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11522 */
11523
11524 if (data.outfile != NULL)
11525 {
11526 if (data.hashfile != NULL)
11527 {
11528 #ifdef _POSIX
11529 struct stat tmpstat_outfile;
11530 struct stat tmpstat_hashfile;
11531 #endif
11532
11533 #ifdef _WIN
11534 struct stat64 tmpstat_outfile;
11535 struct stat64 tmpstat_hashfile;
11536 #endif
11537
11538 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11539
11540 if (tmp_outfile_fp)
11541 {
11542 #ifdef _POSIX
11543 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11544 #endif
11545
11546 #ifdef _WIN
11547 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11548 #endif
11549
11550 fclose (tmp_outfile_fp);
11551 }
11552
11553 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11554
11555 if (tmp_hashfile_fp)
11556 {
11557 #ifdef _POSIX
11558 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11559 #endif
11560
11561 #ifdef _WIN
11562 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11563 #endif
11564
11565 fclose (tmp_hashfile_fp);
11566 }
11567
11568 if (tmp_outfile_fp && tmp_outfile_fp)
11569 {
11570 tmpstat_outfile.st_mode = 0;
11571 tmpstat_outfile.st_nlink = 0;
11572 tmpstat_outfile.st_uid = 0;
11573 tmpstat_outfile.st_gid = 0;
11574 tmpstat_outfile.st_rdev = 0;
11575 tmpstat_outfile.st_atime = 0;
11576
11577 tmpstat_hashfile.st_mode = 0;
11578 tmpstat_hashfile.st_nlink = 0;
11579 tmpstat_hashfile.st_uid = 0;
11580 tmpstat_hashfile.st_gid = 0;
11581 tmpstat_hashfile.st_rdev = 0;
11582 tmpstat_hashfile.st_atime = 0;
11583
11584 #ifdef _POSIX
11585 tmpstat_outfile.st_blksize = 0;
11586 tmpstat_outfile.st_blocks = 0;
11587
11588 tmpstat_hashfile.st_blksize = 0;
11589 tmpstat_hashfile.st_blocks = 0;
11590 #endif
11591
11592 #ifdef _POSIX
11593 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11594 {
11595 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11596
11597 return (-1);
11598 }
11599 #endif
11600
11601 #ifdef _WIN
11602 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11603 {
11604 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11605
11606 return (-1);
11607 }
11608 #endif
11609 }
11610 }
11611 }
11612
11613 /**
11614 * Remove duplicates
11615 */
11616
11617 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11618
11619 if (isSalted)
11620 {
11621 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11622 }
11623 else
11624 {
11625 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11626 }
11627
11628 uint hashes_cnt_orig = hashes_cnt;
11629
11630 hashes_cnt = 1;
11631
11632 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11633 {
11634 if (isSalted)
11635 {
11636 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11637 {
11638 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11639 }
11640 }
11641 else
11642 {
11643 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11644 }
11645
11646 if (hashes_pos > hashes_cnt)
11647 {
11648 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11649 }
11650
11651 hashes_cnt++;
11652 }
11653
11654 /**
11655 * Potfile removes
11656 */
11657
11658 uint potfile_remove_cracks = 0;
11659
11660 if (potfile_disable == 0)
11661 {
11662 hash_t hash_buf;
11663
11664 hash_buf.digest = mymalloc (dgst_size);
11665 hash_buf.salt = NULL;
11666 hash_buf.esalt = NULL;
11667 hash_buf.hash_info = NULL;
11668 hash_buf.cracked = 0;
11669
11670 if (isSalted)
11671 {
11672 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11673 }
11674
11675 if (esalt_size)
11676 {
11677 hash_buf.esalt = mymalloc (esalt_size);
11678 }
11679
11680 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11681
11682 // no solution for these special hash types (for instane because they use hashfile in output etc)
11683 if ((hash_mode != 5200) &&
11684 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11685 (hash_mode != 9000))
11686 {
11687 FILE *fp = fopen (potfile, "rb");
11688
11689 if (fp != NULL)
11690 {
11691 while (!feof (fp))
11692 {
11693 char line_buf[BUFSIZ] = { 0 };
11694
11695 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11696
11697 if (ptr == NULL) break;
11698
11699 int line_len = strlen (line_buf);
11700
11701 if (line_len == 0) continue;
11702
11703 int iter = MAX_CUT_TRIES;
11704
11705 for (int i = line_len - 1; i && iter; i--, line_len--)
11706 {
11707 if (line_buf[i] != ':') continue;
11708
11709 if (isSalted)
11710 {
11711 memset (hash_buf.salt, 0, sizeof (salt_t));
11712 }
11713
11714 hash_t *found = NULL;
11715
11716 if (hash_mode == 6800)
11717 {
11718 if (i < 64) // 64 = 16 * uint in salt_buf[]
11719 {
11720 // manipulate salt_buf
11721 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11722
11723 hash_buf.salt->salt_len = i;
11724
11725 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11726 }
11727 }
11728 else if (hash_mode == 2500)
11729 {
11730 if (i < 64) // 64 = 16 * uint in salt_buf[]
11731 {
11732 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11733 // manipulate salt_buf
11734
11735 // to be safe work with a copy (because of line_len loop, i etc)
11736
11737 char line_buf_cpy[BUFSIZ] = { 0 };
11738
11739 memcpy (line_buf_cpy, line_buf, i);
11740
11741 char *mac2_pos = strrchr (line_buf_cpy, ':');
11742
11743 if (mac2_pos == NULL) continue;
11744
11745 mac2_pos[0] = 0;
11746 mac2_pos++;
11747
11748 if (strlen (mac2_pos) != 12) continue;
11749
11750 char *mac1_pos = strrchr (line_buf_cpy, ':');
11751
11752 if (mac1_pos == NULL) continue;
11753
11754 mac1_pos[0] = 0;
11755 mac1_pos++;
11756
11757 if (strlen (mac1_pos) != 12) continue;
11758
11759 uint essid_length = mac1_pos - line_buf_cpy - 1;
11760
11761 // here we need the ESSID
11762 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11763
11764 hash_buf.salt->salt_len = essid_length;
11765
11766 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11767
11768 if (found)
11769 {
11770 wpa_t *wpa = (wpa_t *) found->esalt;
11771
11772 uint pke[25] = { 0 };
11773
11774 char *pke_ptr = (char *) pke;
11775
11776 for (uint i = 0; i < 25; i++)
11777 {
11778 pke[i] = byte_swap_32 (wpa->pke[i]);
11779 }
11780
11781 u8 mac1[6] = { 0 };
11782 u8 mac2[6] = { 0 };
11783
11784 memcpy (mac1, pke_ptr + 23, 6);
11785 memcpy (mac2, pke_ptr + 29, 6);
11786
11787 // compare hex string(s) vs binary MAC address(es)
11788
11789 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11790 {
11791 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11792 {
11793 found = NULL;
11794 break;
11795 }
11796 }
11797
11798 // early skip ;)
11799 if (!found) continue;
11800
11801 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11802 {
11803 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11804 {
11805 found = NULL;
11806 break;
11807 }
11808 }
11809 }
11810 }
11811 }
11812 else
11813 {
11814 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11815
11816 if (parser_status == PARSER_OK)
11817 {
11818 if (isSalted)
11819 {
11820 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11821 }
11822 else
11823 {
11824 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11825 }
11826 }
11827 }
11828
11829 if (found == NULL) continue;
11830
11831 if (!found->cracked) potfile_remove_cracks++;
11832
11833 found->cracked = 1;
11834
11835 if (found) break;
11836
11837 iter--;
11838 }
11839 }
11840
11841 fclose (fp);
11842 }
11843 }
11844
11845 if (esalt_size)
11846 {
11847 local_free (hash_buf.esalt);
11848 }
11849
11850 if (isSalted)
11851 {
11852 local_free (hash_buf.salt);
11853 }
11854
11855 local_free (hash_buf.digest);
11856 }
11857
11858 /**
11859 * Now generate all the buffers required for later
11860 */
11861
11862 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11863
11864 salt_t *salts_buf_new = NULL;
11865 void *esalts_buf_new = NULL;
11866
11867 if (isSalted)
11868 {
11869 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11870
11871 if (esalt_size)
11872 {
11873 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11874 }
11875 }
11876 else
11877 {
11878 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11879 }
11880
11881 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11882
11883 uint digests_cnt = hashes_cnt;
11884 uint digests_done = 0;
11885
11886 uint size_digests = digests_cnt * dgst_size;
11887 uint size_shown = digests_cnt * sizeof (uint);
11888
11889 uint *digests_shown = (uint *) mymalloc (size_shown);
11890 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11891
11892 uint salts_cnt = 0;
11893 uint salts_done = 0;
11894
11895 hashinfo_t **hash_info = NULL;
11896
11897 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11898 {
11899 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11900
11901 if (username && (remove || show))
11902 {
11903 uint user_pos;
11904
11905 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11906 {
11907 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11908
11909 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11910 }
11911 }
11912 }
11913
11914 uint *salts_shown = (uint *) mymalloc (size_shown);
11915
11916 salt_t *salt_buf;
11917
11918 {
11919 // copied from inner loop
11920
11921 salt_buf = &salts_buf_new[salts_cnt];
11922
11923 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11924
11925 if (esalt_size)
11926 {
11927 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11928 }
11929
11930 salt_buf->digests_cnt = 0;
11931 salt_buf->digests_done = 0;
11932 salt_buf->digests_offset = 0;
11933
11934 salts_cnt++;
11935 }
11936
11937 if (hashes_buf[0].cracked == 1)
11938 {
11939 digests_shown[0] = 1;
11940
11941 digests_done++;
11942
11943 salt_buf->digests_done++;
11944 }
11945
11946 salt_buf->digests_cnt++;
11947
11948 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11949
11950 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11951 {
11952 hash_info[0] = hashes_buf[0].hash_info;
11953 }
11954
11955 // copy from inner loop
11956
11957 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11958 {
11959 if (isSalted)
11960 {
11961 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11962 {
11963 salt_buf = &salts_buf_new[salts_cnt];
11964
11965 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11966
11967 if (esalt_size)
11968 {
11969 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11970 }
11971
11972 salt_buf->digests_cnt = 0;
11973 salt_buf->digests_done = 0;
11974 salt_buf->digests_offset = hashes_pos;
11975
11976 salts_cnt++;
11977 }
11978 }
11979
11980 if (hashes_buf[hashes_pos].cracked == 1)
11981 {
11982 digests_shown[hashes_pos] = 1;
11983
11984 digests_done++;
11985
11986 salt_buf->digests_done++;
11987 }
11988
11989 salt_buf->digests_cnt++;
11990
11991 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11992
11993 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11994 {
11995 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11996 }
11997 }
11998
11999 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12000 {
12001 salt_t *salt_buf = &salts_buf_new[salt_pos];
12002
12003 if (salt_buf->digests_done == salt_buf->digests_cnt)
12004 {
12005 salts_shown[salt_pos] = 1;
12006
12007 salts_done++;
12008 }
12009
12010 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12011 }
12012
12013 local_free (digests_buf);
12014 local_free (salts_buf);
12015 local_free (esalts_buf);
12016
12017 digests_buf = digests_buf_new;
12018 salts_buf = salts_buf_new;
12019 esalts_buf = esalts_buf_new;
12020
12021 local_free (hashes_buf);
12022
12023 /**
12024 * special modification not set from parser
12025 */
12026
12027 switch (hash_mode)
12028 {
12029 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12030 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12031 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12032 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12033 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12034 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12035 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12036 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12037 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12038 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12039 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12040 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12041 }
12042
12043 if (truecrypt_keyfiles)
12044 {
12045 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12046
12047 char *keyfiles = strdup (truecrypt_keyfiles);
12048
12049 char *keyfile = strtok (keyfiles, ",");
12050
12051 do
12052 {
12053 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12054
12055 } while ((keyfile = strtok (NULL, ",")) != NULL);
12056
12057 free (keyfiles);
12058 }
12059
12060 data.digests_cnt = digests_cnt;
12061 data.digests_done = digests_done;
12062 data.digests_buf = digests_buf;
12063 data.digests_shown = digests_shown;
12064 data.digests_shown_tmp = digests_shown_tmp;
12065
12066 data.salts_cnt = salts_cnt;
12067 data.salts_done = salts_done;
12068 data.salts_buf = salts_buf;
12069 data.salts_shown = salts_shown;
12070
12071 data.esalts_buf = esalts_buf;
12072 data.hash_info = hash_info;
12073
12074 /**
12075 * Automatic Optimizers
12076 */
12077
12078 if (salts_cnt == 1)
12079 opti_type |= OPTI_TYPE_SINGLE_SALT;
12080
12081 if (digests_cnt == 1)
12082 opti_type |= OPTI_TYPE_SINGLE_HASH;
12083
12084 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12085 opti_type |= OPTI_TYPE_NOT_ITERATED;
12086
12087 if (attack_mode == ATTACK_MODE_BF)
12088 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12089
12090 data.opti_type = opti_type;
12091
12092 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12093 {
12094 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12095 {
12096 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12097 {
12098 if (opts_type & OPTS_TYPE_ST_ADD80)
12099 {
12100 opts_type &= ~OPTS_TYPE_ST_ADD80;
12101 opts_type |= OPTS_TYPE_PT_ADD80;
12102 }
12103
12104 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12105 {
12106 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12107 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12108 }
12109
12110 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12111 {
12112 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12113 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12114 }
12115 }
12116 }
12117 }
12118
12119 /**
12120 * Some algorithm, like descrypt, can benefit from JIT compilation
12121 */
12122
12123 int force_jit_compilation = -1;
12124
12125 if (hash_mode == 8900)
12126 {
12127 force_jit_compilation = 8900;
12128 }
12129 else if (hash_mode == 9300)
12130 {
12131 force_jit_compilation = 8900;
12132 }
12133 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12134 {
12135 force_jit_compilation = 1500;
12136 }
12137
12138 /**
12139 * generate bitmap tables
12140 */
12141
12142 const uint bitmap_shift1 = 5;
12143 const uint bitmap_shift2 = 13;
12144
12145 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12146
12147 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12148 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12149 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12150 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12151 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12152 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12153 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12154 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12155
12156 uint bitmap_bits;
12157 uint bitmap_nums;
12158 uint bitmap_mask;
12159 uint bitmap_size;
12160
12161 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12162 {
12163 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12164
12165 bitmap_nums = 1 << bitmap_bits;
12166
12167 bitmap_mask = bitmap_nums - 1;
12168
12169 bitmap_size = bitmap_nums * sizeof (uint);
12170
12171 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12172
12173 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;
12174 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;
12175
12176 break;
12177 }
12178
12179 bitmap_nums = 1 << bitmap_bits;
12180
12181 bitmap_mask = bitmap_nums - 1;
12182
12183 bitmap_size = bitmap_nums * sizeof (uint);
12184
12185 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);
12186 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);
12187
12188 /**
12189 * prepare quick rule
12190 */
12191
12192 data.rule_buf_l = rule_buf_l;
12193 data.rule_buf_r = rule_buf_r;
12194
12195 int rule_len_l = (int) strlen (rule_buf_l);
12196 int rule_len_r = (int) strlen (rule_buf_r);
12197
12198 data.rule_len_l = rule_len_l;
12199 data.rule_len_r = rule_len_r;
12200
12201 /**
12202 * load rules
12203 */
12204
12205 uint *all_kernel_rules_cnt = NULL;
12206
12207 kernel_rule_t **all_kernel_rules_buf = NULL;
12208
12209 if (rp_files_cnt)
12210 {
12211 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12212
12213 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12214 }
12215
12216 char rule_buf[BUFSIZ] = { 0 };
12217
12218 int rule_len = 0;
12219
12220 for (uint i = 0; i < rp_files_cnt; i++)
12221 {
12222 uint kernel_rules_avail = 0;
12223
12224 uint kernel_rules_cnt = 0;
12225
12226 kernel_rule_t *kernel_rules_buf = NULL;
12227
12228 char *rp_file = rp_files[i];
12229
12230 char in[BLOCK_SIZE] = { 0 };
12231 char out[BLOCK_SIZE] = { 0 };
12232
12233 FILE *fp = NULL;
12234
12235 uint rule_line = 0;
12236
12237 if ((fp = fopen (rp_file, "rb")) == NULL)
12238 {
12239 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12240
12241 return (-1);
12242 }
12243
12244 while (!feof (fp))
12245 {
12246 memset (rule_buf, 0, BUFSIZ);
12247
12248 rule_len = fgetl (fp, rule_buf);
12249
12250 rule_line++;
12251
12252 if (rule_len == 0) continue;
12253
12254 if (rule_buf[0] == '#') continue;
12255
12256 if (kernel_rules_avail == kernel_rules_cnt)
12257 {
12258 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12259
12260 kernel_rules_avail += INCR_RULES;
12261 }
12262
12263 memset (in, 0, BLOCK_SIZE);
12264 memset (out, 0, BLOCK_SIZE);
12265
12266 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12267
12268 if (result == -1)
12269 {
12270 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12271
12272 continue;
12273 }
12274
12275 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12276 {
12277 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12278
12279 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12280
12281 continue;
12282 }
12283
12284 /* its so slow
12285 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12286 {
12287 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12288
12289 continue;
12290 }
12291 */
12292
12293 kernel_rules_cnt++;
12294 }
12295
12296 fclose (fp);
12297
12298 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12299
12300 all_kernel_rules_buf[i] = kernel_rules_buf;
12301 }
12302
12303 /**
12304 * merge rules or automatic rule generator
12305 */
12306
12307 uint kernel_rules_cnt = 0;
12308
12309 kernel_rule_t *kernel_rules_buf = NULL;
12310
12311 if (attack_mode == ATTACK_MODE_STRAIGHT)
12312 {
12313 if (rp_files_cnt)
12314 {
12315 kernel_rules_cnt = 1;
12316
12317 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12318
12319 repeats[0] = kernel_rules_cnt;
12320
12321 for (uint i = 0; i < rp_files_cnt; i++)
12322 {
12323 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12324
12325 repeats[i + 1] = kernel_rules_cnt;
12326 }
12327
12328 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12329
12330 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12331
12332 for (uint i = 0; i < kernel_rules_cnt; i++)
12333 {
12334 uint out_pos = 0;
12335
12336 kernel_rule_t *out = &kernel_rules_buf[i];
12337
12338 for (uint j = 0; j < rp_files_cnt; j++)
12339 {
12340 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12341 uint in_pos;
12342
12343 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12344
12345 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12346 {
12347 if (out_pos == RULES_MAX - 1)
12348 {
12349 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12350
12351 break;
12352 }
12353
12354 out->cmds[out_pos] = in->cmds[in_pos];
12355 }
12356 }
12357 }
12358
12359 local_free (repeats);
12360 }
12361 else if (rp_gen)
12362 {
12363 uint kernel_rules_avail = 0;
12364
12365 while (kernel_rules_cnt < rp_gen)
12366 {
12367 if (kernel_rules_avail == kernel_rules_cnt)
12368 {
12369 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12370
12371 kernel_rules_avail += INCR_RULES;
12372 }
12373
12374 memset (rule_buf, 0, BLOCK_SIZE);
12375
12376 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12377
12378 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12379
12380 kernel_rules_cnt++;
12381 }
12382 }
12383 }
12384
12385 /**
12386 * generate NOP rules
12387 */
12388
12389 if (kernel_rules_cnt == 0)
12390 {
12391 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12392
12393 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12394
12395 kernel_rules_cnt++;
12396 }
12397
12398 data.kernel_rules_cnt = kernel_rules_cnt;
12399 data.kernel_rules_buf = kernel_rules_buf;
12400
12401 /**
12402 * OpenCL platforms: detect
12403 */
12404
12405 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12406 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12407
12408 cl_uint platforms_cnt = 0;
12409 cl_uint platform_devices_cnt = 0;
12410
12411 if (keyspace == 0)
12412 {
12413 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12414
12415 if (platforms_cnt == 0)
12416 {
12417 log_error ("ERROR: No OpenCL compatible platform found");
12418
12419 return (-1);
12420 }
12421 }
12422
12423 /**
12424 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12425 */
12426
12427 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12428 {
12429 cl_platform_id platform = platforms[platform_id];
12430
12431 char platform_vendor[INFOSZ] = { 0 };
12432
12433 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12434
12435 #ifdef HAVE_HWMON
12436 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12437 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12438 {
12439 // make sure that we do not directly control the fan for NVidia
12440
12441 gpu_temp_retain = 0;
12442
12443 data.gpu_temp_retain = gpu_temp_retain;
12444 }
12445 #endif // HAVE_NVML || HAVE_NVAPI
12446 #endif
12447 }
12448
12449 /**
12450 * OpenCL devices: simply push all devices from all platforms into the same device array
12451 */
12452
12453 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12454
12455 data.devices_param = devices_param;
12456
12457 uint devices_cnt = 0;
12458
12459 uint devices_active = 0;
12460
12461 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12462 {
12463 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12464
12465 cl_platform_id platform = platforms[platform_id];
12466
12467 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12468
12469 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12470 {
12471 size_t param_value_size = 0;
12472
12473 const uint device_id = devices_cnt;
12474
12475 hc_device_param_t *device_param = &data.devices_param[device_id];
12476
12477 device_param->device = platform_devices[platform_devices_id];
12478
12479 device_param->device_id = device_id;
12480
12481 device_param->platform_devices_id = platform_devices_id;
12482
12483 // device_type
12484
12485 cl_device_type device_type;
12486
12487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12488
12489 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12490
12491 device_param->device_type = device_type;
12492
12493 // vendor_id
12494
12495 cl_uint vendor_id = 0;
12496
12497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12498
12499 device_param->vendor_id = vendor_id;
12500
12501 // device_name
12502
12503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12504
12505 char *device_name = (char *) mymalloc (param_value_size);
12506
12507 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12508
12509 device_param->device_name = device_name;
12510
12511 // tuning db
12512
12513 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12514
12515 // device_version
12516
12517 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12518
12519 char *device_version = (char *) mymalloc (param_value_size);
12520
12521 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12522
12523 device_param->device_version = device_version;
12524
12525 // device_opencl_version
12526
12527 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12528
12529 char *device_opencl_version = (char *) mymalloc (param_value_size);
12530
12531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12532
12533 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12534
12535 myfree (device_opencl_version);
12536
12537 if (strstr (device_version, "pocl"))
12538 {
12539 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12540 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12541
12542 cl_uint vendor_id = VENDOR_ID_GENERIC;
12543
12544 device_param->vendor_id = vendor_id;
12545 }
12546
12547 // vector_width
12548
12549 cl_uint vector_width;
12550
12551 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12552 {
12553 if (tuningdb_entry->vector_width == -1)
12554 {
12555 if (opti_type & OPTI_TYPE_USES_BITS_64)
12556 {
12557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12558 }
12559 else
12560 {
12561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12562 }
12563 }
12564 else
12565 {
12566 vector_width = (cl_uint) tuningdb_entry->vector_width;
12567 }
12568 }
12569 else
12570 {
12571 vector_width = opencl_vector_width;
12572 }
12573
12574 if (vector_width > 8) vector_width = 8;
12575
12576 device_param->vector_width = vector_width;
12577
12578 // max_compute_units
12579
12580 cl_uint device_processors;
12581
12582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12583
12584 device_param->device_processors = device_processors;
12585
12586 // max_mem_alloc_size
12587
12588 cl_ulong device_maxmem_alloc;
12589
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12591
12592 device_param->device_maxmem_alloc = device_maxmem_alloc;
12593
12594 // max_mem_alloc_size
12595
12596 cl_ulong device_global_mem;
12597
12598 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12599
12600 device_param->device_global_mem = device_global_mem;
12601
12602 // max_clock_frequency
12603
12604 cl_uint device_maxclock_frequency;
12605
12606 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12607
12608 device_param->device_maxclock_frequency = device_maxclock_frequency;
12609
12610 // skipped
12611
12612 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12613 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12614
12615 device_param->skipped = (skipped1 || skipped2);
12616
12617 // driver_version
12618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12619
12620 char *driver_version = (char *) mymalloc (param_value_size);
12621
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12623
12624 device_param->driver_version = driver_version;
12625
12626 // device_name_chksum
12627
12628 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12629
12630 #if __x86_64__
12631 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);
12632 #else
12633 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);
12634 #endif
12635
12636 uint device_name_digest[4] = { 0 };
12637
12638 md5_64 ((uint *) device_name_chksum, device_name_digest);
12639
12640 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12641
12642 device_param->device_name_chksum = device_name_chksum;
12643
12644 // device_processor_cores
12645
12646 if (device_type & CL_DEVICE_TYPE_CPU)
12647 {
12648 cl_uint device_processor_cores = 1;
12649
12650 device_param->device_processor_cores = device_processor_cores;
12651 }
12652
12653 if (device_type & CL_DEVICE_TYPE_GPU)
12654 {
12655 if (vendor_id == VENDOR_ID_AMD)
12656 {
12657 cl_uint device_processor_cores = 0;
12658
12659 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12660
12661 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12662
12663 device_param->device_processor_cores = device_processor_cores;
12664 }
12665 else if (vendor_id == VENDOR_ID_NV)
12666 {
12667 cl_uint kernel_exec_timeout = 0;
12668
12669 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12670
12671 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12672
12673 device_param->kernel_exec_timeout = kernel_exec_timeout;
12674
12675 cl_uint device_processor_cores = 0;
12676
12677 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12678
12679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12680
12681 device_param->device_processor_cores = device_processor_cores;
12682
12683 cl_uint sm_minor = 0;
12684 cl_uint sm_major = 0;
12685
12686 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12687 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12688
12689 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12691
12692 device_param->sm_minor = sm_minor;
12693 device_param->sm_major = sm_major;
12694 }
12695 else
12696 {
12697 cl_uint device_processor_cores = 1;
12698
12699 device_param->device_processor_cores = device_processor_cores;
12700 }
12701 }
12702
12703 // display results
12704
12705 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12706 {
12707 if (device_param->skipped == 0)
12708 {
12709 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12710 device_id + 1,
12711 device_name,
12712 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12713 (unsigned int) (device_global_mem / 1024 / 1024),
12714 (unsigned int) (device_maxclock_frequency),
12715 (unsigned int) device_processors);
12716 }
12717 else
12718 {
12719 log_info ("Device #%u: %s, skipped",
12720 device_id + 1,
12721 device_name);
12722 }
12723 }
12724
12725 // common driver check
12726
12727 if (device_param->skipped == 0)
12728 {
12729 if (strstr (device_version, "pocl"))
12730 {
12731 if (force == 0)
12732 {
12733 log_info ("");
12734 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12735 log_info ("You are STRONGLY encouraged not to use it");
12736 log_info ("You can use --force to override this but do not post error reports if you do so");
12737 log_info ("");
12738
12739 return (-1);
12740 }
12741 }
12742
12743 if (device_type & CL_DEVICE_TYPE_GPU)
12744 {
12745 if (vendor_id == VENDOR_ID_NV)
12746 {
12747 if (device_param->kernel_exec_timeout != 0)
12748 {
12749 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);
12750 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12751 }
12752 }
12753 else if (vendor_id == VENDOR_ID_AMD)
12754 {
12755 int catalyst_check = (force == 1) ? 0 : 1;
12756
12757 int catalyst_warn = 0;
12758
12759 int catalyst_broken = 0;
12760
12761 if (catalyst_check == 1)
12762 {
12763 catalyst_warn = 1;
12764
12765 // v14.9 and higher
12766 if (atoi (device_param->driver_version) >= 1573)
12767 {
12768 catalyst_warn = 0;
12769 }
12770
12771 catalyst_check = 0;
12772 }
12773
12774 if (catalyst_broken == 1)
12775 {
12776 log_info ("");
12777 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12778 log_info ("It will pass over cracked hashes and does not report them as cracked");
12779 log_info ("You are STRONGLY encouraged not to use it");
12780 log_info ("You can use --force to override this but do not post error reports if you do so");
12781 log_info ("");
12782
12783 return (-1);
12784 }
12785
12786 if (catalyst_warn == 1)
12787 {
12788 log_info ("");
12789 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12790 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12791 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12792 #ifdef _WIN
12793 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12794 #endif
12795 log_info ("You can use --force to override this but do not post error reports if you do so");
12796 log_info ("");
12797
12798 return (-1);
12799 }
12800 }
12801 }
12802
12803 /**
12804 * kernel accel and loops tuning db adjustment
12805 */
12806
12807 uint _kernel_accel = kernel_accel;
12808 uint _kernel_loops = kernel_loops;
12809
12810 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12811
12812 if (kernel_accel_chgd == 0)
12813 {
12814 _kernel_accel = tuningdb_entry->kernel_accel;
12815 }
12816
12817 if (kernel_loops_chgd == 0)
12818 {
12819 _kernel_loops = tuningdb_entry->kernel_loops;
12820
12821 if (workload_profile == 1)
12822 {
12823 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12824 }
12825 else if (workload_profile == 2)
12826 {
12827 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12828 }
12829 }
12830
12831 device_param->kernel_accel = _kernel_accel;
12832 device_param->kernel_loops = _kernel_loops;
12833
12834 devices_active++;
12835 }
12836
12837 // next please
12838
12839 devices_cnt++;
12840 }
12841 }
12842
12843 if (keyspace == 0 && devices_active == 0)
12844 {
12845 log_error ("ERROR: No devices found/left");
12846
12847 return (-1);
12848 }
12849
12850 data.devices_cnt = devices_cnt;
12851
12852 data.devices_active = devices_active;
12853
12854 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12855 {
12856 log_info ("");
12857 }
12858
12859 /**
12860 * HM devices: init
12861 */
12862
12863 #ifdef HAVE_HWMON
12864 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12865 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12866 #endif
12867
12868 #ifdef HAVE_ADL
12869 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12870 #endif
12871
12872 if (gpu_temp_disable == 0)
12873 {
12874 #if defined(WIN) && defined(HAVE_NVAPI)
12875 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12876
12877 if (nvapi_init (nvapi) == 0)
12878 data.hm_nv = nvapi;
12879
12880 if (data.hm_nv)
12881 {
12882 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12883 {
12884 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12885
12886 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12887
12888 int tmp_out = 0;
12889
12890 for (int i = 0; i < tmp_in; i++)
12891 {
12892 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12893 }
12894
12895 for (int i = 0; i < tmp_out; i++)
12896 {
12897 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12898
12899 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12900
12901 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;
12902 }
12903 }
12904 }
12905 #endif // WIN && HAVE_NVAPI
12906
12907 #if defined(LINUX) && defined(HAVE_NVML)
12908 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12909
12910 if (nvml_init (nvml) == 0)
12911 data.hm_nv = nvml;
12912
12913 if (data.hm_nv)
12914 {
12915 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12916 {
12917 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12918
12919 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12920
12921 int tmp_out = 0;
12922
12923 for (int i = 0; i < tmp_in; i++)
12924 {
12925 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12926 }
12927
12928 for (int i = 0; i < tmp_out; i++)
12929 {
12930 unsigned int speed;
12931
12932 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;
12933 }
12934 }
12935 }
12936 #endif // LINUX && HAVE_NVML
12937
12938 data.hm_amd = NULL;
12939
12940 #ifdef HAVE_ADL
12941 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
12942
12943 if (adl_init (adl) == 0)
12944 data.hm_amd = adl;
12945
12946 if (data.hm_amd)
12947 {
12948 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12949 {
12950 // total number of adapters
12951
12952 int hm_adapters_num;
12953
12954 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
12955
12956 // adapter info
12957
12958 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
12959
12960 if (lpAdapterInfo == NULL) return (-1);
12961
12962 // get a list (of ids of) valid/usable adapters
12963
12964 int num_adl_adapters = 0;
12965
12966 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12967
12968 if (num_adl_adapters > 0)
12969 {
12970 hc_thread_mutex_lock (mux_adl);
12971
12972 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12973
12974 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12975
12976 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12977 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12978
12979 hc_thread_mutex_unlock (mux_adl);
12980 }
12981
12982 myfree (valid_adl_device_list);
12983 myfree (lpAdapterInfo);
12984 }
12985 }
12986 #endif // HAVE_ADL
12987
12988 if (data.hm_amd == NULL && data.hm_nv == NULL)
12989 {
12990 gpu_temp_disable = 1;
12991 }
12992 }
12993
12994 /**
12995 * OpenCL devices: allocate buffer for device specific information
12996 */
12997
12998 #ifdef HAVE_HWMON
12999 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13000
13001 #ifdef HAVE_ADL
13002 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13003
13004 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13005 #endif // ADL
13006 #endif
13007
13008 /**
13009 * enable custom signal handler(s)
13010 */
13011
13012 if (benchmark == 0)
13013 {
13014 hc_signal (sigHandler_default);
13015 }
13016 else
13017 {
13018 hc_signal (sigHandler_benchmark);
13019 }
13020
13021 /**
13022 * User-defined GPU temp handling
13023 */
13024
13025 #ifdef HAVE_HWMON
13026 if (gpu_temp_disable == 1)
13027 {
13028 gpu_temp_abort = 0;
13029 gpu_temp_retain = 0;
13030 }
13031
13032 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13033 {
13034 if (gpu_temp_abort < gpu_temp_retain)
13035 {
13036 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13037
13038 return (-1);
13039 }
13040 }
13041
13042 data.gpu_temp_disable = gpu_temp_disable;
13043 data.gpu_temp_abort = gpu_temp_abort;
13044 data.gpu_temp_retain = gpu_temp_retain;
13045 #endif
13046
13047 /**
13048 * inform the user
13049 */
13050
13051 if (data.quiet == 0)
13052 {
13053 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13054
13055 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);
13056
13057 if (attack_mode == ATTACK_MODE_STRAIGHT)
13058 {
13059 log_info ("Rules: %u", kernel_rules_cnt);
13060 }
13061
13062 if (opti_type)
13063 {
13064 log_info ("Applicable Optimizers:");
13065
13066 for (uint i = 0; i < 32; i++)
13067 {
13068 const uint opti_bit = 1u << i;
13069
13070 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13071 }
13072 }
13073
13074 /**
13075 * Watchdog and Temperature balance
13076 */
13077
13078 #ifdef HAVE_HWMON
13079 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13080 {
13081 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13082 }
13083
13084 if (gpu_temp_abort == 0)
13085 {
13086 log_info ("Watchdog: Temperature abort trigger disabled");
13087 }
13088 else
13089 {
13090 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13091 }
13092
13093 if (gpu_temp_retain == 0)
13094 {
13095 log_info ("Watchdog: Temperature retain trigger disabled");
13096 }
13097 else
13098 {
13099 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13100 }
13101 #endif
13102 }
13103
13104 if (data.quiet == 0) log_info ("");
13105
13106 /**
13107 * HM devices: copy
13108 */
13109
13110 if (gpu_temp_disable == 0)
13111 {
13112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13113 {
13114 hc_device_param_t *device_param = &data.devices_param[device_id];
13115
13116 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13117
13118 if (device_param->skipped) continue;
13119
13120 const uint platform_devices_id = device_param->platform_devices_id;
13121
13122 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13123 if (device_param->vendor_id == VENDOR_ID_NV)
13124 {
13125 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13126 }
13127 #endif
13128
13129 #ifdef HAVE_ADL
13130 if (device_param->vendor_id == VENDOR_ID_AMD)
13131 {
13132 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13133 }
13134 #endif
13135 }
13136 }
13137
13138 /*
13139 * Temporary fix:
13140 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13141 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13142 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13143 * Driver / ADL bug?
13144 */
13145
13146 #ifdef HAVE_ADL
13147 if (powertune_enable == 1)
13148 {
13149 hc_thread_mutex_lock (mux_adl);
13150
13151 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13152 {
13153 hc_device_param_t *device_param = &data.devices_param[device_id];
13154
13155 if (device_param->skipped) continue;
13156
13157 if (data.hm_device[device_id].od_version == 6)
13158 {
13159 // set powertune value only
13160
13161 int powertune_supported = 0;
13162
13163 int ADL_rc = 0;
13164
13165 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13166 {
13167 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13168
13169 return (-1);
13170 }
13171
13172 if (powertune_supported != 0)
13173 {
13174 // powertune set
13175 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13176
13177 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13178 {
13179 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13180
13181 return (-1);
13182 }
13183
13184 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13185 {
13186 log_error ("ERROR: Failed to set new ADL PowerControl values");
13187
13188 return (-1);
13189 }
13190 }
13191 }
13192 }
13193
13194 hc_thread_mutex_unlock (mux_adl);
13195 }
13196 #endif // HAVE_ADK
13197 #endif // HAVE_HWMON
13198
13199 #ifdef OSX
13200 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13201 {
13202 if (force == 0)
13203 {
13204 log_info ("");
13205 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13206 log_info ("You can use --force to override this but do not post error reports if you do so");
13207 log_info ("");
13208
13209 continue;
13210 }
13211 }
13212 #endif
13213
13214 #ifdef DEBUG
13215 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13216 #endif
13217
13218 uint kernel_power_all = 0;
13219
13220 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13221 {
13222 /**
13223 * host buffer
13224 */
13225
13226 hc_device_param_t *device_param = &data.devices_param[device_id];
13227
13228 if (device_param->skipped) continue;
13229
13230 /**
13231 * device properties
13232 */
13233
13234 const char *device_name_chksum = device_param->device_name_chksum;
13235 const u32 device_processors = device_param->device_processors;
13236 const u32 device_processor_cores = device_param->device_processor_cores;
13237
13238 /**
13239 * create context for each device
13240 */
13241
13242 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13243
13244 /**
13245 * create command-queue
13246 */
13247
13248 // not supported with NV
13249 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13250
13251 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13252
13253 /**
13254 * create input buffers on device : calculate size of fixed memory buffers
13255 */
13256
13257 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13258 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13259
13260 device_param->size_root_css = size_root_css;
13261 device_param->size_markov_css = size_markov_css;
13262
13263 uint size_results = KERNEL_THREADS * sizeof (uint);
13264
13265 device_param->size_results = size_results;
13266
13267 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13268 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13269
13270 uint size_plains = digests_cnt * sizeof (plain_t);
13271 uint size_salts = salts_cnt * sizeof (salt_t);
13272 uint size_esalts = salts_cnt * esalt_size;
13273
13274 device_param->size_plains = size_plains;
13275 device_param->size_digests = size_digests;
13276 device_param->size_shown = size_shown;
13277 device_param->size_salts = size_salts;
13278
13279 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13280 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13281 uint size_tm = 32 * sizeof (bs_word_t);
13282
13283 // scryptV stuff
13284
13285 u64 size_scryptV = 1;
13286
13287 if ((hash_mode == 8900) || (hash_mode == 9300))
13288 {
13289 uint tmto_start = 0;
13290 uint tmto_stop = 10;
13291
13292 if (scrypt_tmto)
13293 {
13294 tmto_start = scrypt_tmto;
13295 }
13296 else
13297 {
13298 // in case the user did not specify the tmto manually
13299 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13300 // but set the lower end only in case the user has a device with too less memory
13301
13302 if (hash_mode == 8900)
13303 {
13304 if (device_param->vendor_id == VENDOR_ID_AMD)
13305 {
13306 tmto_start = 1;
13307 }
13308 else if (device_param->vendor_id == VENDOR_ID_NV)
13309 {
13310 tmto_start = 3;
13311 }
13312 }
13313 else if (hash_mode == 9300)
13314 {
13315 if (device_param->vendor_id == VENDOR_ID_AMD)
13316 {
13317 tmto_start = 3;
13318 }
13319 else if (device_param->vendor_id == VENDOR_ID_NV)
13320 {
13321 tmto_start = 5;
13322 }
13323 }
13324 }
13325
13326 if (quiet == 0) log_info ("");
13327
13328 uint shader_per_mp = 1;
13329
13330 if (device_param->vendor_id == VENDOR_ID_AMD)
13331 {
13332 shader_per_mp = 8;
13333 }
13334 else if (device_param->vendor_id == VENDOR_ID_NV)
13335 {
13336 shader_per_mp = 32;
13337 }
13338
13339 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13340 {
13341 // TODO: in theory the following calculation needs to be done per salt, not global
13342 // we assume all hashes have the same scrypt settings
13343
13344 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13345
13346 size_scryptV /= 1 << tmto;
13347
13348 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13349
13350 if (size_scryptV > device_param->device_maxmem_alloc)
13351 {
13352 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13353
13354 continue;
13355 }
13356
13357 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13358 {
13359 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13360 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13361 }
13362
13363 break;
13364 }
13365
13366 if (data.salts_buf[0].scrypt_phy == 0)
13367 {
13368 log_error ("ERROR: can't allocate enough device memory");
13369
13370 return -1;
13371 }
13372
13373 if (quiet == 0) log_info ("");
13374 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13375 }
13376
13377 /**
13378 * create input buffers on device : calculate size of dynamic size memory buffers
13379 */
13380
13381 uint kernel_threads = KERNEL_THREADS;
13382
13383 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13384
13385 if (hash_mode == 3200) kernel_threads = 8;
13386 if (hash_mode == 9000) kernel_threads = 8;
13387
13388 /**
13389 * some algorithms need a fixed kernel-loops count
13390 */
13391
13392 u32 kernel_loops_min = 1;
13393 u32 kernel_loops_max = 1024;
13394
13395 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13396 {
13397 const u32 kernel_loops_fixed = 1024;
13398
13399 device_param->kernel_loops = kernel_loops_fixed;
13400
13401 kernel_loops_min = kernel_loops_fixed;
13402 kernel_loops_max = kernel_loops_fixed;
13403 }
13404
13405 if (hash_mode == 8900)
13406 {
13407 const u32 kernel_loops_fixed = 1;
13408
13409 device_param->kernel_loops = kernel_loops_fixed;
13410
13411 kernel_loops_min = kernel_loops_fixed;
13412 kernel_loops_max = kernel_loops_fixed;
13413 }
13414
13415 if (hash_mode == 9300)
13416 {
13417 const u32 kernel_loops_fixed = 1;
13418
13419 device_param->kernel_loops = kernel_loops_fixed;
13420
13421 kernel_loops_min = kernel_loops_fixed;
13422 kernel_loops_max = kernel_loops_fixed;
13423 }
13424
13425 if (hash_mode == 12500)
13426 {
13427 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13428
13429 device_param->kernel_loops = kernel_loops_fixed;
13430
13431 kernel_loops_min = kernel_loops_fixed;
13432 kernel_loops_max = kernel_loops_fixed;
13433 }
13434
13435 device_param->kernel_loops_min = kernel_loops_min;
13436 device_param->kernel_loops_max = kernel_loops_max;
13437
13438 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13439
13440 uint size_pws = 4;
13441 uint size_tmps = 4;
13442 uint size_hooks = 4;
13443
13444 uint kernel_accel_min = 1;
13445 uint kernel_accel_max = device_param->kernel_accel;
13446
13447 while (kernel_accel_max)
13448 {
13449 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13450
13451 // size_pws
13452
13453 size_pws = kernel_power_max * sizeof (pw_t);
13454
13455 // size_tmps
13456
13457 switch (hash_mode)
13458 {
13459 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13460 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13461 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13462 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13463 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13464 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13465 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13466 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13467 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13468 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13469 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13470 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13471 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13472 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13473 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13474 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13475 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13476 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13477 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13478 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13479 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13480 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13481 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13482 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13483 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13484 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13485 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13486 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13487 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13488 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13489 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13490 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13491 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13492 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13493 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13494 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13495 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13496 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13497 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13498 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13499 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13500 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13501 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13502 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13503 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13504 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13505 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13506 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13507 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13508 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13509 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13510 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13511 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13512 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13513 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13514 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13515 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13516 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13517 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13518 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13519 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13520 };
13521
13522 // size_hooks
13523
13524 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13525 {
13526 // none yet
13527 }
13528
13529 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13530 // if not, decrease amplifier and try again
13531
13532 int skip = 0;
13533
13534 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13535 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13536 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13537
13538 if (( bitmap_size
13539 + bitmap_size
13540 + bitmap_size
13541 + bitmap_size
13542 + bitmap_size
13543 + bitmap_size
13544 + bitmap_size
13545 + bitmap_size
13546 + size_bfs
13547 + size_combs
13548 + size_digests
13549 + size_esalts
13550 + size_hooks
13551 + size_markov_css
13552 + size_plains
13553 + size_pws
13554 + size_results
13555 + size_root_css
13556 + size_rules
13557 + size_rules_c
13558 + size_salts
13559 + size_scryptV
13560 + size_shown
13561 + size_tm
13562 + size_tmps) > device_param->device_global_mem) skip = 1;
13563
13564 if (skip == 1)
13565 {
13566 kernel_accel_max--;
13567
13568 continue;
13569 }
13570
13571 break;
13572 }
13573
13574 if (kernel_accel_max == 0)
13575 {
13576 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13577
13578 return -1;
13579 }
13580
13581 device_param->kernel_accel_min = kernel_accel_min;
13582 device_param->kernel_accel_max = kernel_accel_max;
13583
13584 if (kernel_accel_max < kernel_accel)
13585 {
13586 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13587
13588 device_param->kernel_accel = kernel_accel_max;
13589 }
13590
13591 const u32 kernel_accel = device_param->kernel_accel;
13592
13593 device_param->size_pws = size_pws;
13594 device_param->size_tmps = size_tmps;
13595 device_param->size_hooks = size_hooks;
13596
13597 // do not confuse kernel_accel_max with kernel_accel here
13598
13599 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13600
13601 device_param->kernel_threads = kernel_threads;
13602 device_param->kernel_power_user = kernel_power;
13603
13604 kernel_power_all += kernel_power;
13605
13606 /**
13607 * default building options
13608 */
13609
13610 char build_opts[1024] = { 0 };
13611
13612 // we don't have sm_* on vendors not NV but it doesn't matter
13613
13614 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13615
13616 /**
13617 * main kernel
13618 */
13619
13620 {
13621 /**
13622 * kernel source filename
13623 */
13624
13625 char source_file[256] = { 0 };
13626
13627 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13628
13629 struct stat sst;
13630
13631 if (stat (source_file, &sst) == -1)
13632 {
13633 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13634
13635 return -1;
13636 }
13637
13638 /**
13639 * kernel cached filename
13640 */
13641
13642 char cached_file[256] = { 0 };
13643
13644 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13645
13646 int cached = 1;
13647
13648 struct stat cst;
13649
13650 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13651 {
13652 cached = 0;
13653 }
13654
13655 /**
13656 * kernel compile or load
13657 */
13658
13659 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13660
13661 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13662
13663 if (force_jit_compilation == -1)
13664 {
13665 if (cached == 0)
13666 {
13667 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13668
13669 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13670
13671 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13672
13673 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13674
13675 if (rc != 0)
13676 {
13677 device_param->skipped = true;
13678 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13679 continue;
13680 }
13681
13682 size_t binary_size;
13683
13684 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13685
13686 u8 *binary = (u8 *) mymalloc (binary_size);
13687
13688 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13689
13690 writeProgramBin (cached_file, binary, binary_size);
13691
13692 local_free (binary);
13693 }
13694 else
13695 {
13696 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13697
13698 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13699
13700 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13701
13702 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13703 }
13704 }
13705 else
13706 {
13707 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13708
13709 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13710
13711 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13712
13713 char build_opts_update[1024] = { 0 };
13714
13715 if (force_jit_compilation == 1500)
13716 {
13717 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13718 }
13719 else if (force_jit_compilation == 8900)
13720 {
13721 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);
13722 }
13723
13724 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13725
13726 if (rc != 0)
13727 {
13728 device_param->skipped = true;
13729 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13730 }
13731 }
13732
13733 local_free (kernel_lengths);
13734 local_free (kernel_sources[0]);
13735 local_free (kernel_sources);
13736 }
13737
13738 /**
13739 * word generator kernel
13740 */
13741
13742 if (attack_mode != ATTACK_MODE_STRAIGHT)
13743 {
13744 /**
13745 * kernel mp source filename
13746 */
13747
13748 char source_file[256] = { 0 };
13749
13750 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13751
13752 struct stat sst;
13753
13754 if (stat (source_file, &sst) == -1)
13755 {
13756 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13757
13758 return -1;
13759 }
13760
13761 /**
13762 * kernel mp cached filename
13763 */
13764
13765 char cached_file[256] = { 0 };
13766
13767 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13768
13769 int cached = 1;
13770
13771 struct stat cst;
13772
13773 if (stat (cached_file, &cst) == -1)
13774 {
13775 cached = 0;
13776 }
13777
13778 /**
13779 * kernel compile or load
13780 */
13781
13782 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13783
13784 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13785
13786 if (cached == 0)
13787 {
13788 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13789
13790 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13791
13792 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13793
13794 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13795
13796 if (rc != 0)
13797 {
13798 device_param->skipped = true;
13799 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13800 continue;
13801 }
13802
13803 size_t binary_size;
13804
13805 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13806
13807 u8 *binary = (u8 *) mymalloc (binary_size);
13808
13809 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13810
13811 writeProgramBin (cached_file, binary, binary_size);
13812
13813 local_free (binary);
13814 }
13815 else
13816 {
13817 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13818
13819 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13820
13821 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13822
13823 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13824 }
13825
13826 local_free (kernel_lengths);
13827 local_free (kernel_sources[0]);
13828 local_free (kernel_sources);
13829 }
13830
13831 /**
13832 * amplifier kernel
13833 */
13834
13835 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13836 {
13837
13838 }
13839 else
13840 {
13841 /**
13842 * kernel amp source filename
13843 */
13844
13845 char source_file[256] = { 0 };
13846
13847 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13848
13849 struct stat sst;
13850
13851 if (stat (source_file, &sst) == -1)
13852 {
13853 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13854
13855 return -1;
13856 }
13857
13858 /**
13859 * kernel amp cached filename
13860 */
13861
13862 char cached_file[256] = { 0 };
13863
13864 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13865
13866 int cached = 1;
13867
13868 struct stat cst;
13869
13870 if (stat (cached_file, &cst) == -1)
13871 {
13872 cached = 0;
13873 }
13874
13875 /**
13876 * kernel compile or load
13877 */
13878
13879 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13880
13881 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13882
13883 if (cached == 0)
13884 {
13885 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13886
13887 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13888
13889 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13890
13891 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13892
13893 if (rc != 0)
13894 {
13895 device_param->skipped = true;
13896 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13897 continue;
13898 }
13899
13900 size_t binary_size;
13901
13902 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13903
13904 u8 *binary = (u8 *) mymalloc (binary_size);
13905
13906 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13907
13908 writeProgramBin (cached_file, binary, binary_size);
13909
13910 local_free (binary);
13911 }
13912 else
13913 {
13914 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13915
13916 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13917
13918 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13919
13920 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
13921 }
13922
13923 local_free (kernel_lengths);
13924 local_free (kernel_sources[0]);
13925 local_free (kernel_sources);
13926 }
13927
13928 // some algorithm collide too fast, make that impossible
13929
13930 if (benchmark == 1)
13931 {
13932 ((uint *) digests_buf)[0] = -1;
13933 ((uint *) digests_buf)[1] = -1;
13934 ((uint *) digests_buf)[2] = -1;
13935 ((uint *) digests_buf)[3] = -1;
13936 }
13937
13938 /**
13939 * global buffers
13940 */
13941
13942 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13943 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13944 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13945 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13946 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13947 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13948 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13949 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13950 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13951 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13952 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13953 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13954 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13955 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13956 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13957 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13958 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13959 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13960
13961 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);
13962 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);
13963 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);
13964 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);
13965 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);
13966 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);
13967 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);
13968 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);
13969 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13970 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13971 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13972
13973 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13974 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13975 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13976 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13977 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13978 run_kernel_bzero (device_param, device_param->d_result, size_results);
13979
13980 /**
13981 * special buffers
13982 */
13983
13984 if (attack_kern == ATTACK_KERN_STRAIGHT)
13985 {
13986 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13987 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13988
13989 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13990
13991 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13992 }
13993 else if (attack_kern == ATTACK_KERN_COMBI)
13994 {
13995 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13996 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13997 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13998 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13999
14000 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14001 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14002 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14003 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14004 }
14005 else if (attack_kern == ATTACK_KERN_BF)
14006 {
14007 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14008 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14009 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14010 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14011 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14012
14013 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14014 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14015 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14016 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14017 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14018 }
14019
14020 if (size_esalts)
14021 {
14022 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14023
14024 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14025 }
14026
14027 /**
14028 * main host data
14029 */
14030
14031 uint *result = (uint *) mymalloc (size_results);
14032
14033 device_param->result = result;
14034
14035 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14036
14037 device_param->pws_buf = pws_buf;
14038
14039 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14040
14041 for (int i = 0; i < 64; i++)
14042 {
14043 pw_caches[i].pw_buf.pw_len = i;
14044 pw_caches[i].cnt = 0;
14045 }
14046
14047 device_param->pw_caches = pw_caches;
14048
14049 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14050
14051 device_param->combs_buf = combs_buf;
14052
14053 void *hooks_buf = mymalloc (size_hooks);
14054
14055 device_param->hooks_buf = hooks_buf;
14056
14057 device_param->pw_transpose = pw_transpose_to_hi1;
14058 device_param->pw_add = pw_add_to_hc1;
14059
14060 /**
14061 * kernel args
14062 */
14063
14064 device_param->kernel_params_buf32[21] = bitmap_mask;
14065 device_param->kernel_params_buf32[22] = bitmap_shift1;
14066 device_param->kernel_params_buf32[23] = bitmap_shift2;
14067 device_param->kernel_params_buf32[24] = 0; // salt_pos
14068 device_param->kernel_params_buf32[25] = 0; // loop_pos
14069 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14070 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14071 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14072 device_param->kernel_params_buf32[29] = 0; // digests_offset
14073 device_param->kernel_params_buf32[30] = 0; // combs_mode
14074 device_param->kernel_params_buf32[31] = 0; // gid_max
14075
14076 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14077 ? &device_param->d_pws_buf
14078 : &device_param->d_pws_amp_buf;
14079 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14080 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14081 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14082 device_param->kernel_params[ 4] = &device_param->d_tmps;
14083 device_param->kernel_params[ 5] = &device_param->d_hooks;
14084 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14085 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14086 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14087 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14088 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14089 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14090 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14091 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14092 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14093 device_param->kernel_params[15] = &device_param->d_digests_buf;
14094 device_param->kernel_params[16] = &device_param->d_digests_shown;
14095 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14096 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14097 device_param->kernel_params[19] = &device_param->d_result;
14098 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14099 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14100 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14101 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14102 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14103 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14104 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14105 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14106 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14107 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14108 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14109 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14110
14111 device_param->kernel_params_mp_buf64[3] = 0;
14112 device_param->kernel_params_mp_buf32[4] = 0;
14113 device_param->kernel_params_mp_buf32[5] = 0;
14114 device_param->kernel_params_mp_buf32[6] = 0;
14115 device_param->kernel_params_mp_buf32[7] = 0;
14116 device_param->kernel_params_mp_buf32[8] = 0;
14117
14118 device_param->kernel_params_mp[0] = NULL;
14119 device_param->kernel_params_mp[1] = NULL;
14120 device_param->kernel_params_mp[2] = NULL;
14121 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14122 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14123 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14124 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14125 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14126 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14127
14128 device_param->kernel_params_mp_l_buf64[3] = 0;
14129 device_param->kernel_params_mp_l_buf32[4] = 0;
14130 device_param->kernel_params_mp_l_buf32[5] = 0;
14131 device_param->kernel_params_mp_l_buf32[6] = 0;
14132 device_param->kernel_params_mp_l_buf32[7] = 0;
14133 device_param->kernel_params_mp_l_buf32[8] = 0;
14134 device_param->kernel_params_mp_l_buf32[9] = 0;
14135
14136 device_param->kernel_params_mp_l[0] = NULL;
14137 device_param->kernel_params_mp_l[1] = NULL;
14138 device_param->kernel_params_mp_l[2] = NULL;
14139 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14140 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14141 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14142 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14143 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14144 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14145 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14146
14147 device_param->kernel_params_mp_r_buf64[3] = 0;
14148 device_param->kernel_params_mp_r_buf32[4] = 0;
14149 device_param->kernel_params_mp_r_buf32[5] = 0;
14150 device_param->kernel_params_mp_r_buf32[6] = 0;
14151 device_param->kernel_params_mp_r_buf32[7] = 0;
14152 device_param->kernel_params_mp_r_buf32[8] = 0;
14153
14154 device_param->kernel_params_mp_r[0] = NULL;
14155 device_param->kernel_params_mp_r[1] = NULL;
14156 device_param->kernel_params_mp_r[2] = NULL;
14157 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14158 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14159 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14160 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14161 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14162 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14163
14164 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14165 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14166
14167 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14168 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14169 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14170 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14171 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14172 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14173 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14174
14175 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14176
14177 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14178 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14179
14180 /**
14181 * kernel name
14182 */
14183
14184 char kernel_name[64] = { 0 };
14185
14186 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14187 {
14188 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14189 {
14190 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14191
14192 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14193
14194 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14195
14196 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14197
14198 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14199
14200 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14201 }
14202 else
14203 {
14204 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14205
14206 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14207
14208 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14209
14210 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14211
14212 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14213
14214 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14215 }
14216
14217 if (data.attack_mode == ATTACK_MODE_BF)
14218 {
14219 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14220 {
14221 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14222
14223 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14224
14225 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14226
14227 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14228 }
14229 }
14230 }
14231 else
14232 {
14233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14234
14235 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14236
14237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14238
14239 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14240
14241 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14242
14243 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14244
14245 if (opts_type & OPTS_TYPE_HOOK12)
14246 {
14247 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14248
14249 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14250 }
14251
14252 if (opts_type & OPTS_TYPE_HOOK23)
14253 {
14254 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14255
14256 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14257 }
14258 }
14259
14260 for (uint i = 0; i <= 20; i++)
14261 {
14262 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14263 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14264 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14265
14266 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14267 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14268 }
14269
14270 for (uint i = 21; i <= 31; i++)
14271 {
14272 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14273 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14274 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14275
14276 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14277 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14278 }
14279
14280 if (attack_mode == ATTACK_MODE_BF)
14281 {
14282 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14283 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14284
14285 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14286 {
14287 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14288
14289 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14290 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14291 }
14292 }
14293 else if (attack_mode == ATTACK_MODE_HYBRID1)
14294 {
14295 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14296 }
14297 else if (attack_mode == ATTACK_MODE_HYBRID2)
14298 {
14299 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14300 }
14301
14302 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14303 {
14304 // nothing to do
14305 }
14306 else
14307 {
14308 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14309 }
14310
14311 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14312 {
14313 // nothing to do
14314 }
14315 else
14316 {
14317 for (uint i = 0; i < 5; i++)
14318 {
14319 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14320 }
14321
14322 for (uint i = 5; i < 7; i++)
14323 {
14324 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14325 }
14326 }
14327
14328 /**
14329 * Store initial fanspeed if gpu_temp_retain is enabled
14330 */
14331
14332 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14333 int gpu_temp_retain_set = 0;
14334
14335 if (gpu_temp_disable == 0)
14336 {
14337 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14338 {
14339 hc_thread_mutex_lock (mux_adl);
14340
14341 if (data.hm_device[device_id].fan_supported == 1)
14342 {
14343 if (gpu_temp_retain_chgd == 0)
14344 {
14345 uint cur_temp = 0;
14346 uint default_temp = 0;
14347
14348 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);
14349
14350 if (ADL_rc == ADL_OK)
14351 {
14352 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14353
14354 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14355
14356 // special case with multi gpu setups: always use minimum retain
14357
14358 if (gpu_temp_retain_set == 0)
14359 {
14360 gpu_temp_retain = gpu_temp_retain_target;
14361 gpu_temp_retain_set = 1;
14362 }
14363 else
14364 {
14365 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14366 }
14367
14368 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14369 }
14370 }
14371
14372 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14373
14374 temp_retain_fanspeed_value[device_id] = fan_speed;
14375
14376 if (fan_speed == -1)
14377 {
14378 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14379
14380 temp_retain_fanspeed_value[device_id] = 0;
14381 }
14382 }
14383
14384 hc_thread_mutex_unlock (mux_adl);
14385 }
14386 }
14387
14388 /**
14389 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14390 */
14391
14392 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14393 {
14394 hc_thread_mutex_lock (mux_adl);
14395
14396 if (data.hm_device[device_id].od_version == 6)
14397 {
14398 int ADL_rc;
14399
14400 // check powertune capabilities first, if not available then skip device
14401
14402 int powertune_supported = 0;
14403
14404 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14405 {
14406 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14407
14408 return (-1);
14409 }
14410
14411 if (powertune_supported != 0)
14412 {
14413 // powercontrol settings
14414
14415 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14416
14417 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14418 {
14419 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14420 }
14421
14422 if (ADL_rc != ADL_OK)
14423 {
14424 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14425
14426 return (-1);
14427 }
14428
14429 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14430 {
14431 log_error ("ERROR: Failed to set new ADL PowerControl values");
14432
14433 return (-1);
14434 }
14435
14436 // clocks
14437
14438 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14439
14440 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14441
14442 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)
14443 {
14444 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14445
14446 return (-1);
14447 }
14448
14449 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14450
14451 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14452
14453 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14454 {
14455 log_error ("ERROR: Failed to get ADL device capabilities");
14456
14457 return (-1);
14458 }
14459
14460 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14461 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14462
14463 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14464 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14465
14466 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14467 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14468
14469 // warning if profile has too low max values
14470
14471 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14472 {
14473 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14474 }
14475
14476 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14477 {
14478 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14479 }
14480
14481 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14482
14483 performance_state->iNumberOfPerformanceLevels = 2;
14484
14485 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14486 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14487 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14488 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14489
14490 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)
14491 {
14492 log_info ("ERROR: Failed to set ADL performance state");
14493
14494 return (-1);
14495 }
14496
14497 local_free (performance_state);
14498 }
14499 }
14500
14501 hc_thread_mutex_unlock (mux_adl);
14502 }
14503 #endif // HAVE_HWMON && HAVE_ADL
14504 }
14505
14506 data.kernel_power_all = kernel_power_all;
14507
14508 if (data.quiet == 0) log_info ("");
14509
14510 /**
14511 * Inform user which algorithm is checked and at which workload setting
14512 */
14513
14514 if (benchmark == 1)
14515 {
14516 quiet = 0;
14517
14518 data.quiet = quiet;
14519
14520 char *hash_type = strhashtype (data.hash_mode); // not a bug
14521
14522 log_info ("Hashtype: %s", hash_type);
14523 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14524 log_info ("");
14525 }
14526
14527 /**
14528 * keep track of the progress
14529 */
14530
14531 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14532 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14533 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14534
14535 /**
14536 * open filehandles
14537 */
14538
14539 #if _WIN
14540 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14541 {
14542 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14543
14544 return (-1);
14545 }
14546
14547 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14548 {
14549 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14550
14551 return (-1);
14552 }
14553
14554 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14555 {
14556 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14557
14558 return (-1);
14559 }
14560 #endif
14561
14562 /**
14563 * dictionary pad
14564 */
14565
14566 segment_size *= (1024 * 1024);
14567
14568 data.segment_size = segment_size;
14569
14570 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14571
14572 wl_data->buf = (char *) mymalloc (segment_size);
14573 wl_data->avail = segment_size;
14574 wl_data->incr = segment_size;
14575 wl_data->cnt = 0;
14576 wl_data->pos = 0;
14577
14578 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14579
14580 data.wordlist_mode = wordlist_mode;
14581
14582 cs_t *css_buf = NULL;
14583 uint css_cnt = 0;
14584 uint dictcnt = 0;
14585 uint maskcnt = 1;
14586 char **masks = NULL;
14587 char **dictfiles = NULL;
14588
14589 uint mask_from_file = 0;
14590
14591 if (attack_mode == ATTACK_MODE_STRAIGHT)
14592 {
14593 if (wordlist_mode == WL_MODE_FILE)
14594 {
14595 int wls_left = myargc - (optind + 1);
14596
14597 for (int i = 0; i < wls_left; i++)
14598 {
14599 char *l0_filename = myargv[optind + 1 + i];
14600
14601 struct stat l0_stat;
14602
14603 if (stat (l0_filename, &l0_stat) == -1)
14604 {
14605 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14606
14607 return (-1);
14608 }
14609
14610 uint is_dir = S_ISDIR (l0_stat.st_mode);
14611
14612 if (is_dir == 0)
14613 {
14614 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14615
14616 dictcnt++;
14617
14618 dictfiles[dictcnt - 1] = l0_filename;
14619 }
14620 else
14621 {
14622 // do not allow --keyspace w/ a directory
14623
14624 if (keyspace == 1)
14625 {
14626 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14627
14628 return (-1);
14629 }
14630
14631 char **dictionary_files = NULL;
14632
14633 dictionary_files = scan_directory (l0_filename);
14634
14635 if (dictionary_files != NULL)
14636 {
14637 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14638
14639 for (int d = 0; dictionary_files[d] != NULL; d++)
14640 {
14641 char *l1_filename = dictionary_files[d];
14642
14643 struct stat l1_stat;
14644
14645 if (stat (l1_filename, &l1_stat) == -1)
14646 {
14647 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14648
14649 return (-1);
14650 }
14651
14652 if (S_ISREG (l1_stat.st_mode))
14653 {
14654 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14655
14656 dictcnt++;
14657
14658 dictfiles[dictcnt - 1] = strdup (l1_filename);
14659 }
14660 }
14661 }
14662
14663 local_free (dictionary_files);
14664 }
14665 }
14666
14667 if (dictcnt < 1)
14668 {
14669 log_error ("ERROR: No usable dictionary file found.");
14670
14671 return (-1);
14672 }
14673 }
14674 else if (wordlist_mode == WL_MODE_STDIN)
14675 {
14676 dictcnt = 1;
14677 }
14678 }
14679 else if (attack_mode == ATTACK_MODE_COMBI)
14680 {
14681 // display
14682
14683 char *dictfile1 = myargv[optind + 1 + 0];
14684 char *dictfile2 = myargv[optind + 1 + 1];
14685
14686 // find the bigger dictionary and use as base
14687
14688 FILE *fp1 = NULL;
14689 FILE *fp2 = NULL;
14690
14691 struct stat tmp_stat;
14692
14693 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14694 {
14695 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14696
14697 return (-1);
14698 }
14699
14700 if (stat (dictfile1, &tmp_stat) == -1)
14701 {
14702 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14703
14704 fclose (fp1);
14705
14706 return (-1);
14707 }
14708
14709 if (S_ISDIR (tmp_stat.st_mode))
14710 {
14711 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14712
14713 fclose (fp1);
14714
14715 return (-1);
14716 }
14717
14718 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14719 {
14720 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14721
14722 fclose (fp1);
14723
14724 return (-1);
14725 }
14726
14727 if (stat (dictfile2, &tmp_stat) == -1)
14728 {
14729 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14730
14731 fclose (fp1);
14732 fclose (fp2);
14733
14734 return (-1);
14735 }
14736
14737 if (S_ISDIR (tmp_stat.st_mode))
14738 {
14739 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14740
14741 fclose (fp1);
14742 fclose (fp2);
14743
14744 return (-1);
14745 }
14746
14747 data.combs_cnt = 1;
14748
14749 data.quiet = 1;
14750
14751 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14752
14753 data.quiet = quiet;
14754
14755 if (words1_cnt == 0)
14756 {
14757 log_error ("ERROR: %s: empty file", dictfile1);
14758
14759 fclose (fp1);
14760 fclose (fp2);
14761
14762 return (-1);
14763 }
14764
14765 data.combs_cnt = 1;
14766
14767 data.quiet = 1;
14768
14769 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14770
14771 data.quiet = quiet;
14772
14773 if (words2_cnt == 0)
14774 {
14775 log_error ("ERROR: %s: empty file", dictfile2);
14776
14777 fclose (fp1);
14778 fclose (fp2);
14779
14780 return (-1);
14781 }
14782
14783 fclose (fp1);
14784 fclose (fp2);
14785
14786 data.dictfile = dictfile1;
14787 data.dictfile2 = dictfile2;
14788
14789 if (words1_cnt >= words2_cnt)
14790 {
14791 data.combs_cnt = words2_cnt;
14792 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14793
14794 dictfiles = &data.dictfile;
14795
14796 dictcnt = 1;
14797 }
14798 else
14799 {
14800 data.combs_cnt = words1_cnt;
14801 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14802
14803 dictfiles = &data.dictfile2;
14804
14805 dictcnt = 1;
14806
14807 // we also have to switch wordlist related rules!
14808
14809 char *tmpc = data.rule_buf_l;
14810
14811 data.rule_buf_l = data.rule_buf_r;
14812 data.rule_buf_r = tmpc;
14813
14814 int tmpi = data.rule_len_l;
14815
14816 data.rule_len_l = data.rule_len_r;
14817 data.rule_len_r = tmpi;
14818 }
14819 }
14820 else if (attack_mode == ATTACK_MODE_BF)
14821 {
14822 char *mask = NULL;
14823
14824 maskcnt = 0;
14825
14826 if (benchmark == 0)
14827 {
14828 mask = myargv[optind + 1];
14829
14830 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14831
14832 if ((optind + 2) <= myargc)
14833 {
14834 struct stat file_stat;
14835
14836 if (stat (mask, &file_stat) == -1)
14837 {
14838 maskcnt = 1;
14839
14840 masks[maskcnt - 1] = mystrdup (mask);
14841 }
14842 else
14843 {
14844 int wls_left = myargc - (optind + 1);
14845
14846 uint masks_avail = INCR_MASKS;
14847
14848 for (int i = 0; i < wls_left; i++)
14849 {
14850 if (i != 0)
14851 {
14852 mask = myargv[optind + 1 + i];
14853
14854 if (stat (mask, &file_stat) == -1)
14855 {
14856 log_error ("ERROR: %s: %s", mask, strerror (errno));
14857
14858 return (-1);
14859 }
14860 }
14861
14862 uint is_file = S_ISREG (file_stat.st_mode);
14863
14864 if (is_file == 1)
14865 {
14866 FILE *mask_fp;
14867
14868 if ((mask_fp = fopen (mask, "r")) == NULL)
14869 {
14870 log_error ("ERROR: %s: %s", mask, strerror (errno));
14871
14872 return (-1);
14873 }
14874
14875 char line_buf[BUFSIZ] = { 0 };
14876
14877 while (!feof (mask_fp))
14878 {
14879 memset (line_buf, 0, BUFSIZ);
14880
14881 int line_len = fgetl (mask_fp, line_buf);
14882
14883 if (line_len == 0) continue;
14884
14885 if (line_buf[0] == '#') continue;
14886
14887 if (masks_avail == maskcnt)
14888 {
14889 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14890
14891 masks_avail += INCR_MASKS;
14892 }
14893
14894 masks[maskcnt] = mystrdup (line_buf);
14895
14896 maskcnt++;
14897 }
14898
14899 fclose (mask_fp);
14900 }
14901 else
14902 {
14903 log_error ("ERROR: %s: unsupported file-type", mask);
14904
14905 return (-1);
14906 }
14907 }
14908
14909 mask_from_file = 1;
14910 }
14911 }
14912 else
14913 {
14914 custom_charset_1 = (char *) "?l?d?u";
14915 custom_charset_2 = (char *) "?l?d";
14916 custom_charset_3 = (char *) "?l?d*!$@_";
14917
14918 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14919 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14920 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14921
14922 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14923
14924 wordlist_mode = WL_MODE_MASK;
14925
14926 data.wordlist_mode = wordlist_mode;
14927
14928 increment = 1;
14929
14930 maskcnt = 1;
14931 }
14932 }
14933 else
14934 {
14935 /**
14936 * generate full masks and charsets
14937 */
14938
14939 masks = (char **) mymalloc (sizeof (char *));
14940
14941 switch (hash_mode)
14942 {
14943 case 1731: pw_min = 5;
14944 pw_max = 5;
14945 mask = mystrdup ("?b?b?b?b?b");
14946 break;
14947 case 12500: pw_min = 5;
14948 pw_max = 5;
14949 mask = mystrdup ("?b?b?b?b?b");
14950 break;
14951 default: pw_min = 7;
14952 pw_max = 7;
14953 mask = mystrdup ("?b?b?b?b?b?b?b");
14954 break;
14955 }
14956
14957 maskcnt = 1;
14958
14959 masks[maskcnt - 1] = mystrdup (mask);
14960
14961 wordlist_mode = WL_MODE_MASK;
14962
14963 data.wordlist_mode = wordlist_mode;
14964
14965 increment = 1;
14966 }
14967
14968 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14969
14970 if (increment)
14971 {
14972 if (increment_min > pw_min) pw_min = increment_min;
14973
14974 if (increment_max < pw_max) pw_max = increment_max;
14975 }
14976 }
14977 else if (attack_mode == ATTACK_MODE_HYBRID1)
14978 {
14979 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14980
14981 // display
14982
14983 char *mask = myargv[myargc - 1];
14984
14985 maskcnt = 0;
14986
14987 masks = (char **) mymalloc (1 * sizeof (char *));
14988
14989 // mod
14990
14991 struct stat file_stat;
14992
14993 if (stat (mask, &file_stat) == -1)
14994 {
14995 maskcnt = 1;
14996
14997 masks[maskcnt - 1] = mystrdup (mask);
14998 }
14999 else
15000 {
15001 uint is_file = S_ISREG (file_stat.st_mode);
15002
15003 if (is_file == 1)
15004 {
15005 FILE *mask_fp;
15006
15007 if ((mask_fp = fopen (mask, "r")) == NULL)
15008 {
15009 log_error ("ERROR: %s: %s", mask, strerror (errno));
15010
15011 return (-1);
15012 }
15013
15014 char line_buf[BUFSIZ] = { 0 };
15015
15016 uint masks_avail = 1;
15017
15018 while (!feof (mask_fp))
15019 {
15020 memset (line_buf, 0, BUFSIZ);
15021
15022 int line_len = fgetl (mask_fp, line_buf);
15023
15024 if (line_len == 0) continue;
15025
15026 if (line_buf[0] == '#') continue;
15027
15028 if (masks_avail == maskcnt)
15029 {
15030 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15031
15032 masks_avail += INCR_MASKS;
15033 }
15034
15035 masks[maskcnt] = mystrdup (line_buf);
15036
15037 maskcnt++;
15038 }
15039
15040 fclose (mask_fp);
15041
15042 mask_from_file = 1;
15043 }
15044 else
15045 {
15046 maskcnt = 1;
15047
15048 masks[maskcnt - 1] = mystrdup (mask);
15049 }
15050 }
15051
15052 // base
15053
15054 int wls_left = myargc - (optind + 2);
15055
15056 for (int i = 0; i < wls_left; i++)
15057 {
15058 char *filename = myargv[optind + 1 + i];
15059
15060 struct stat file_stat;
15061
15062 if (stat (filename, &file_stat) == -1)
15063 {
15064 log_error ("ERROR: %s: %s", filename, strerror (errno));
15065
15066 return (-1);
15067 }
15068
15069 uint is_dir = S_ISDIR (file_stat.st_mode);
15070
15071 if (is_dir == 0)
15072 {
15073 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15074
15075 dictcnt++;
15076
15077 dictfiles[dictcnt - 1] = filename;
15078 }
15079 else
15080 {
15081 // do not allow --keyspace w/ a directory
15082
15083 if (keyspace == 1)
15084 {
15085 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15086
15087 return (-1);
15088 }
15089
15090 char **dictionary_files = NULL;
15091
15092 dictionary_files = scan_directory (filename);
15093
15094 if (dictionary_files != NULL)
15095 {
15096 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15097
15098 for (int d = 0; dictionary_files[d] != NULL; d++)
15099 {
15100 char *l1_filename = dictionary_files[d];
15101
15102 struct stat l1_stat;
15103
15104 if (stat (l1_filename, &l1_stat) == -1)
15105 {
15106 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15107
15108 return (-1);
15109 }
15110
15111 if (S_ISREG (l1_stat.st_mode))
15112 {
15113 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15114
15115 dictcnt++;
15116
15117 dictfiles[dictcnt - 1] = strdup (l1_filename);
15118 }
15119 }
15120 }
15121
15122 local_free (dictionary_files);
15123 }
15124 }
15125
15126 if (dictcnt < 1)
15127 {
15128 log_error ("ERROR: No usable dictionary file found.");
15129
15130 return (-1);
15131 }
15132
15133 if (increment)
15134 {
15135 maskcnt = 0;
15136
15137 uint mask_min = increment_min; // we can't reject smaller masks here
15138 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15139
15140 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15141 {
15142 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15143
15144 if (cur_mask == NULL) break;
15145
15146 masks[maskcnt] = cur_mask;
15147
15148 maskcnt++;
15149
15150 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15151 }
15152 }
15153 }
15154 else if (attack_mode == ATTACK_MODE_HYBRID2)
15155 {
15156 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15157
15158 // display
15159
15160 char *mask = myargv[optind + 1 + 0];
15161
15162 maskcnt = 0;
15163
15164 masks = (char **) mymalloc (1 * sizeof (char *));
15165
15166 // mod
15167
15168 struct stat file_stat;
15169
15170 if (stat (mask, &file_stat) == -1)
15171 {
15172 maskcnt = 1;
15173
15174 masks[maskcnt - 1] = mystrdup (mask);
15175 }
15176 else
15177 {
15178 uint is_file = S_ISREG (file_stat.st_mode);
15179
15180 if (is_file == 1)
15181 {
15182 FILE *mask_fp;
15183
15184 if ((mask_fp = fopen (mask, "r")) == NULL)
15185 {
15186 log_error ("ERROR: %s: %s", mask, strerror (errno));
15187
15188 return (-1);
15189 }
15190
15191 char line_buf[BUFSIZ] = { 0 };
15192
15193 uint masks_avail = 1;
15194
15195 while (!feof (mask_fp))
15196 {
15197 memset (line_buf, 0, BUFSIZ);
15198
15199 int line_len = fgetl (mask_fp, line_buf);
15200
15201 if (line_len == 0) continue;
15202
15203 if (line_buf[0] == '#') continue;
15204
15205 if (masks_avail == maskcnt)
15206 {
15207 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15208
15209 masks_avail += INCR_MASKS;
15210 }
15211
15212 masks[maskcnt] = mystrdup (line_buf);
15213
15214 maskcnt++;
15215 }
15216
15217 fclose (mask_fp);
15218
15219 mask_from_file = 1;
15220 }
15221 else
15222 {
15223 maskcnt = 1;
15224
15225 masks[maskcnt - 1] = mystrdup (mask);
15226 }
15227 }
15228
15229 // base
15230
15231 int wls_left = myargc - (optind + 2);
15232
15233 for (int i = 0; i < wls_left; i++)
15234 {
15235 char *filename = myargv[optind + 2 + i];
15236
15237 struct stat file_stat;
15238
15239 if (stat (filename, &file_stat) == -1)
15240 {
15241 log_error ("ERROR: %s: %s", filename, strerror (errno));
15242
15243 return (-1);
15244 }
15245
15246 uint is_dir = S_ISDIR (file_stat.st_mode);
15247
15248 if (is_dir == 0)
15249 {
15250 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15251
15252 dictcnt++;
15253
15254 dictfiles[dictcnt - 1] = filename;
15255 }
15256 else
15257 {
15258 // do not allow --keyspace w/ a directory
15259
15260 if (keyspace == 1)
15261 {
15262 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15263
15264 return (-1);
15265 }
15266
15267 char **dictionary_files = NULL;
15268
15269 dictionary_files = scan_directory (filename);
15270
15271 if (dictionary_files != NULL)
15272 {
15273 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15274
15275 for (int d = 0; dictionary_files[d] != NULL; d++)
15276 {
15277 char *l1_filename = dictionary_files[d];
15278
15279 struct stat l1_stat;
15280
15281 if (stat (l1_filename, &l1_stat) == -1)
15282 {
15283 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15284
15285 return (-1);
15286 }
15287
15288 if (S_ISREG (l1_stat.st_mode))
15289 {
15290 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15291
15292 dictcnt++;
15293
15294 dictfiles[dictcnt - 1] = strdup (l1_filename);
15295 }
15296 }
15297 }
15298
15299 local_free (dictionary_files);
15300 }
15301 }
15302
15303 if (dictcnt < 1)
15304 {
15305 log_error ("ERROR: No usable dictionary file found.");
15306
15307 return (-1);
15308 }
15309
15310 if (increment)
15311 {
15312 maskcnt = 0;
15313
15314 uint mask_min = increment_min; // we can't reject smaller masks here
15315 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15316
15317 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15318 {
15319 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15320
15321 if (cur_mask == NULL) break;
15322
15323 masks[maskcnt] = cur_mask;
15324
15325 maskcnt++;
15326
15327 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15328 }
15329 }
15330 }
15331
15332 data.pw_min = pw_min;
15333 data.pw_max = pw_max;
15334
15335 /**
15336 * weak hash check
15337 */
15338
15339 if (weak_hash_threshold >= salts_cnt)
15340 {
15341 hc_device_param_t *device_param = NULL;
15342
15343 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15344 {
15345 device_param = &data.devices_param[device_id];
15346
15347 if (device_param->skipped) continue;
15348
15349 break;
15350 }
15351
15352 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15353
15354 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15355 {
15356 weak_hash_check (device_param, salt_pos);
15357 }
15358 }
15359
15360 // Display hack, guarantee that there is at least one \r before real start
15361
15362 if (data.quiet == 0) log_info_nn ("");
15363
15364 /**
15365 * status and monitor threads
15366 */
15367
15368 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15369
15370 hc_thread_t i_thread = 0;
15371
15372 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15373 {
15374 hc_thread_create (i_thread, thread_keypress, &benchmark);
15375 }
15376
15377 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15378
15379 uint ni_threads_cnt = 0;
15380
15381 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15382
15383 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15384
15385 ni_threads_cnt++;
15386
15387 /**
15388 * Outfile remove
15389 */
15390
15391 if (keyspace == 0)
15392 {
15393 if (outfile_check_timer != 0)
15394 {
15395 if (data.outfile_check_directory != NULL)
15396 {
15397 if ((hash_mode != 5200) &&
15398 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15399 (hash_mode != 9000))
15400 {
15401 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15402
15403 ni_threads_cnt++;
15404 }
15405 else
15406 {
15407 outfile_check_timer = 0;
15408 }
15409 }
15410 else
15411 {
15412 outfile_check_timer = 0;
15413 }
15414 }
15415 }
15416
15417 /**
15418 * Inform the user if we got some hashes remove because of the pot file remove feature
15419 */
15420
15421 if (data.quiet == 0)
15422 {
15423 if (potfile_remove_cracks > 0)
15424 {
15425 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15426 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15427 }
15428 }
15429
15430 data.outfile_check_timer = outfile_check_timer;
15431
15432 /**
15433 * main loop
15434 */
15435
15436 char **induction_dictionaries = NULL;
15437
15438 int induction_dictionaries_cnt = 0;
15439
15440 hcstat_table_t *root_table_buf = NULL;
15441 hcstat_table_t *markov_table_buf = NULL;
15442
15443 uint initial_restore_done = 0;
15444
15445 data.maskcnt = maskcnt;
15446
15447 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15448 {
15449 if (data.devices_status == STATUS_CRACKED) break;
15450
15451 data.devices_status = STATUS_INIT;
15452
15453 if (maskpos > rd->maskpos)
15454 {
15455 rd->dictpos = 0;
15456 }
15457
15458 rd->maskpos = maskpos;
15459 data.maskpos = maskpos;
15460
15461 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15462 {
15463 char *mask = masks[maskpos];
15464
15465 if (mask_from_file == 1)
15466 {
15467 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15468
15469 char *str_ptr;
15470 uint str_pos;
15471
15472 uint mask_offset = 0;
15473
15474 uint separator_cnt;
15475
15476 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15477 {
15478 str_ptr = strstr (mask + mask_offset, ",");
15479
15480 if (str_ptr == NULL) break;
15481
15482 str_pos = str_ptr - mask;
15483
15484 // escaped separator, i.e. "\,"
15485
15486 if (str_pos > 0)
15487 {
15488 if (mask[str_pos - 1] == '\\')
15489 {
15490 separator_cnt --;
15491
15492 mask_offset = str_pos + 1;
15493
15494 continue;
15495 }
15496 }
15497
15498 // reset the offset
15499
15500 mask_offset = 0;
15501
15502 mask[str_pos] = '\0';
15503
15504 switch (separator_cnt)
15505 {
15506 case 0:
15507 mp_reset_usr (mp_usr, 0);
15508
15509 custom_charset_1 = mask;
15510 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15511 break;
15512
15513 case 1:
15514 mp_reset_usr (mp_usr, 1);
15515
15516 custom_charset_2 = mask;
15517 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15518 break;
15519
15520 case 2:
15521 mp_reset_usr (mp_usr, 2);
15522
15523 custom_charset_3 = mask;
15524 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15525 break;
15526
15527 case 3:
15528 mp_reset_usr (mp_usr, 3);
15529
15530 custom_charset_4 = mask;
15531 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15532 break;
15533 }
15534
15535 mask = mask + str_pos + 1;
15536 }
15537 }
15538
15539 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15540 {
15541 if (maskpos > 0)
15542 {
15543 local_free (css_buf);
15544 local_free (data.root_css_buf);
15545 local_free (data.markov_css_buf);
15546
15547 local_free (masks[maskpos - 1]);
15548 }
15549
15550 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15551
15552 data.mask = mask;
15553 data.css_cnt = css_cnt;
15554 data.css_buf = css_buf;
15555
15556 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15557
15558 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15559
15560 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15561 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15562
15563 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15564
15565 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15566
15567 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15568 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15569
15570 data.root_css_buf = root_css_buf;
15571 data.markov_css_buf = markov_css_buf;
15572
15573 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15574
15575 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15576
15577 local_free (root_table_buf);
15578 local_free (markov_table_buf);
15579
15580 // args
15581
15582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15583 {
15584 hc_device_param_t *device_param = &data.devices_param[device_id];
15585
15586 if (device_param->skipped) continue;
15587
15588 device_param->kernel_params_mp[0] = &device_param->d_combs;
15589 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15590 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15591
15592 device_param->kernel_params_mp_buf64[3] = 0;
15593 device_param->kernel_params_mp_buf32[4] = css_cnt;
15594 device_param->kernel_params_mp_buf32[5] = 0;
15595 device_param->kernel_params_mp_buf32[6] = 0;
15596 device_param->kernel_params_mp_buf32[7] = 0;
15597
15598 if (attack_mode == ATTACK_MODE_HYBRID1)
15599 {
15600 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15601 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15602 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15603 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15604 }
15605 else if (attack_mode == ATTACK_MODE_HYBRID2)
15606 {
15607 device_param->kernel_params_mp_buf32[5] = 0;
15608 device_param->kernel_params_mp_buf32[6] = 0;
15609 device_param->kernel_params_mp_buf32[7] = 0;
15610 }
15611
15612 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]);
15613 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]);
15614 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]);
15615
15616 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);
15617 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);
15618 }
15619 }
15620 else if (attack_mode == ATTACK_MODE_BF)
15621 {
15622 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15623
15624 if (increment)
15625 {
15626 for (uint i = 0; i < dictcnt; i++)
15627 {
15628 local_free (dictfiles[i]);
15629 }
15630
15631 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15632 {
15633 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15634
15635 if (l1_filename == NULL) break;
15636
15637 dictcnt++;
15638
15639 dictfiles[dictcnt - 1] = l1_filename;
15640 }
15641 }
15642 else
15643 {
15644 dictcnt++;
15645
15646 dictfiles[dictcnt - 1] = mask;
15647 }
15648
15649 if (dictcnt == 0)
15650 {
15651 log_error ("ERROR: Mask is too small");
15652
15653 return (-1);
15654 }
15655 }
15656 }
15657
15658 free (induction_dictionaries);
15659
15660 // induction_dictionaries_cnt = 0; // implied
15661
15662 if (attack_mode != ATTACK_MODE_BF)
15663 {
15664 if (keyspace == 0)
15665 {
15666 induction_dictionaries = scan_directory (induction_directory);
15667
15668 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15669 }
15670 }
15671
15672 if (induction_dictionaries_cnt)
15673 {
15674 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15675 }
15676
15677 /**
15678 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15679 */
15680 if (keyspace == 1)
15681 {
15682 if ((maskcnt > 1) || (dictcnt > 1))
15683 {
15684 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15685
15686 return (-1);
15687 }
15688 }
15689
15690 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15691 {
15692 char *subid = logfile_generate_subid ();
15693
15694 data.subid = subid;
15695
15696 logfile_sub_msg ("START");
15697
15698 data.devices_status = STATUS_INIT;
15699
15700 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15701 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15702 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15703
15704 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15705
15706 data.cpt_pos = 0;
15707
15708 data.cpt_start = time (NULL);
15709
15710 data.cpt_total = 0;
15711
15712 if (data.restore == 0)
15713 {
15714 rd->words_cur = skip;
15715
15716 skip = 0;
15717
15718 data.skip = 0;
15719 }
15720
15721 data.ms_paused = 0;
15722
15723 data.words_cur = rd->words_cur;
15724
15725 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15726 {
15727 hc_device_param_t *device_param = &data.devices_param[device_id];
15728
15729 if (device_param->skipped) continue;
15730
15731 device_param->speed_pos = 0;
15732
15733 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15734 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15735 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15736
15737 device_param->exec_pos = 0;
15738
15739 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15740
15741 device_param->kernel_power = device_param->kernel_power_user;
15742
15743 device_param->outerloop_pos = 0;
15744 device_param->outerloop_left = 0;
15745 device_param->innerloop_pos = 0;
15746 device_param->innerloop_left = 0;
15747
15748 // some more resets:
15749
15750 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15751
15752 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15753
15754 device_param->pw_cnt = 0;
15755 device_param->pws_cnt = 0;
15756
15757 device_param->words_off = 0;
15758 device_param->words_done = 0;
15759 }
15760
15761 data.kernel_power_div = 0;
15762
15763 // figure out some workload
15764
15765 if (attack_mode == ATTACK_MODE_STRAIGHT)
15766 {
15767 if (data.wordlist_mode == WL_MODE_FILE)
15768 {
15769 char *dictfile = NULL;
15770
15771 if (induction_dictionaries_cnt)
15772 {
15773 dictfile = induction_dictionaries[0];
15774 }
15775 else
15776 {
15777 dictfile = dictfiles[dictpos];
15778 }
15779
15780 data.dictfile = dictfile;
15781
15782 logfile_sub_string (dictfile);
15783
15784 for (uint i = 0; i < rp_files_cnt; i++)
15785 {
15786 logfile_sub_var_string ("rulefile", rp_files[i]);
15787 }
15788
15789 FILE *fd2 = fopen (dictfile, "rb");
15790
15791 if (fd2 == NULL)
15792 {
15793 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15794
15795 return (-1);
15796 }
15797
15798 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15799
15800 fclose (fd2);
15801
15802 if (data.words_cnt == 0)
15803 {
15804 if (data.devices_status == STATUS_CRACKED) break;
15805 if (data.devices_status == STATUS_ABORTED) break;
15806
15807 dictpos++;
15808
15809 continue;
15810 }
15811 }
15812 }
15813 else if (attack_mode == ATTACK_MODE_COMBI)
15814 {
15815 char *dictfile = data.dictfile;
15816 char *dictfile2 = data.dictfile2;
15817
15818 logfile_sub_string (dictfile);
15819 logfile_sub_string (dictfile2);
15820
15821 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15822 {
15823 FILE *fd2 = fopen (dictfile, "rb");
15824
15825 if (fd2 == NULL)
15826 {
15827 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15828
15829 return (-1);
15830 }
15831
15832 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15833
15834 fclose (fd2);
15835 }
15836 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15837 {
15838 FILE *fd2 = fopen (dictfile2, "rb");
15839
15840 if (fd2 == NULL)
15841 {
15842 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15843
15844 return (-1);
15845 }
15846
15847 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15848
15849 fclose (fd2);
15850 }
15851
15852 if (data.words_cnt == 0)
15853 {
15854 if (data.devices_status == STATUS_CRACKED) break;
15855 if (data.devices_status == STATUS_ABORTED) break;
15856
15857 dictpos++;
15858
15859 continue;
15860 }
15861 }
15862 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15863 {
15864 char *dictfile = NULL;
15865
15866 if (induction_dictionaries_cnt)
15867 {
15868 dictfile = induction_dictionaries[0];
15869 }
15870 else
15871 {
15872 dictfile = dictfiles[dictpos];
15873 }
15874
15875 data.dictfile = dictfile;
15876
15877 char *mask = data.mask;
15878
15879 logfile_sub_string (dictfile);
15880 logfile_sub_string (mask);
15881
15882 FILE *fd2 = fopen (dictfile, "rb");
15883
15884 if (fd2 == NULL)
15885 {
15886 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15887
15888 return (-1);
15889 }
15890
15891 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15892
15893 fclose (fd2);
15894
15895 if (data.words_cnt == 0)
15896 {
15897 if (data.devices_status == STATUS_CRACKED) break;
15898 if (data.devices_status == STATUS_ABORTED) break;
15899
15900 dictpos++;
15901
15902 continue;
15903 }
15904 }
15905 else if (attack_mode == ATTACK_MODE_BF)
15906 {
15907 local_free (css_buf);
15908 local_free (data.root_css_buf);
15909 local_free (data.markov_css_buf);
15910
15911 char *mask = dictfiles[dictpos];
15912
15913 logfile_sub_string (mask);
15914
15915 // base
15916
15917 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15918
15919 if (opts_type & OPTS_TYPE_PT_UNICODE)
15920 {
15921 uint css_cnt_unicode = css_cnt * 2;
15922
15923 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15924
15925 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15926 {
15927 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15928
15929 css_buf_unicode[j + 1].cs_buf[0] = 0;
15930 css_buf_unicode[j + 1].cs_len = 1;
15931 }
15932
15933 free (css_buf);
15934
15935 css_buf = css_buf_unicode;
15936 css_cnt = css_cnt_unicode;
15937 }
15938
15939 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15940
15941 uint mask_min = pw_min;
15942 uint mask_max = pw_max;
15943
15944 if (opts_type & OPTS_TYPE_PT_UNICODE)
15945 {
15946 mask_min *= 2;
15947 mask_max *= 2;
15948 }
15949
15950 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15951 {
15952 if (css_cnt < mask_min)
15953 {
15954 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15955 }
15956
15957 if (css_cnt > mask_max)
15958 {
15959 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15960 }
15961
15962 // skip to next mask
15963
15964 dictpos++;
15965
15966 rd->dictpos = dictpos;
15967
15968 logfile_sub_msg ("STOP");
15969
15970 continue;
15971 }
15972
15973 uint save_css_cnt = css_cnt;
15974
15975 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15976 {
15977 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15978 {
15979 uint salt_len = (uint) data.salts_buf[0].salt_len;
15980 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15981
15982 uint css_cnt_salt = css_cnt + salt_len;
15983
15984 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15985
15986 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15987
15988 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15989 {
15990 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15991 css_buf_salt[j].cs_len = 1;
15992 }
15993
15994 free (css_buf);
15995
15996 css_buf = css_buf_salt;
15997 css_cnt = css_cnt_salt;
15998 }
15999 }
16000
16001 data.mask = mask;
16002 data.css_cnt = css_cnt;
16003 data.css_buf = css_buf;
16004
16005 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16006
16007 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16008
16009 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16010
16011 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16012 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16013
16014 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16015
16016 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16017
16018 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16019 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16020
16021 data.root_css_buf = root_css_buf;
16022 data.markov_css_buf = markov_css_buf;
16023
16024 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16025
16026 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16027
16028 local_free (root_table_buf);
16029 local_free (markov_table_buf);
16030
16031 // copy + args
16032
16033 uint css_cnt_l = css_cnt;
16034 uint css_cnt_r;
16035
16036 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16037 {
16038 if (save_css_cnt < 6)
16039 {
16040 css_cnt_r = 1;
16041 }
16042 else if (save_css_cnt == 6)
16043 {
16044 css_cnt_r = 2;
16045 }
16046 else
16047 {
16048 if (opts_type & OPTS_TYPE_PT_UNICODE)
16049 {
16050 if (save_css_cnt == 8 || save_css_cnt == 10)
16051 {
16052 css_cnt_r = 2;
16053 }
16054 else
16055 {
16056 css_cnt_r = 4;
16057 }
16058 }
16059 else
16060 {
16061 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16062 {
16063 css_cnt_r = 3;
16064 }
16065 else
16066 {
16067 css_cnt_r = 4;
16068 }
16069 }
16070 }
16071 }
16072 else
16073 {
16074 css_cnt_r = 1;
16075
16076 /* unfinished code?
16077 int sum = css_buf[css_cnt_r - 1].cs_len;
16078
16079 for (uint i = 1; i < 4 && i < css_cnt; i++)
16080 {
16081 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16082
16083 css_cnt_r++;
16084
16085 sum *= css_buf[css_cnt_r - 1].cs_len;
16086 }
16087 */
16088 }
16089
16090 css_cnt_l -= css_cnt_r;
16091
16092 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16093
16094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16095 {
16096 hc_device_param_t *device_param = &data.devices_param[device_id];
16097
16098 if (device_param->skipped) continue;
16099
16100 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16101 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16102 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16103
16104 device_param->kernel_params_mp_l_buf64[3] = 0;
16105 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16106 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16107 device_param->kernel_params_mp_l_buf32[6] = 0;
16108 device_param->kernel_params_mp_l_buf32[7] = 0;
16109 device_param->kernel_params_mp_l_buf32[8] = 0;
16110
16111 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16112 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16113 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16114 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16115
16116 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16117 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16118 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16119
16120 device_param->kernel_params_mp_r_buf64[3] = 0;
16121 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16122 device_param->kernel_params_mp_r_buf32[5] = 0;
16123 device_param->kernel_params_mp_r_buf32[6] = 0;
16124 device_param->kernel_params_mp_r_buf32[7] = 0;
16125
16126 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]);
16127 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]);
16128 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]);
16129
16130 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]);
16131 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]);
16132 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]);
16133
16134 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);
16135 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);
16136 }
16137 }
16138
16139 u64 words_base = data.words_cnt;
16140
16141 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16142 {
16143 if (data.kernel_rules_cnt)
16144 {
16145 words_base /= data.kernel_rules_cnt;
16146 }
16147 }
16148 else if (data.attack_kern == ATTACK_KERN_COMBI)
16149 {
16150 if (data.combs_cnt)
16151 {
16152 words_base /= data.combs_cnt;
16153 }
16154 }
16155 else if (data.attack_kern == ATTACK_KERN_BF)
16156 {
16157 if (data.bfs_cnt)
16158 {
16159 words_base /= data.bfs_cnt;
16160 }
16161 }
16162
16163 data.words_base = words_base;
16164
16165 if (keyspace == 1)
16166 {
16167 log_info ("%llu", (unsigned long long int) words_base);
16168
16169 return (0);
16170 }
16171
16172 if (data.words_cur > data.words_base)
16173 {
16174 log_error ("ERROR: restore value greater keyspace");
16175
16176 return (-1);
16177 }
16178
16179 if (data.words_cur)
16180 {
16181 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16182 {
16183 for (uint i = 0; i < data.salts_cnt; i++)
16184 {
16185 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16186 }
16187 }
16188 else if (data.attack_kern == ATTACK_KERN_COMBI)
16189 {
16190 for (uint i = 0; i < data.salts_cnt; i++)
16191 {
16192 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16193 }
16194 }
16195 else if (data.attack_kern == ATTACK_KERN_BF)
16196 {
16197 for (uint i = 0; i < data.salts_cnt; i++)
16198 {
16199 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16200 }
16201 }
16202 }
16203
16204 /*
16205 * Inform user about possible slow speeds
16206 */
16207
16208 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16209 {
16210 if (data.words_base < kernel_power_all)
16211 {
16212 if (quiet == 0)
16213 {
16214 log_info ("");
16215 log_info ("ATTENTION!");
16216 log_info (" The wordlist or mask you are using is too small.");
16217 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16218 log_info (" The cracking speed will drop.");
16219 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16220 log_info ("");
16221 }
16222 }
16223 }
16224
16225 /*
16226 * Update loopback file
16227 */
16228
16229 if (loopback == 1)
16230 {
16231 time_t now;
16232
16233 time (&now);
16234
16235 uint random_num = get_random_num (0, 9999);
16236
16237 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16238
16239 data.loopback_file = loopback_file;
16240 }
16241
16242 /*
16243 * Update dictionary statistic
16244 */
16245
16246 if (keyspace == 0)
16247 {
16248 dictstat_fp = fopen (dictstat, "wb");
16249
16250 if (dictstat_fp)
16251 {
16252 lock_file (dictstat_fp);
16253
16254 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16255
16256 fclose (dictstat_fp);
16257 }
16258 }
16259
16260 data.devices_status = STATUS_RUNNING;
16261
16262 if (initial_restore_done == 0)
16263 {
16264 if (data.restore_disable == 0) cycle_restore ();
16265
16266 initial_restore_done = 1;
16267 }
16268
16269 hc_timer_set (&data.timer_running);
16270
16271 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16272 {
16273 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16274 {
16275 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16276 if (quiet == 0) fflush (stdout);
16277 }
16278 }
16279 else if (wordlist_mode == WL_MODE_STDIN)
16280 {
16281 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16282 if (data.quiet == 0) log_info ("");
16283 }
16284
16285 time_t runtime_start;
16286
16287 time (&runtime_start);
16288
16289 data.runtime_start = runtime_start;
16290
16291 /**
16292 * create cracker threads
16293 */
16294
16295 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16296
16297 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16298 {
16299 hc_device_param_t *device_param = &devices_param[device_id];
16300
16301 if (wordlist_mode == WL_MODE_STDIN)
16302 {
16303 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16304 }
16305 else
16306 {
16307 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16308 }
16309 }
16310
16311 // wait for crack threads to exit
16312
16313 hc_thread_wait (data.devices_cnt, c_threads);
16314
16315 local_free (c_threads);
16316
16317 data.restore = 0;
16318
16319 // finalize task
16320
16321 logfile_sub_var_uint ("status-after-work", data.devices_status);
16322
16323 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16324
16325 if (data.devices_status == STATUS_CRACKED) break;
16326 if (data.devices_status == STATUS_ABORTED) break;
16327
16328 if (data.devices_status == STATUS_BYPASS)
16329 {
16330 data.devices_status = STATUS_RUNNING;
16331 }
16332
16333 if (induction_dictionaries_cnt)
16334 {
16335 unlink (induction_dictionaries[0]);
16336 }
16337
16338 free (induction_dictionaries);
16339
16340 if (attack_mode != ATTACK_MODE_BF)
16341 {
16342 induction_dictionaries = scan_directory (induction_directory);
16343
16344 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16345 }
16346
16347 if (benchmark == 0)
16348 {
16349 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16350 {
16351 if (quiet == 0) clear_prompt ();
16352
16353 if (quiet == 0) log_info ("");
16354
16355 if (status == 1)
16356 {
16357 status_display ();
16358 }
16359 else
16360 {
16361 if (quiet == 0) status_display ();
16362 }
16363
16364 if (quiet == 0) log_info ("");
16365 }
16366 }
16367
16368 if (attack_mode == ATTACK_MODE_BF)
16369 {
16370 dictpos++;
16371
16372 rd->dictpos = dictpos;
16373 }
16374 else
16375 {
16376 if (induction_dictionaries_cnt)
16377 {
16378 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16379 }
16380 else
16381 {
16382 dictpos++;
16383
16384 rd->dictpos = dictpos;
16385 }
16386 }
16387
16388 time_t runtime_stop;
16389
16390 time (&runtime_stop);
16391
16392 data.runtime_stop = runtime_stop;
16393
16394 logfile_sub_uint (runtime_start);
16395 logfile_sub_uint (runtime_stop);
16396
16397 logfile_sub_msg ("STOP");
16398
16399 global_free (subid);
16400 }
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 if (data.devices_status == STATUS_QUIT) break;
16407
16408 if (data.devices_status == STATUS_BYPASS)
16409 {
16410 data.devices_status = STATUS_RUNNING;
16411 }
16412 }
16413
16414 // 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
16415
16416 if (attack_mode == ATTACK_MODE_STRAIGHT)
16417 {
16418 if (data.wordlist_mode == WL_MODE_FILE)
16419 {
16420 if (data.dictfile == NULL)
16421 {
16422 if (dictfiles != NULL)
16423 {
16424 data.dictfile = dictfiles[0];
16425
16426 hc_timer_set (&data.timer_running);
16427 }
16428 }
16429 }
16430 }
16431 // NOTE: combi is okay because it is already set beforehand
16432 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16433 {
16434 if (data.dictfile == NULL)
16435 {
16436 if (dictfiles != NULL)
16437 {
16438 hc_timer_set (&data.timer_running);
16439
16440 data.dictfile = dictfiles[0];
16441 }
16442 }
16443 }
16444 else if (attack_mode == ATTACK_MODE_BF)
16445 {
16446 if (data.mask == NULL)
16447 {
16448 hc_timer_set (&data.timer_running);
16449
16450 data.mask = masks[0];
16451 }
16452 }
16453
16454 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16455 {
16456 data.devices_status = STATUS_EXHAUSTED;
16457 }
16458
16459 // if cracked / aborted remove last induction dictionary
16460
16461 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16462 {
16463 struct stat induct_stat;
16464
16465 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16466 {
16467 unlink (induction_dictionaries[file_pos]);
16468 }
16469 }
16470
16471 // wait for non-interactive threads
16472
16473 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16474 {
16475 hc_thread_wait (1, &ni_threads[thread_idx]);
16476 }
16477
16478 local_free (ni_threads);
16479
16480 // wait for interactive threads
16481
16482 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16483 {
16484 hc_thread_wait (1, &i_thread);
16485 }
16486
16487 // we dont need restore file anymore
16488 if (data.restore_disable == 0)
16489 {
16490 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16491 {
16492 unlink (eff_restore_file);
16493 unlink (new_restore_file);
16494 }
16495 else
16496 {
16497 cycle_restore ();
16498 }
16499 }
16500
16501 // finally save left hashes
16502
16503 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16504 {
16505 save_hash ();
16506 }
16507
16508 /**
16509 * Clean up
16510 */
16511
16512 if (benchmark == 1)
16513 {
16514 status_benchmark ();
16515
16516 log_info ("");
16517 }
16518 else
16519 {
16520 if (quiet == 0) clear_prompt ();
16521
16522 if (quiet == 0) log_info ("");
16523
16524 if (status == 1)
16525 {
16526 status_display ();
16527 }
16528 else
16529 {
16530 if (quiet == 0) status_display ();
16531 }
16532
16533 if (quiet == 0) log_info ("");
16534 }
16535
16536 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16537 {
16538 hc_device_param_t *device_param = &data.devices_param[device_id];
16539
16540 if (device_param->skipped) continue;
16541
16542 local_free (device_param->result);
16543
16544 local_free (device_param->pw_caches);
16545
16546 local_free (device_param->combs_buf);
16547
16548 local_free (device_param->hooks_buf);
16549
16550 local_free (device_param->device_name);
16551
16552 local_free (device_param->device_name_chksum);
16553
16554 local_free (device_param->device_version);
16555
16556 local_free (device_param->driver_version);
16557
16558 if (device_param->pws_buf) myfree (device_param->pws_buf);
16559 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16560 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16561 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16562 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16563 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16564 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16565 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16566 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16567 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16568 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16569 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16570 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16571 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16572 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16573 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16574 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16575 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16576 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16577 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16578 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16579 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16580 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16581 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16582 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16583 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16584 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16585 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16586 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16587
16588 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16589 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16590 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16591 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16592 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16593 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16594 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16595 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16596 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16597 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16598 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16599
16600 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16601 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16602 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16603
16604 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16605 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16606 }
16607
16608 // reset default fan speed
16609
16610 #ifdef HAVE_HWMON
16611 if (gpu_temp_disable == 0)
16612 {
16613 #ifdef HAVE_ADL
16614 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16615 {
16616 hc_thread_mutex_lock (mux_adl);
16617
16618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16619 {
16620 hc_device_param_t *device_param = &data.devices_param[device_id];
16621
16622 if (device_param->skipped) continue;
16623
16624 if (data.hm_device[device_id].fan_supported == 1)
16625 {
16626 int fanspeed = temp_retain_fanspeed_value[device_id];
16627
16628 if (fanspeed == -1) continue;
16629
16630 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16631
16632 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16633 }
16634 }
16635
16636 hc_thread_mutex_unlock (mux_adl);
16637 }
16638 #endif // HAVE_ADL
16639 }
16640
16641 #ifdef HAVE_ADL
16642 // reset power tuning
16643
16644 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16645 {
16646 hc_thread_mutex_lock (mux_adl);
16647
16648 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16649 {
16650 hc_device_param_t *device_param = &data.devices_param[device_id];
16651
16652 if (device_param->skipped) continue;
16653
16654 if (data.hm_device[device_id].od_version == 6)
16655 {
16656 // check powertune capabilities first, if not available then skip device
16657
16658 int powertune_supported = 0;
16659
16660 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16661 {
16662 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16663
16664 return (-1);
16665 }
16666
16667 if (powertune_supported != 0)
16668 {
16669 // powercontrol settings
16670
16671 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)
16672 {
16673 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16674
16675 return (-1);
16676 }
16677
16678 // clocks
16679
16680 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16681
16682 performance_state->iNumberOfPerformanceLevels = 2;
16683
16684 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16685 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16686 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16687 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16688
16689 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)
16690 {
16691 log_info ("ERROR: Failed to restore ADL performance state");
16692
16693 return (-1);
16694 }
16695
16696 local_free (performance_state);
16697 }
16698 }
16699 }
16700
16701 hc_thread_mutex_unlock (mux_adl);
16702 }
16703 #endif // HAVE_ADL
16704
16705 if (gpu_temp_disable == 0)
16706 {
16707 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16708 if (data.hm_nv)
16709 {
16710 #if defined(LINUX) && defined(HAVE_NVML)
16711
16712 hm_NVML_nvmlShutdown (data.hm_nv);
16713
16714 nvml_close (data.hm_nv);
16715
16716 #elif defined(WIN) && (HAVE_NVAPI)
16717
16718 hm_NvAPI_Unload (data.hm_nv);
16719
16720 nvapi_close (data.hm_nv);
16721
16722 #endif
16723
16724 data.hm_nv = NULL;
16725 }
16726 #endif
16727
16728 #ifdef HAVE_ADL
16729 if (data.hm_amd)
16730 {
16731 hm_ADL_Main_Control_Destroy (data.hm_amd);
16732
16733 adl_close (data.hm_amd);
16734 data.hm_amd = NULL;
16735 }
16736 #endif
16737 }
16738 #endif // HAVE_HWMON
16739
16740 // free memory
16741
16742 local_free (masks);
16743
16744 local_free (dictstat_base);
16745
16746 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16747 {
16748 pot_t *pot_ptr = &pot[pot_pos];
16749
16750 hash_t *hash = &pot_ptr->hash;
16751
16752 local_free (hash->digest);
16753
16754 if (isSalted)
16755 {
16756 local_free (hash->salt);
16757 }
16758 }
16759
16760 local_free (pot);
16761
16762 local_free (all_kernel_rules_cnt);
16763 local_free (all_kernel_rules_buf);
16764
16765 local_free (wl_data->buf);
16766 local_free (wl_data);
16767
16768 local_free (bitmap_s1_a);
16769 local_free (bitmap_s1_b);
16770 local_free (bitmap_s1_c);
16771 local_free (bitmap_s1_d);
16772 local_free (bitmap_s2_a);
16773 local_free (bitmap_s2_b);
16774 local_free (bitmap_s2_c);
16775 local_free (bitmap_s2_d);
16776
16777 #ifdef HAVE_HWMON
16778 local_free (temp_retain_fanspeed_value);
16779 #ifdef HAVE_ADL
16780 local_free (od_clock_mem_status);
16781 local_free (od_power_control_status);
16782 #endif // ADL
16783 #endif
16784
16785 global_free (devices_param);
16786
16787 global_free (kernel_rules_buf);
16788
16789 global_free (root_css_buf);
16790 global_free (markov_css_buf);
16791
16792 global_free (digests_buf);
16793 global_free (digests_shown);
16794 global_free (digests_shown_tmp);
16795
16796 global_free (salts_buf);
16797 global_free (salts_shown);
16798
16799 global_free (esalts_buf);
16800
16801 global_free (words_progress_done);
16802 global_free (words_progress_rejected);
16803 global_free (words_progress_restored);
16804
16805 if (pot_fp) fclose (pot_fp);
16806
16807 if (data.devices_status == STATUS_QUIT) break;
16808 }
16809
16810 // destroy others mutex
16811
16812 hc_thread_mutex_delete (mux_dispatcher);
16813 hc_thread_mutex_delete (mux_counter);
16814 hc_thread_mutex_delete (mux_display);
16815 hc_thread_mutex_delete (mux_adl);
16816
16817 // free memory
16818
16819 local_free (eff_restore_file);
16820 local_free (new_restore_file);
16821
16822 local_free (rd);
16823
16824 // tuning db
16825
16826 tuning_db_destroy (tuning_db);
16827
16828 // loopback
16829
16830 local_free (loopback_file);
16831
16832 if (loopback == 1) unlink (loopback_file);
16833
16834 // induction directory
16835
16836 if (induction_dir == NULL)
16837 {
16838 if (attack_mode != ATTACK_MODE_BF)
16839 {
16840 if (rmdir (induction_directory) == -1)
16841 {
16842 if (errno == ENOENT)
16843 {
16844 // good, we can ignore
16845 }
16846 else if (errno == ENOTEMPTY)
16847 {
16848 // good, we can ignore
16849 }
16850 else
16851 {
16852 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16853
16854 return (-1);
16855 }
16856 }
16857
16858 local_free (induction_directory);
16859 }
16860 }
16861
16862 // outfile-check directory
16863
16864 if (outfile_check_dir == NULL)
16865 {
16866 if (rmdir (outfile_check_directory) == -1)
16867 {
16868 if (errno == ENOENT)
16869 {
16870 // good, we can ignore
16871 }
16872 else if (errno == ENOTEMPTY)
16873 {
16874 // good, we can ignore
16875 }
16876 else
16877 {
16878 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16879
16880 return (-1);
16881 }
16882 }
16883
16884 local_free (outfile_check_directory);
16885 }
16886
16887 time_t proc_stop;
16888
16889 time (&proc_stop);
16890
16891 logfile_top_uint (proc_start);
16892 logfile_top_uint (proc_stop);
16893
16894 logfile_top_msg ("STOP");
16895
16896 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16897 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16898
16899 if (data.ocl) ocl_close (data.ocl);
16900
16901 if (data.devices_status == STATUS_ABORTED) return 2;
16902 if (data.devices_status == STATUS_QUIT) return 2;
16903 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16904 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16905 if (data.devices_status == STATUS_CRACKED) return 0;
16906
16907 return -1;
16908 }
Hashcat additions to support pwdhash