projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Get rid of hc_clEnqueueNDRangeKernel double call
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
400 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Reduced performance profile (low latency desktop)",
447 " 2 = Default performance profile",
448 " 3 = Tuned performance profile (high latency desktop)",
449 "",
450 "* Benchmark Settings:",
451 "",
452 " 0 = Manual Tuning",
453 " 1 = Performance Tuning, default",
454 "",
455 "* OpenCL device-types:",
456 "",
457 " 1 = CPU devices",
458 " 2 = GPU devices",
459 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
460 "",
461 "* Outfile Formats:",
462 "",
463 " 1 = hash[:salt]",
464 " 2 = plain",
465 " 3 = hash[:salt]:plain",
466 " 4 = hex_plain",
467 " 5 = hash[:salt]:hex_plain",
468 " 6 = plain:hex_plain",
469 " 7 = hash[:salt]:plain:hex_plain",
470 " 8 = crackpos",
471 " 9 = hash[:salt]:crackpos",
472 " 10 = plain:crackpos",
473 " 11 = hash[:salt]:plain:crackpos",
474 " 12 = hex_plain:crackpos",
475 " 13 = hash[:salt]:hex_plain:crackpos",
476 " 14 = plain:hex_plain:crackpos",
477 " 15 = hash[:salt]:plain:hex_plain:crackpos",
478 "",
479 "* Debug mode output formats (for hybrid mode only, by using rules):",
480 "",
481 " 1 = save finding rule",
482 " 2 = save original word",
483 " 3 = save original word and finding rule",
484 " 4 = save original word, finding rule and modified plain",
485 "",
486 "* Built-in charsets:",
487 "",
488 " ?l = abcdefghijklmnopqrstuvwxyz",
489 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
490 " ?d = 0123456789",
491 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
492 " ?a = ?l?u?d?s",
493 " ?b = 0x00 - 0xff",
494 "",
495 "* Attack modes:",
496 "",
497 " 0 = Straight",
498 " 1 = Combination",
499 " 3 = Brute-force",
500 " 6 = Hybrid dict + mask",
501 " 7 = Hybrid mask + dict",
502 "",
503 "* Hash types:",
504 "",
505 "[[ Roll-your-own: Raw Hashes ]]",
506 "",
507 " 900 = MD4",
508 " 0 = MD5",
509 " 5100 = Half MD5",
510 " 100 = SHA1",
511 " 10800 = SHA-384",
512 " 1400 = SHA-256",
513 " 1700 = SHA-512",
514 " 5000 = SHA-3(Keccak)",
515 " 10100 = SipHash",
516 " 6000 = RipeMD160",
517 " 6100 = Whirlpool",
518 " 6900 = GOST R 34.11-94",
519 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
520 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
521 "",
522 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
523 "",
524 " 10 = md5($pass.$salt)",
525 " 20 = md5($salt.$pass)",
526 " 30 = md5(unicode($pass).$salt)",
527 " 40 = md5($salt.unicode($pass))",
528 " 3800 = md5($salt.$pass.$salt)",
529 " 3710 = md5($salt.md5($pass))",
530 " 2600 = md5(md5($pass)",
531 " 4300 = md5(strtoupper(md5($pass)))",
532 " 4400 = md5(sha1($pass))",
533 " 110 = sha1($pass.$salt)",
534 " 120 = sha1($salt.$pass)",
535 " 130 = sha1(unicode($pass).$salt)",
536 " 140 = sha1($salt.unicode($pass))",
537 " 4500 = sha1(sha1($pass)",
538 " 4700 = sha1(md5($pass))",
539 " 4900 = sha1($salt.$pass.$salt)",
540 " 1410 = sha256($pass.$salt)",
541 " 1420 = sha256($salt.$pass)",
542 " 1430 = sha256(unicode($pass).$salt)",
543 " 1440 = sha256($salt.unicode($pass))",
544 " 1710 = sha512($pass.$salt)",
545 " 1720 = sha512($salt.$pass)",
546 " 1730 = sha512(unicode($pass).$salt)",
547 " 1740 = sha512($salt.unicode($pass))",
548 "",
549 "[[ Roll-your-own: Authenticated Hashes ]]",
550 "",
551 " 50 = HMAC-MD5 (key = $pass)",
552 " 60 = HMAC-MD5 (key = $salt)",
553 " 150 = HMAC-SHA1 (key = $pass)",
554 " 160 = HMAC-SHA1 (key = $salt)",
555 " 1450 = HMAC-SHA256 (key = $pass)",
556 " 1460 = HMAC-SHA256 (key = $salt)",
557 " 1750 = HMAC-SHA512 (key = $pass)",
558 " 1760 = HMAC-SHA512 (key = $salt)",
559 "",
560 "[[ Generic KDF ]]",
561 "",
562 " 400 = phpass",
563 " 8900 = scrypt",
564 " 11900 = PBKDF2-HMAC-MD5",
565 " 12000 = PBKDF2-HMAC-SHA1",
566 " 10900 = PBKDF2-HMAC-SHA256",
567 " 12100 = PBKDF2-HMAC-SHA512",
568 "",
569 "[[ Network protocols, Challenge-Response ]]",
570 "",
571 " 23 = Skype",
572 " 2500 = WPA/WPA2",
573 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
574 " 5300 = IKE-PSK MD5",
575 " 5400 = IKE-PSK SHA1",
576 " 5500 = NetNTLMv1",
577 " 5500 = NetNTLMv1 + ESS",
578 " 5600 = NetNTLMv2",
579 " 7300 = IPMI2 RAKP HMAC-SHA1",
580 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
581 " 8300 = DNSSEC (NSEC3)",
582 " 10200 = Cram MD5",
583 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
584 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
585 " 11400 = SIP digest authentication (MD5)",
586 "",
587 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
588 "",
589 " 121 = SMF (Simple Machines Forum)",
590 " 400 = phpBB3",
591 " 2611 = vBulletin < v3.8.5",
592 " 2711 = vBulletin > v3.8.5",
593 " 2811 = MyBB",
594 " 2811 = IPB (Invison Power Board)",
595 " 8400 = WBB3 (Woltlab Burning Board)",
596 " 11 = Joomla < 2.5.18",
597 " 400 = Joomla > 2.5.18",
598 " 400 = Wordpress",
599 " 2612 = PHPS",
600 " 7900 = Drupal7",
601 " 21 = osCommerce",
602 " 21 = xt:Commerce",
603 " 11000 = PrestaShop",
604 " 124 = Django (SHA-1)",
605 " 10000 = Django (PBKDF2-SHA256)",
606 " 3711 = Mediawiki B type",
607 " 7600 = Redmine",
608 "",
609 "[[ Database Server ]]",
610 "",
611 " 12 = PostgreSQL",
612 " 131 = MSSQL(2000)",
613 " 132 = MSSQL(2005)",
614 " 1731 = MSSQL(2012)",
615 " 1731 = MSSQL(2014)",
616 " 200 = MySQL323",
617 " 300 = MySQL4.1/MySQL5",
618 " 3100 = Oracle H: Type (Oracle 7+)",
619 " 112 = Oracle S: Type (Oracle 11+)",
620 " 12300 = Oracle T: Type (Oracle 12+)",
621 " 8000 = Sybase ASE",
622 "",
623 "[[ HTTP, SMTP, LDAP Server ]]",
624 "",
625 " 141 = EPiServer 6.x < v4",
626 " 1441 = EPiServer 6.x > v4",
627 " 1600 = Apache $apr1$",
628 " 12600 = ColdFusion 10+",
629 " 1421 = hMailServer",
630 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
631 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
632 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
633 "",
634 "[[ Checksums ]]",
635 "",
636 " 11500 = CRC32",
637 "",
638 "[[ Operating-Systems ]]",
639 "",
640 " 3000 = LM",
641 " 1000 = NTLM",
642 " 1100 = Domain Cached Credentials (DCC), MS Cache",
643 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
644 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
645 " 1500 = descrypt, DES(Unix), Traditional DES",
646 " 12400 = BSDiCrypt, Extended DES",
647 " 500 = md5crypt $1$, MD5(Unix)",
648 " 3200 = bcrypt $2*$, Blowfish(Unix)",
649 " 7400 = sha256crypt $5$, SHA256(Unix)",
650 " 1800 = sha512crypt $6$, SHA512(Unix)",
651 " 122 = OSX v10.4",
652 " 122 = OSX v10.5",
653 " 122 = OSX v10.6",
654 " 1722 = OSX v10.7",
655 " 7100 = OSX v10.8",
656 " 7100 = OSX v10.9",
657 " 7100 = OSX v10.10",
658 " 6300 = AIX {smd5}",
659 " 6700 = AIX {ssha1}",
660 " 6400 = AIX {ssha256}",
661 " 6500 = AIX {ssha512}",
662 " 2400 = Cisco-PIX",
663 " 2410 = Cisco-ASA",
664 " 500 = Cisco-IOS $1$",
665 " 5700 = Cisco-IOS $4$",
666 " 9200 = Cisco-IOS $8$",
667 " 9300 = Cisco-IOS $9$",
668 " 22 = Juniper Netscreen/SSG (ScreenOS)",
669 " 501 = Juniper IVE",
670 " 5800 = Android PIN",
671 " 8100 = Citrix Netscaler",
672 " 8500 = RACF",
673 " 7200 = GRUB 2",
674 " 9900 = Radmin2",
675 "",
676 "[[ Enterprise Application Software (EAS) ]]",
677 "",
678 " 7700 = SAP CODVN B (BCODE)",
679 " 7800 = SAP CODVN F/G (PASSCODE)",
680 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
681 " 8600 = Lotus Notes/Domino 5",
682 " 8700 = Lotus Notes/Domino 6",
683 " 9100 = Lotus Notes/Domino 8",
684 " 133 = PeopleSoft",
685 "",
686 "[[ Archives ]]",
687 "",
688 " 11600 = 7-Zip",
689 " 12500 = RAR3-hp",
690 " 13000 = RAR5",
691 "",
692 "[[ Full-Disk encryptions (FDE) ]]",
693 "",
694 " 62XY = TrueCrypt 5.0+",
695 " X = 1 = PBKDF2-HMAC-RipeMD160",
696 " X = 2 = PBKDF2-HMAC-SHA512",
697 " X = 3 = PBKDF2-HMAC-Whirlpool",
698 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
699 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
700 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
701 " Y = 3 = XTS 1536 bit (Ciphers: All)",
702 " 8800 = Android FDE < v4.3",
703 " 12900 = Android FDE (Samsung DEK)",
704 " 12200 = eCryptfs",
705 "",
706 "[[ Documents ]]",
707 "",
708 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
709 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
710 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
711 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
712 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
713 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
714 " 9400 = MS Office 2007",
715 " 9500 = MS Office 2010",
716 " 9600 = MS Office 2013",
717 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
718 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
719 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
720 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
721 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
722 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
723 "",
724 "[[ Password Managers ]]",
725 "",
726 " 9000 = Password Safe v2",
727 " 5200 = Password Safe v3",
728 " 6800 = Lastpass",
729 " 6600 = 1Password, agilekeychain",
730 " 8200 = 1Password, cloudkeychain",
731 " 11300 = Bitcoin/Litecoin wallet.dat",
732 " 12700 = Blockchain, My Wallet",
733 "",
734 NULL
735 };
736
737 /**
738 * oclHashcat specific functions
739 */
740
741 void status_display_automat ()
742 {
743 FILE *out = stdout;
744
745 fprintf (out, "STATUS\t%u\t", data.devices_status);
746
747 /**
748 * speed new
749 */
750
751 fprintf (out, "SPEED\t");
752
753 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
754 {
755 hc_device_param_t *device_param = &data.devices_param[device_id];
756
757 if (device_param->skipped) continue;
758
759 u64 speed_cnt = 0;
760 float speed_ms = 0;
761
762 for (int i = 0; i < SPEED_CACHE; i++)
763 {
764 float rec_ms;
765
766 hc_timer_get (device_param->speed_rec[i], rec_ms);
767
768 if (rec_ms > SPEED_MAXAGE) continue;
769
770 speed_cnt += device_param->speed_cnt[i];
771 speed_ms += device_param->speed_ms[i];
772 }
773
774 speed_cnt /= SPEED_CACHE;
775 speed_ms /= SPEED_CACHE;
776
777 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
778 }
779
780 /**
781 * exec time
782 */
783
784 fprintf (out, "EXEC_RUNTIME\t");
785
786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
787 {
788 hc_device_param_t *device_param = &data.devices_param[device_id];
789
790 if (device_param->skipped) continue;
791
792 double exec_ms_total = 0;
793
794 int exec_ms_cnt = 0;
795
796 for (int i = 0; i < EXEC_CACHE; i++)
797 {
798 double exec_ms = device_param->exec_ms[i];
799
800 if (exec_ms)
801 {
802 exec_ms_total += exec_ms;
803
804 exec_ms_cnt++;
805 }
806 }
807
808 exec_ms_total /= exec_ms_cnt;
809
810 fprintf (out, "%f\t", exec_ms_total);
811 }
812
813 /**
814 * words_cur
815 */
816
817 u64 words_cur = get_lowest_words_done ();
818
819 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
820
821 /**
822 * counter
823 */
824
825 uint salts_left = data.salts_cnt - data.salts_done;
826
827 if (salts_left == 0) salts_left = 1;
828
829 u64 progress_total = data.words_cnt * salts_left;
830
831 u64 all_done = 0;
832 u64 all_rejected = 0;
833 u64 all_restored = 0;
834
835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
836 {
837 if (salts_left > 1)
838 {
839 // otherwise the final cracked status shows 0/XXX progress
840
841 if (data.salts_shown[salt_pos] == 1) continue;
842 }
843
844 all_done += data.words_progress_done[salt_pos];
845 all_rejected += data.words_progress_rejected[salt_pos];
846 all_restored += data.words_progress_restored[salt_pos];
847 }
848
849 u64 progress_cur = all_restored + all_done + all_rejected;
850 u64 progress_end = progress_total;
851
852 u64 progress_skip = 0;
853
854 if (data.skip)
855 {
856 progress_skip = MIN (data.skip, data.words_base) * salts_left;
857
858 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
859 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
860 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
861 }
862
863 if (data.limit)
864 {
865 progress_end = MIN (data.limit, data.words_base) * salts_left;
866
867 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
868 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
869 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
870 }
871
872 u64 progress_cur_relative_skip = progress_cur - progress_skip;
873 u64 progress_end_relative_skip = progress_end - progress_skip;
874
875 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
876
877 /**
878 * cracks
879 */
880
881 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
882 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
883
884 /**
885 * temperature
886 */
887
888 #ifdef HAVE_HWMON
889 if (data.gpu_temp_disable == 0)
890 {
891 fprintf (out, "TEMP\t");
892
893 hc_thread_mutex_lock (mux_adl);
894
895 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
896 {
897 hc_device_param_t *device_param = &data.devices_param[device_id];
898
899 if (device_param->skipped) continue;
900
901 int temp = hm_get_temperature_with_device_id (device_id);
902
903 fprintf (out, "%d\t", temp);
904 }
905
906 hc_thread_mutex_unlock (mux_adl);
907 }
908 #endif // HAVE_HWMON
909
910 /**
911 * flush
912 */
913
914 #ifdef _WIN
915 fputc ('\r', out);
916 fputc ('\n', out);
917 #endif
918
919 #ifdef _POSIX
920 fputc ('\n', out);
921 #endif
922
923 fflush (out);
924 }
925
926 void status_display ()
927 {
928 if (data.devices_status == STATUS_INIT) return;
929 if (data.devices_status == STATUS_STARTING) return;
930 if (data.devices_status == STATUS_BYPASS) return;
931
932 if (data.status_automat == 1)
933 {
934 status_display_automat ();
935
936 return;
937 }
938
939 char tmp_buf[1000] = { 0 };
940
941 uint tmp_len = 0;
942
943 log_info ("Session.Name...: %s", data.session);
944
945 char *status_type = strstatus (data.devices_status);
946
947 uint hash_mode = data.hash_mode;
948
949 char *hash_type = strhashtype (hash_mode); // not a bug
950
951 log_info ("Status.........: %s", status_type);
952
953 /**
954 * show rules
955 */
956
957 if (data.rp_files_cnt)
958 {
959 uint i;
960
961 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
962 {
963 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
964 }
965
966 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
967
968 log_info ("Rules.Type.....: %s", tmp_buf);
969
970 tmp_len = 0;
971 }
972
973 if (data.rp_gen)
974 {
975 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
976
977 if (data.rp_gen_seed)
978 {
979 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
980 }
981 }
982
983 /**
984 * show input
985 */
986
987 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
988 {
989 if (data.wordlist_mode == WL_MODE_FILE)
990 {
991 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
992 }
993 else if (data.wordlist_mode == WL_MODE_STDIN)
994 {
995 log_info ("Input.Mode.....: Pipe");
996 }
997 }
998 else if (data.attack_mode == ATTACK_MODE_COMBI)
999 {
1000 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1001 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1002 }
1003 else if (data.attack_mode == ATTACK_MODE_BF)
1004 {
1005 char *mask = data.mask;
1006
1007 if (mask != NULL)
1008 {
1009 uint mask_len = data.css_cnt;
1010
1011 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1012
1013 if (mask_len > 0)
1014 {
1015 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1016 {
1017 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1018 {
1019 mask_len -= data.salts_buf[0].salt_len;
1020 }
1021 }
1022
1023 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1024
1025 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1026 }
1027
1028 if (data.maskcnt > 1)
1029 {
1030 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1031
1032 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1033 }
1034
1035 log_info ("Input.Mode.....: %s", tmp_buf);
1036 }
1037
1038 tmp_len = 0;
1039 }
1040 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1041 {
1042 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1043 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 }
1045 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1046 {
1047 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1048 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1049 }
1050
1051 if (data.digests_cnt == 1)
1052 {
1053 if (data.hash_mode == 2500)
1054 {
1055 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1056
1057 uint pke[25] = { 0 };
1058
1059 char *pke_ptr = (char *) pke;
1060
1061 for (uint i = 0; i < 25; i++)
1062 {
1063 pke[i] = byte_swap_32 (wpa->pke[i]);
1064 }
1065
1066 char mac1[6] = { 0 };
1067 char mac2[6] = { 0 };
1068
1069 memcpy (mac1, pke_ptr + 23, 6);
1070 memcpy (mac2, pke_ptr + 29, 6);
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 mac1[0] & 0xff,
1075 mac1[1] & 0xff,
1076 mac1[2] & 0xff,
1077 mac1[3] & 0xff,
1078 mac1[4] & 0xff,
1079 mac1[5] & 0xff,
1080 mac2[0] & 0xff,
1081 mac2[1] & 0xff,
1082 mac2[2] & 0xff,
1083 mac2[3] & 0xff,
1084 mac2[4] & 0xff,
1085 mac2[5] & 0xff);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[4096] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[4096] = { 0 };
1122 char out_buf2[4096] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 float speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 // we need to clear values (set to 0) because in case the device does
1151 // not get new candidates it idles around but speed display would
1152 // show it as working.
1153 // if we instantly set it to 0 after reading it happens that the
1154 // speed can be shown as zero if the users refreshes too fast.
1155 // therefore, we add a timestamp when a stat was recorded and if its
1156 // too old we will not use it
1157
1158 speed_cnt[device_id] = 0;
1159 speed_ms[device_id] = 0;
1160
1161 for (int i = 0; i < SPEED_CACHE; i++)
1162 {
1163 float rec_ms;
1164
1165 hc_timer_get (device_param->speed_rec[i], rec_ms);
1166
1167 if (rec_ms > SPEED_MAXAGE) continue;
1168
1169 speed_cnt[device_id] += device_param->speed_cnt[i];
1170 speed_ms[device_id] += device_param->speed_ms[i];
1171 }
1172
1173 speed_cnt[device_id] /= SPEED_CACHE;
1174 speed_ms[device_id] /= SPEED_CACHE;
1175 }
1176
1177 float hashes_all_ms = 0;
1178
1179 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1180
1181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1182 {
1183 hc_device_param_t *device_param = &data.devices_param[device_id];
1184
1185 if (device_param->skipped) continue;
1186
1187 hashes_dev_ms[device_id] = 0;
1188
1189 if (speed_ms[device_id])
1190 {
1191 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1192
1193 hashes_all_ms += hashes_dev_ms[device_id];
1194 }
1195 }
1196
1197 /**
1198 * exec time
1199 */
1200
1201 double exec_all_ms[DEVICES_MAX] = { 0 };
1202
1203 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1204 {
1205 hc_device_param_t *device_param = &data.devices_param[device_id];
1206
1207 if (device_param->skipped) continue;
1208
1209 double exec_ms_total = 0;
1210
1211 int exec_ms_cnt = 0;
1212
1213 for (int i = 0; i < EXEC_CACHE; i++)
1214 {
1215 double exec_ms = device_param->exec_ms[i];
1216
1217 if (exec_ms)
1218 {
1219 exec_ms_total += exec_ms;
1220
1221 exec_ms_cnt++;
1222 }
1223 }
1224
1225 exec_ms_total /= exec_ms_cnt;
1226
1227 exec_all_ms[device_id] = exec_ms_total;
1228 }
1229
1230 /**
1231 * timers
1232 */
1233
1234 float ms_running = 0;
1235
1236 hc_timer_get (data.timer_running, ms_running);
1237
1238 float ms_paused = data.ms_paused;
1239
1240 if (data.devices_status == STATUS_PAUSED)
1241 {
1242 float ms_paused_tmp = 0;
1243
1244 hc_timer_get (data.timer_paused, ms_paused_tmp);
1245
1246 ms_paused += ms_paused_tmp;
1247 }
1248
1249 #ifdef WIN
1250
1251 __time64_t sec_run = ms_running / 1000;
1252
1253 #else
1254
1255 time_t sec_run = ms_running / 1000;
1256
1257 #endif
1258
1259 if (sec_run)
1260 {
1261 char display_run[32] = { 0 };
1262
1263 struct tm tm_run;
1264
1265 struct tm *tmp = NULL;
1266
1267 #ifdef WIN
1268
1269 tmp = _gmtime64 (&sec_run);
1270
1271 #else
1272
1273 tmp = gmtime (&sec_run);
1274
1275 #endif
1276
1277 if (tmp != NULL)
1278 {
1279 memset (&tm_run, 0, sizeof (tm_run));
1280
1281 memcpy (&tm_run, tmp, sizeof (tm_run));
1282
1283 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1284
1285 char *start = ctime (&data.proc_start);
1286
1287 size_t start_len = strlen (start);
1288
1289 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1290 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1291
1292 log_info ("Time.Started...: %s (%s)", start, display_run);
1293 }
1294 }
1295 else
1296 {
1297 log_info ("Time.Started...: 0 secs");
1298 }
1299
1300 /**
1301 * counters
1302 */
1303
1304 uint salts_left = data.salts_cnt - data.salts_done;
1305
1306 if (salts_left == 0) salts_left = 1;
1307
1308 u64 progress_total = data.words_cnt * salts_left;
1309
1310 u64 all_done = 0;
1311 u64 all_rejected = 0;
1312 u64 all_restored = 0;
1313
1314 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1315 {
1316 if (salts_left > 1)
1317 {
1318 // otherwise the final cracked status shows 0/XXX progress
1319
1320 if (data.salts_shown[salt_pos] == 1) continue;
1321 }
1322
1323 all_done += data.words_progress_done[salt_pos];
1324 all_rejected += data.words_progress_rejected[salt_pos];
1325 all_restored += data.words_progress_restored[salt_pos];
1326 }
1327
1328 u64 progress_cur = all_restored + all_done + all_rejected;
1329 u64 progress_end = progress_total;
1330
1331 u64 progress_skip = 0;
1332
1333 if (data.skip)
1334 {
1335 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1336
1337 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1340 }
1341
1342 if (data.limit)
1343 {
1344 progress_end = MIN (data.limit, data.words_base) * salts_left;
1345
1346 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1347 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1348 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1349 }
1350
1351 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1352 u64 progress_end_relative_skip = progress_end - progress_skip;
1353
1354 float speed_ms_real = ms_running - ms_paused;
1355 u64 speed_plains_real = all_done;
1356
1357 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1358 {
1359 if (data.devices_status != STATUS_CRACKED)
1360 {
1361 u64 words_per_ms = 0;
1362
1363 if (speed_plains_real && speed_ms_real)
1364 {
1365 words_per_ms = speed_plains_real / speed_ms_real;
1366 }
1367
1368 #ifdef WIN
1369 __time64_t sec_etc = 0;
1370 #else
1371 time_t sec_etc = 0;
1372 #endif
1373
1374 if (words_per_ms)
1375 {
1376 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1377
1378 u64 ms_left = progress_left_relative_skip / words_per_ms;
1379
1380 sec_etc = ms_left / 1000;
1381 }
1382
1383 if (sec_etc == 0)
1384 {
1385 log_info ("Time.Estimated.: 0 secs");
1386 }
1387 else if ((u64) sec_etc > ETC_MAX)
1388 {
1389 log_info ("Time.Estimated.: > 10 Years");
1390 }
1391 else
1392 {
1393 char display_etc[32] = { 0 };
1394
1395 struct tm tm_etc;
1396
1397 struct tm *tmp = NULL;
1398
1399 #ifdef WIN
1400
1401 tmp = _gmtime64 (&sec_etc);
1402
1403 #else
1404
1405 tmp = gmtime (&sec_etc);
1406
1407 #endif
1408
1409 if (tmp != NULL)
1410 {
1411 memset (&tm_etc, 0, sizeof (tm_etc));
1412
1413 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1414
1415 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1416
1417 time_t now;
1418
1419 time (&now);
1420
1421 now += sec_etc;
1422
1423 char *etc = ctime (&now);
1424
1425 size_t etc_len = strlen (etc);
1426
1427 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1428 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1429
1430 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1431 }
1432 }
1433 }
1434 }
1435
1436 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1437 {
1438 hc_device_param_t *device_param = &data.devices_param[device_id];
1439
1440 if (device_param->skipped) continue;
1441
1442 char display_dev_cur[16] = { 0 };
1443
1444 strncpy (display_dev_cur, "0.00", 4);
1445
1446 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1447
1448 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1449 }
1450
1451 char display_all_cur[16] = { 0 };
1452
1453 strncpy (display_all_cur, "0.00", 4);
1454
1455 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1456
1457 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1458
1459 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1460 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1461
1462 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1463
1464 // crack-per-time
1465
1466 if (data.digests_cnt > 100)
1467 {
1468 time_t now = time (NULL);
1469
1470 int cpt_cur_min = 0;
1471 int cpt_cur_hour = 0;
1472 int cpt_cur_day = 0;
1473
1474 for (int i = 0; i < CPT_BUF; i++)
1475 {
1476 const uint cracked = data.cpt_buf[i].cracked;
1477 const time_t timestamp = data.cpt_buf[i].timestamp;
1478
1479 if ((timestamp + 60) > now)
1480 {
1481 cpt_cur_min += cracked;
1482 }
1483
1484 if ((timestamp + 3600) > now)
1485 {
1486 cpt_cur_hour += cracked;
1487 }
1488
1489 if ((timestamp + 86400) > now)
1490 {
1491 cpt_cur_day += cracked;
1492 }
1493 }
1494
1495 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1496 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1497 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1498
1499 if ((data.cpt_start + 86400) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_cur_hour,
1504 cpt_cur_day,
1505 cpt_avg_min,
1506 cpt_avg_hour,
1507 cpt_avg_day);
1508 }
1509 else if ((data.cpt_start + 3600) < now)
1510 {
1511 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1512 cpt_cur_min,
1513 cpt_cur_hour,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else if ((data.cpt_start + 60) < now)
1519 {
1520 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_cur_min,
1522 cpt_avg_min,
1523 cpt_avg_hour,
1524 cpt_avg_day);
1525 }
1526 else
1527 {
1528 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1529 cpt_avg_min,
1530 cpt_avg_hour,
1531 cpt_avg_day);
1532 }
1533 }
1534
1535 // Restore point
1536
1537 u64 restore_point = get_lowest_words_done ();
1538
1539 u64 restore_total = data.words_base;
1540
1541 float percent_restore = 0;
1542
1543 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1544
1545 if (progress_end_relative_skip)
1546 {
1547 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1548 {
1549 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1550 float percent_rejected = 0.0;
1551
1552 if (progress_cur)
1553 {
1554 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1555 }
1556
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 if (percent_finished != 1)
1563 {
1564 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1565 }
1566 }
1567 }
1568 }
1569 else
1570 {
1571 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1572 {
1573 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1574 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1575
1576 if (data.restore_disable == 0)
1577 {
1578 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1579 }
1580 }
1581 else
1582 {
1583 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1584 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1585
1586 // --restore not allowed if stdin is used -- really? why?
1587
1588 //if (data.restore_disable == 0)
1589 //{
1590 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1591 //}
1592 }
1593 }
1594
1595 #ifdef HAVE_HWMON
1596 if (data.gpu_temp_disable == 0)
1597 {
1598 hc_thread_mutex_lock (mux_adl);
1599
1600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1601 {
1602 hc_device_param_t *device_param = &data.devices_param[device_id];
1603
1604 if (device_param->skipped) continue;
1605
1606 #define HM_STR_BUF_SIZE 255
1607
1608 if (data.hm_device[device_id].fan_supported == 1)
1609 {
1610 char utilization[HM_STR_BUF_SIZE] = { 0 };
1611 char temperature[HM_STR_BUF_SIZE] = { 0 };
1612 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1613
1614 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1615 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1616
1617 if (device_param->vendor_id == VENDOR_ID_AMD)
1618 {
1619 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1620 }
1621 else if (device_param->vendor_id == VENDOR_ID_NV)
1622 {
1623 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1624 }
1625
1626 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1627 }
1628 else
1629 {
1630 char utilization[HM_STR_BUF_SIZE] = { 0 };
1631 char temperature[HM_STR_BUF_SIZE] = { 0 };
1632
1633 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1634 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1635
1636 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1637 }
1638 }
1639
1640 hc_thread_mutex_unlock (mux_adl);
1641 }
1642 #endif // HAVE_HWMON
1643 }
1644
1645 static void status_benchmark ()
1646 {
1647 if (data.devices_status == STATUS_INIT) return;
1648 if (data.devices_status == STATUS_STARTING) return;
1649
1650 if (data.words_cnt == 0) return;
1651
1652 u64 speed_cnt[DEVICES_MAX] = { 0 };
1653 float speed_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 speed_cnt[device_id] = 0;
1662 speed_ms[device_id] = 0;
1663
1664 for (int i = 0; i < SPEED_CACHE; i++)
1665 {
1666 speed_cnt[device_id] += device_param->speed_cnt[i];
1667 speed_ms[device_id] += device_param->speed_ms[i];
1668 }
1669
1670 speed_cnt[device_id] /= SPEED_CACHE;
1671 speed_ms[device_id] /= SPEED_CACHE;
1672 }
1673
1674 float hashes_all_ms = 0;
1675
1676 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1677
1678 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1679 {
1680 hc_device_param_t *device_param = &data.devices_param[device_id];
1681
1682 if (device_param->skipped) continue;
1683
1684 hashes_dev_ms[device_id] = 0;
1685
1686 if (speed_ms[device_id])
1687 {
1688 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1689
1690 hashes_all_ms += hashes_dev_ms[device_id];
1691 }
1692 }
1693
1694 /**
1695 * exec time
1696 */
1697
1698 double exec_all_ms[DEVICES_MAX] = { 0 };
1699
1700 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1701 {
1702 hc_device_param_t *device_param = &data.devices_param[device_id];
1703
1704 if (device_param->skipped) continue;
1705
1706 double exec_ms_total = 0;
1707
1708 int exec_ms_cnt = 0;
1709
1710 for (int i = 0; i < EXEC_CACHE; i++)
1711 {
1712 double exec_ms = device_param->exec_ms[i];
1713
1714 if (exec_ms)
1715 {
1716 exec_ms_total += exec_ms;
1717
1718 exec_ms_cnt++;
1719 }
1720 }
1721
1722 exec_ms_total /= exec_ms_cnt;
1723
1724 exec_all_ms[device_id] = exec_ms_total;
1725 }
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 char display_dev_cur[16] = { 0 };
1734
1735 strncpy (display_dev_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1738
1739 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1740 }
1741
1742 char display_all_cur[16] = { 0 };
1743
1744 strncpy (display_all_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1747
1748 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1749 }
1750
1751 /**
1752 * oclHashcat -only- functions
1753 */
1754
1755 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1756 {
1757 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1758 {
1759 if (attack_kern == ATTACK_KERN_STRAIGHT)
1760 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1761 else if (attack_kern == ATTACK_KERN_COMBI)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_BF)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1765 }
1766 else
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1768 }
1769
1770 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1792 }
1793 else
1794 {
1795 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1796 }
1797 }
1798
1799 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1800 {
1801 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1802 {
1803 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1812 {
1813 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1814 }
1815
1816 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1819 }
1820
1821 static uint convert_from_hex (char *line_buf, const uint line_len)
1822 {
1823 if (line_len & 1) return (line_len); // not in hex
1824
1825 if (data.hex_wordlist == 1)
1826 {
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839 else if (line_len >= 6) // $HEX[] = 6
1840 {
1841 if (line_buf[0] != '$') return (line_len);
1842 if (line_buf[1] != 'H') return (line_len);
1843 if (line_buf[2] != 'E') return (line_len);
1844 if (line_buf[3] != 'X') return (line_len);
1845 if (line_buf[4] != '[') return (line_len);
1846 if (line_buf[line_len - 1] != ']') return (line_len);
1847
1848 uint i;
1849 uint j;
1850
1851 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1852 {
1853 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1854 }
1855
1856 memset (line_buf + i, 0, line_len - i);
1857
1858 return (i);
1859 }
1860
1861 return (line_len);
1862 }
1863
1864 static void clear_prompt ()
1865 {
1866 fputc ('\r', stdout);
1867
1868 for (size_t i = 0; i < strlen (PROMPT); i++)
1869 {
1870 fputc (' ', stdout);
1871 }
1872
1873 fputc ('\r', stdout);
1874
1875 fflush (stdout);
1876 }
1877
1878 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1879 {
1880 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1881 }
1882
1883 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1884 {
1885 char *outfile = data.outfile;
1886 uint quiet = data.quiet;
1887 FILE *pot_fp = data.pot_fp;
1888 uint loopback = data.loopback;
1889 uint debug_mode = data.debug_mode;
1890 char *debug_file = data.debug_file;
1891
1892 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1893 int debug_rule_len = 0; // -1 error
1894 uint debug_plain_len = 0;
1895
1896 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1897
1898 // hash
1899
1900 char out_buf[4096] = { 0 };
1901
1902 ascii_digest (out_buf, salt_pos, digest_pos);
1903
1904 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1905
1906 // plain
1907
1908 plain_t plain;
1909
1910 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1911
1912 uint gidvid = plain.gidvid;
1913 uint il_pos = plain.il_pos;
1914
1915 u64 crackpos = device_param->words_off;
1916
1917 uint plain_buf[16] = { 0 };
1918
1919 u8 *plain_ptr = (u8 *) plain_buf;
1920 unsigned int plain_len = 0;
1921
1922 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1923 {
1924 u64 gidd = gidvid;
1925 u64 gidm = 0;
1926
1927 pw_t pw;
1928
1929 gidd_to_pw_t (device_param, gidd, &pw);
1930
1931 for (int i = 0, j = gidm; i < 16; i++, j++)
1932 {
1933 plain_buf[i] = pw.h.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 const uint off = device_param->innerloop_pos + il_pos;
1939
1940 if (debug_mode > 0)
1941 {
1942 debug_rule_len = 0;
1943
1944 // save rule
1945 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1946 {
1947 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1948
1949 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1950 }
1951
1952 // save plain
1953 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1954 {
1955 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1956
1957 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1958
1959 debug_plain_len = plain_len;
1960 }
1961 }
1962
1963 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1964
1965 crackpos += gidvid;
1966 crackpos *= data.kernel_rules_cnt;
1967 crackpos += device_param->innerloop_pos + il_pos;
1968
1969 if (plain_len > data.pw_max) plain_len = data.pw_max;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_COMBI)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.h.hi1[0][j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1988 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1989
1990 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1991 {
1992 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1993 }
1994 else
1995 {
1996 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1997
1998 memcpy (plain_ptr, comb_buf, comb_len);
1999 }
2000
2001 plain_len += comb_len;
2002
2003 crackpos += gidvid;
2004 crackpos *= data.combs_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006
2007 if (data.pw_max != PW_DICTMAX1)
2008 {
2009 if (plain_len > data.pw_max) plain_len = data.pw_max;
2010 }
2011 }
2012 else if (data.attack_mode == ATTACK_MODE_BF)
2013 {
2014 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2015 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2016
2017 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2018 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2019
2020 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2021 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2022
2023 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2024 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2025
2026 plain_len = data.css_cnt;
2027
2028 crackpos += gidvid;
2029 crackpos *= data.bfs_cnt;
2030 crackpos += device_param->innerloop_pos + il_pos;
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2033 {
2034 u64 gidd = gidvid;
2035 u64 gidm = 0;
2036
2037 pw_t pw;
2038
2039 gidd_to_pw_t (device_param, gidd, &pw);
2040
2041 for (int i = 0, j = gidm; i < 16; i++, j++)
2042 {
2043 plain_buf[i] = pw.h.hi1[0][j];
2044 }
2045
2046 plain_len = pw.pw_len;
2047
2048 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2049
2050 uint start = 0;
2051 uint stop = device_param->kernel_params_mp_buf32[4];
2052
2053 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2054
2055 plain_len += start + stop;
2056
2057 crackpos += gidvid;
2058 crackpos *= data.combs_cnt;
2059 crackpos += device_param->innerloop_pos + il_pos;
2060
2061 if (data.pw_max != PW_DICTMAX1)
2062 {
2063 if (plain_len > data.pw_max) plain_len = data.pw_max;
2064 }
2065 }
2066 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2067 {
2068 u64 gidd = gidvid;
2069 u64 gidm = 0;
2070
2071 pw_t pw;
2072
2073 gidd_to_pw_t (device_param, gidd, &pw);
2074
2075 for (int i = 0, j = gidm; i < 16; i++, j++)
2076 {
2077 plain_buf[i] = pw.h.hi1[0][j];
2078 }
2079
2080 plain_len = pw.pw_len;
2081
2082 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2083
2084 uint start = 0;
2085 uint stop = device_param->kernel_params_mp_buf32[4];
2086
2087 memmove (plain_ptr + stop, plain_ptr, plain_len);
2088
2089 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2090
2091 plain_len += start + stop;
2092
2093 crackpos += gidvid;
2094 crackpos *= data.combs_cnt;
2095 crackpos += device_param->innerloop_pos + il_pos;
2096
2097 if (data.pw_max != PW_DICTMAX1)
2098 {
2099 if (plain_len > data.pw_max) plain_len = data.pw_max;
2100 }
2101 }
2102
2103 if (data.attack_mode == ATTACK_MODE_BF)
2104 {
2105 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2106 {
2107 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2108 {
2109 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2110 {
2111 plain_len = plain_len - data.salts_buf[0].salt_len;
2112 }
2113 }
2114
2115 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2116 {
2117 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2118 {
2119 plain_ptr[j] = plain_ptr[i];
2120 }
2121
2122 plain_len = plain_len / 2;
2123 }
2124 }
2125 }
2126
2127 // if enabled, update also the potfile
2128
2129 if (pot_fp)
2130 {
2131 lock_file (pot_fp);
2132
2133 fprintf (pot_fp, "%s:", out_buf);
2134
2135 format_plain (pot_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', pot_fp);
2138
2139 fflush (pot_fp);
2140
2141 unlock_file (pot_fp);
2142 }
2143
2144 // outfile
2145
2146 FILE *out_fp = NULL;
2147
2148 if (outfile != NULL)
2149 {
2150 if ((out_fp = fopen (outfile, "ab")) == NULL)
2151 {
2152 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2153
2154 out_fp = stdout;
2155 }
2156 lock_file (out_fp);
2157 }
2158 else
2159 {
2160 out_fp = stdout;
2161
2162 if (quiet == 0) clear_prompt ();
2163 }
2164
2165 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2166
2167 if (outfile != NULL)
2168 {
2169 if (out_fp != stdout)
2170 {
2171 fclose (out_fp);
2172 }
2173 }
2174 else
2175 {
2176 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2177 {
2178 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2179 {
2180 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2181 if (quiet == 0) fflush (stdout);
2182 }
2183 }
2184 }
2185
2186 // loopback
2187
2188 if (loopback)
2189 {
2190 char *loopback_file = data.loopback_file;
2191
2192 FILE *fb_fp = NULL;
2193
2194 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2195 {
2196 lock_file (fb_fp);
2197
2198 format_plain (fb_fp, plain_ptr, plain_len, 1);
2199
2200 fputc ('\n', fb_fp);
2201
2202 fclose (fb_fp);
2203 }
2204 }
2205
2206 // (rule) debug mode
2207
2208 // the next check implies that:
2209 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2210 // - debug_mode > 0
2211
2212 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2213 {
2214 if (debug_rule_len < 0) debug_rule_len = 0;
2215
2216 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2217
2218 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2219
2220 if ((quiet == 0) && (debug_file == NULL))
2221 {
2222 fprintf (stdout, "%s", PROMPT);
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 int found = 0;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2235
2236 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2237
2238 if (found == 1)
2239 {
2240 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2241
2242 log_info_nn ("");
2243
2244 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2249 {
2250 uint idx = salt_buf->digests_offset + digest_pos;
2251
2252 if (data.digests_shown_tmp[idx] == 0) continue;
2253
2254 if (data.digests_shown[idx] == 1) continue;
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[idx] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 check_hash (device_param, salt_pos, digest_pos);
2277 }
2278
2279 if (cpt_cracked > 0)
2280 {
2281 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2282 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2283
2284 data.cpt_pos++;
2285
2286 data.cpt_total += cpt_cracked;
2287
2288 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2289 }
2290
2291 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2292 {
2293 // we need to reset cracked state on the device
2294 // otherwise host thinks again and again the hash was cracked
2295 // and returns invalid password each time
2296
2297 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2298
2299 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2300 }
2301
2302 memset (device_param->result, 0, device_param->size_results);
2303
2304 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2305 }
2306 }
2307
2308 static void save_hash ()
2309 {
2310 char *hashfile = data.hashfile;
2311
2312 char new_hashfile[256] = { 0 };
2313 char old_hashfile[256] = { 0 };
2314
2315 snprintf (new_hashfile, 255, "%s.new", hashfile);
2316 snprintf (old_hashfile, 255, "%s.old", hashfile);
2317
2318 unlink (new_hashfile);
2319
2320 char separator = data.separator;
2321
2322 FILE *fp = fopen (new_hashfile, "wb");
2323
2324 if (fp == NULL)
2325 {
2326 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2327
2328 exit (-1);
2329 }
2330
2331 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2332 {
2333 if (data.salts_shown[salt_pos] == 1) continue;
2334
2335 salt_t *salt_buf = &data.salts_buf[salt_pos];
2336
2337 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2338 {
2339 uint idx = salt_buf->digests_offset + digest_pos;
2340
2341 if (data.digests_shown[idx] == 1) continue;
2342
2343 if (data.hash_mode != 2500)
2344 {
2345 char out_buf[4096] = { 0 };
2346
2347 if (data.username == 1)
2348 {
2349 user_t *user = data.hash_info[idx]->user;
2350
2351 uint i;
2352
2353 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2354
2355 fputc (separator, fp);
2356 }
2357
2358 ascii_digest (out_buf, salt_pos, digest_pos);
2359
2360 fputs (out_buf, fp);
2361
2362 log_out (fp, "");
2363 }
2364 else
2365 {
2366 hccap_t hccap;
2367
2368 to_hccap_t (&hccap, salt_pos, digest_pos);
2369
2370 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2371 }
2372 }
2373 }
2374
2375 fflush (fp);
2376
2377 fclose (fp);
2378
2379 unlink (old_hashfile);
2380
2381 if (rename (hashfile, old_hashfile) != 0)
2382 {
2383 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2384
2385 exit (-1);
2386 }
2387
2388 unlink (hashfile);
2389
2390 if (rename (new_hashfile, hashfile) != 0)
2391 {
2392 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2393
2394 exit (-1);
2395 }
2396
2397 unlink (old_hashfile);
2398 }
2399
2400 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2401 {
2402 // function called only in case kernel_blocks_all > words_left)
2403
2404 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2405
2406 kernel_blocks_div += kernel_blocks_div / 100;
2407
2408 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2409
2410 while (kernel_blocks_new < total_left)
2411 {
2412 kernel_blocks_div += kernel_blocks_div / 100;
2413
2414 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2415 }
2416
2417 if (data.quiet == 0)
2418 {
2419 clear_prompt ();
2420
2421 log_info ("");
2422
2423 log_info ("INFO: approaching final keyspace, workload adjusted");
2424
2425 log_info ("");
2426
2427 fprintf (stdout, "%s", PROMPT);
2428
2429 fflush (stdout);
2430 }
2431
2432 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2433
2434 return kernel_blocks_div;
2435 }
2436
2437 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2438 {
2439 uint num_elements = num;
2440
2441 device_param->kernel_params_buf32[30] = data.combs_mode;
2442 device_param->kernel_params_buf32[31] = num;
2443
2444 uint kernel_threads = device_param->kernel_threads;
2445
2446 while (num_elements % kernel_threads) num_elements++;
2447
2448 cl_kernel kernel = NULL;
2449
2450 switch (kern_run)
2451 {
2452 case KERN_RUN_1: kernel = device_param->kernel1; break;
2453 case KERN_RUN_12: kernel = device_param->kernel12; break;
2454 case KERN_RUN_2: kernel = device_param->kernel2; break;
2455 case KERN_RUN_23: kernel = device_param->kernel23; break;
2456 case KERN_RUN_3: kernel = device_param->kernel3; break;
2457 }
2458
2459 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2460 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2461 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2462 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2463 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2464 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2465 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2466 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2467 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2468 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2469 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2470
2471 cl_event event;
2472
2473 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2474 {
2475 const size_t global_work_size[3] = { num_elements, 32, 1 };
2476 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2477
2478 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2479 }
2480 else
2481 {
2482 size_t workgroup_size = 0;
2483 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2484 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2485
2486 const size_t global_work_size[3] = { num_elements, 1, 1 };
2487 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2488
2489 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2490 }
2491
2492 hc_clFlush (data.ocl, device_param->command_queue);
2493
2494 hc_clWaitForEvents (data.ocl, 1, &event);
2495
2496 if (event_update)
2497 {
2498 cl_ulong time_start;
2499 cl_ulong time_end;
2500
2501 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2503
2504 const double exec_time = (time_end - time_start) / 1000000.0;
2505
2506 uint exec_pos = device_param->exec_pos;
2507
2508 device_param->exec_ms[exec_pos] = exec_time;
2509
2510 exec_pos++;
2511
2512 if (exec_pos == EXEC_CACHE)
2513 {
2514 exec_pos = 0;
2515 }
2516
2517 device_param->exec_pos = exec_pos;
2518 }
2519
2520 hc_clReleaseEvent (data.ocl, event);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2526 {
2527 uint num_elements = num;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2532 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2533 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2534 }
2535
2536 // causes problems with special threads like in bcrypt
2537 // const uint kernel_threads = device_param->kernel_threads;
2538
2539 uint kernel_threads = KERNEL_THREADS;
2540
2541 while (num_elements % kernel_threads) num_elements++;
2542
2543 cl_kernel kernel = NULL;
2544
2545 switch (kern_run)
2546 {
2547 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2548 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2549 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2550 }
2551
2552 switch (kern_run)
2553 {
2554 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2555 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2556 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2557 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2558 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2559 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2560 break;
2561 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2562 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2565 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2566 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2567 break;
2568 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2569 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2570 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2571 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2572 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2573 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2574 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2575 break;
2576 }
2577
2578 size_t workgroup_size = 0;
2579 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2580 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2581
2582 const size_t global_work_size[3] = { num_elements, 1, 1 };
2583 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2584
2585 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2586
2587 hc_clFlush (data.ocl, device_param->command_queue);
2588
2589 hc_clFinish (data.ocl, device_param->command_queue);
2590 }
2591
2592 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2593 {
2594 uint num_elements = num;
2595
2596 uint kernel_threads = device_param->kernel_threads;
2597
2598 while (num_elements % kernel_threads) num_elements++;
2599
2600 cl_kernel kernel = device_param->kernel_tb;
2601
2602 size_t workgroup_size = 0;
2603 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2604 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2605
2606 const size_t global_work_size[3] = { num_elements, 1, 1 };
2607 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2608
2609 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2610
2611 hc_clFlush (data.ocl, device_param->command_queue);
2612
2613 hc_clFinish (data.ocl, device_param->command_queue);
2614 }
2615
2616 static void run_kernel_tm (hc_device_param_t *device_param)
2617 {
2618 const uint num_elements = 1024; // fixed
2619
2620 uint kernel_threads = 32;
2621
2622 cl_kernel kernel = device_param->kernel_tm;
2623
2624 size_t workgroup_size = 0;
2625 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2626 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2627
2628 const size_t global_work_size[3] = { num_elements, 1, 1 };
2629 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2630
2631 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2632
2633 hc_clFlush (data.ocl, device_param->command_queue);
2634
2635 hc_clFinish (data.ocl, device_param->command_queue);
2636 }
2637
2638 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2639 {
2640 uint num_elements = num;
2641
2642 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2643 device_param->kernel_params_amp_buf32[6] = num_elements;
2644
2645 // causes problems with special threads like in bcrypt
2646 // const uint kernel_threads = device_param->kernel_threads;
2647
2648 uint kernel_threads = KERNEL_THREADS;
2649
2650 while (num_elements % kernel_threads) num_elements++;
2651
2652 cl_kernel kernel = device_param->kernel_amp;
2653
2654 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2655 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2656
2657 size_t workgroup_size = 0;
2658 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2659 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2660
2661 const size_t global_work_size[3] = { num_elements, 1, 1 };
2662 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2663
2664 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2665
2666 hc_clFlush (data.ocl, device_param->command_queue);
2667
2668 hc_clFinish (data.ocl, device_param->command_queue);
2669 }
2670
2671 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2672 {
2673 int rc = -1;
2674
2675 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2676 {
2677 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2678
2679 const cl_uchar zero = 0;
2680
2681 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2682 }
2683
2684 if (rc != 0)
2685 {
2686 // NOTE: clEnqueueFillBuffer () always fails with -59
2687 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2688 // How's that possible, OpenCL 1.2 support is advertised??
2689 // We need to workaround...
2690
2691 #define FILLSZ 0x100000
2692
2693 char *tmp = (char *) mymalloc (FILLSZ);
2694
2695 for (uint i = 0; i < size; i += FILLSZ)
2696 {
2697 const int left = size - i;
2698
2699 const int fillsz = MIN (FILLSZ, left);
2700
2701 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2702 }
2703
2704 myfree (tmp);
2705 }
2706 }
2707
2708 static int run_rule_engine (const int rule_len, const char *rule_buf)
2709 {
2710 if (rule_len == 0)
2711 {
2712 return 0;
2713 }
2714 else if (rule_len == 1)
2715 {
2716 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2717 }
2718
2719 return 1;
2720 }
2721
2722 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2723 {
2724 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2725 {
2726 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);
2727 }
2728 else if (data.attack_kern == ATTACK_KERN_COMBI)
2729 {
2730 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);
2731 }
2732 else if (data.attack_kern == ATTACK_KERN_BF)
2733 {
2734 const u64 off = device_param->words_off;
2735
2736 device_param->kernel_params_mp_l_buf64[3] = off;
2737
2738 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2739 }
2740 }
2741
2742 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2743 {
2744 const uint kernel_loops = device_param->kernel_loops;
2745
2746 //only useful in debug
2747 //if (data.quiet == 0)
2748 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2749
2750 // init speed timer
2751
2752 uint speed_pos = device_param->speed_pos;
2753
2754 #ifdef _POSIX
2755 if (device_param->timer_speed.tv_sec == 0)
2756 {
2757 hc_timer_set (&device_param->timer_speed);
2758 }
2759 #endif
2760
2761 #ifdef _WIN
2762 if (device_param->timer_speed.QuadPart == 0)
2763 {
2764 hc_timer_set (&device_param->timer_speed);
2765 }
2766 #endif
2767
2768 // find higest password length, this is for optimization stuff
2769
2770 uint highest_pw_len = 0;
2771
2772 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2773 {
2774 }
2775 else if (data.attack_kern == ATTACK_KERN_COMBI)
2776 {
2777 }
2778 else if (data.attack_kern == ATTACK_KERN_BF)
2779 {
2780 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2781 + device_param->kernel_params_mp_l_buf32[5];
2782 }
2783
2784 // bitslice optimization stuff
2785
2786 if (data.attack_mode == ATTACK_MODE_BF)
2787 {
2788 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2789 {
2790 run_kernel_tb (device_param, pws_cnt);
2791 }
2792 }
2793
2794 // iteration type
2795
2796 uint innerloop_step = 0;
2797 uint innerloop_cnt = 0;
2798
2799 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2800 else innerloop_step = 1;
2801
2802 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2803 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2804 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2805
2806 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2807
2808 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2809 {
2810 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2811
2812 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2813
2814 if (data.devices_status == STATUS_CRACKED) break;
2815 if (data.devices_status == STATUS_ABORTED) break;
2816 if (data.devices_status == STATUS_QUIT) break;
2817 if (data.devices_status == STATUS_BYPASS) break;
2818
2819 if (data.salts_shown[salt_pos] == 1) continue;
2820
2821 salt_t *salt_buf = &data.salts_buf[salt_pos];
2822
2823 device_param->kernel_params_buf32[24] = salt_pos;
2824 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2825 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2826
2827 FILE *combs_fp = device_param->combs_fp;
2828
2829 if (data.attack_mode == ATTACK_MODE_COMBI)
2830 {
2831 rewind (combs_fp);
2832 }
2833
2834 // innerloops
2835
2836 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2837 {
2838 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2839
2840 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2841
2842 if (data.devices_status == STATUS_CRACKED) break;
2843 if (data.devices_status == STATUS_ABORTED) break;
2844 if (data.devices_status == STATUS_QUIT) break;
2845 if (data.devices_status == STATUS_BYPASS) break;
2846
2847 uint innerloop_left = innerloop_cnt - innerloop_pos;
2848
2849 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2850
2851 device_param->innerloop_pos = innerloop_pos;
2852 device_param->innerloop_left = innerloop_left;
2853
2854 device_param->kernel_params_buf32[27] = innerloop_left;
2855
2856 if (innerloop_left == 0) continue;
2857
2858 // initialize amplifiers
2859
2860 if (data.attack_mode == ATTACK_MODE_COMBI)
2861 {
2862 char line_buf[BUFSIZ] = { 0 };
2863
2864 uint i = 0;
2865
2866 while (i < innerloop_left)
2867 {
2868 if (feof (combs_fp)) break;
2869
2870 int line_len = fgetl (combs_fp, line_buf);
2871
2872 if (line_len >= PW_MAX1) continue;
2873
2874 line_len = convert_from_hex (line_buf, line_len);
2875
2876 char *line_buf_new = line_buf;
2877
2878 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2879 {
2880 char rule_buf_out[BLOCK_SIZE] = { 0 };
2881
2882 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2883
2884 if (rule_len_out < 0)
2885 {
2886 data.words_progress_rejected[salt_pos] += pw_cnt;
2887
2888 continue;
2889 }
2890
2891 line_len = rule_len_out;
2892
2893 line_buf_new = rule_buf_out;
2894 }
2895
2896 line_len = MIN (line_len, PW_DICTMAX);
2897
2898 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2899
2900 memcpy (ptr, line_buf_new, line_len);
2901
2902 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2903
2904 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2905 {
2906 uppercase (ptr, line_len);
2907 }
2908
2909 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2910 {
2911 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2912 {
2913 ptr[line_len] = 0x80;
2914 }
2915
2916 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2917 {
2918 ptr[line_len] = 0x01;
2919 }
2920 }
2921
2922 device_param->combs_buf[i].pw_len = line_len;
2923
2924 i++;
2925 }
2926
2927 for (uint j = i; j < innerloop_left; j++)
2928 {
2929 device_param->combs_buf[j].i[0] = 0;
2930 device_param->combs_buf[j].i[1] = 0;
2931 device_param->combs_buf[j].i[2] = 0;
2932 device_param->combs_buf[j].i[3] = 0;
2933 device_param->combs_buf[j].i[4] = 0;
2934 device_param->combs_buf[j].i[5] = 0;
2935 device_param->combs_buf[j].i[6] = 0;
2936 device_param->combs_buf[j].i[7] = 0;
2937
2938 device_param->combs_buf[j].pw_len = 0;
2939 }
2940
2941 innerloop_left = i;
2942 }
2943 else if (data.attack_mode == ATTACK_MODE_BF)
2944 {
2945 u64 off = innerloop_pos;
2946
2947 device_param->kernel_params_mp_r_buf64[3] = off;
2948
2949 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2950 }
2951 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2952 {
2953 u64 off = innerloop_pos;
2954
2955 device_param->kernel_params_mp_buf64[3] = off;
2956
2957 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2958 }
2959 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2960 {
2961 u64 off = innerloop_pos;
2962
2963 device_param->kernel_params_mp_buf64[3] = off;
2964
2965 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2966 }
2967
2968 // copy amplifiers
2969
2970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2971 {
2972 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);
2973 }
2974 else if (data.attack_mode == ATTACK_MODE_COMBI)
2975 {
2976 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);
2977 }
2978 else if (data.attack_mode == ATTACK_MODE_BF)
2979 {
2980 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);
2981 }
2982 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2983 {
2984 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);
2985 }
2986 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2987 {
2988 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);
2989 }
2990
2991 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2992 {
2993 if (data.attack_mode == ATTACK_MODE_BF)
2994 {
2995 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2996 {
2997 const uint size_tm = 32 * sizeof (bs_word_t);
2998
2999 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3000
3001 run_kernel_tm (device_param);
3002
3003 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);
3004 }
3005 }
3006
3007 if (highest_pw_len < 16)
3008 {
3009 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3010 }
3011 else if (highest_pw_len < 32)
3012 {
3013 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3014 }
3015 else
3016 {
3017 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3018 }
3019 }
3020 else
3021 {
3022 run_kernel_amp (device_param, pws_cnt);
3023
3024 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3025
3026 if (data.opts_type & OPTS_TYPE_HOOK12)
3027 {
3028 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3029 }
3030
3031 uint iter = salt_buf->salt_iter;
3032
3033 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
3034 {
3035 uint loop_left = iter - loop_pos;
3036
3037 loop_left = MIN (loop_left, kernel_loops);
3038
3039 device_param->kernel_params_buf32[25] = loop_pos;
3040 device_param->kernel_params_buf32[26] = loop_left;
3041
3042 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3043
3044 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3045
3046 if (data.devices_status == STATUS_CRACKED) break;
3047 if (data.devices_status == STATUS_ABORTED) break;
3048 if (data.devices_status == STATUS_QUIT) break;
3049 }
3050
3051 if (data.opts_type & OPTS_TYPE_HOOK23)
3052 {
3053 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3054
3055 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);
3056
3057 // do something with data
3058
3059 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);
3060 }
3061
3062 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3063 }
3064
3065 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3066
3067 if (data.devices_status == STATUS_CRACKED) break;
3068 if (data.devices_status == STATUS_ABORTED) break;
3069 if (data.devices_status == STATUS_QUIT) break;
3070
3071 /**
3072 * result
3073 */
3074
3075 hc_thread_mutex_lock (mux_display);
3076
3077 check_cracked (device_param, salt_pos);
3078
3079 hc_thread_mutex_unlock (mux_display);
3080
3081 /**
3082 * progress
3083 */
3084
3085 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3086
3087 hc_thread_mutex_lock (mux_counter);
3088
3089 data.words_progress_done[salt_pos] += perf_sum_all;
3090
3091 hc_thread_mutex_unlock (mux_counter);
3092
3093 /**
3094 * speed
3095 */
3096
3097 float speed_ms;
3098
3099 hc_timer_get (device_param->timer_speed, speed_ms);
3100
3101 hc_timer_set (&device_param->timer_speed);
3102
3103 hc_thread_mutex_lock (mux_display);
3104
3105 device_param->speed_cnt[speed_pos] = perf_sum_all;
3106
3107 device_param->speed_ms[speed_pos] = speed_ms;
3108
3109 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3110
3111 hc_thread_mutex_unlock (mux_display);
3112
3113 speed_pos++;
3114
3115 if (speed_pos == SPEED_CACHE)
3116 {
3117 speed_pos = 0;
3118 }
3119 }
3120 }
3121
3122 device_param->speed_pos = speed_pos;
3123 }
3124
3125 static void load_segment (wl_data_t *wl_data, FILE *fd)
3126 {
3127 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3128
3129 wl_data->pos = 0;
3130
3131 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3132
3133 wl_data->buf[wl_data->cnt] = 0;
3134
3135 if (wl_data->cnt == 0) return;
3136
3137 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3138
3139 while (!feof (fd))
3140 {
3141 if (wl_data->cnt == wl_data->avail)
3142 {
3143 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3144
3145 wl_data->avail += wl_data->incr;
3146 }
3147
3148 const int c = fgetc (fd);
3149
3150 if (c == EOF) break;
3151
3152 wl_data->buf[wl_data->cnt] = (char) c;
3153
3154 wl_data->cnt++;
3155
3156 if (c == '\n') break;
3157 }
3158
3159 // ensure stream ends with a newline
3160
3161 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3162 {
3163 wl_data->cnt++;
3164
3165 wl_data->buf[wl_data->cnt - 1] = '\n';
3166 }
3167
3168 return;
3169 }
3170
3171 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3172 {
3173 char *ptr = buf;
3174
3175 for (u32 i = 0; i < sz; i++, ptr++)
3176 {
3177 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3178
3179 if (i == 7)
3180 {
3181 *off = i;
3182 *len = i;
3183
3184 return;
3185 }
3186
3187 if (*ptr != '\n') continue;
3188
3189 *off = i + 1;
3190
3191 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3192
3193 *len = i;
3194
3195 return;
3196 }
3197
3198 *off = sz;
3199 *len = sz;
3200 }
3201
3202 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3203 {
3204 char *ptr = buf;
3205
3206 for (u32 i = 0; i < sz; i++, ptr++)
3207 {
3208 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3209
3210 if (*ptr != '\n') continue;
3211
3212 *off = i + 1;
3213
3214 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3215
3216 *len = i;
3217
3218 return;
3219 }
3220
3221 *off = sz;
3222 *len = sz;
3223 }
3224
3225 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3226 {
3227 char *ptr = buf;
3228
3229 for (u32 i = 0; i < sz; i++, ptr++)
3230 {
3231 if (*ptr != '\n') continue;
3232
3233 *off = i + 1;
3234
3235 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3236
3237 *len = i;
3238
3239 return;
3240 }
3241
3242 *off = sz;
3243 *len = sz;
3244 }
3245
3246 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3247 {
3248 while (wl_data->pos < wl_data->cnt)
3249 {
3250 uint off;
3251 uint len;
3252
3253 char *ptr = wl_data->buf + wl_data->pos;
3254
3255 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3256
3257 wl_data->pos += off;
3258
3259 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3260 {
3261 char rule_buf_out[BLOCK_SIZE] = { 0 };
3262
3263 int rule_len_out = -1;
3264
3265 if (len < BLOCK_SIZE)
3266 {
3267 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3268 }
3269
3270 if (rule_len_out < 0)
3271 {
3272 continue;
3273 }
3274
3275 if (rule_len_out > PW_MAX)
3276 {
3277 continue;
3278 }
3279 }
3280 else
3281 {
3282 if (len > PW_MAX)
3283 {
3284 continue;
3285 }
3286 }
3287
3288 *out_buf = ptr;
3289 *out_len = len;
3290
3291 return;
3292 }
3293
3294 if (feof (fd))
3295 {
3296 fprintf (stderr, "bug!!\n");
3297
3298 return;
3299 }
3300
3301 load_segment (wl_data, fd);
3302
3303 get_next_word (wl_data, fd, out_buf, out_len);
3304 }
3305
3306 #ifdef _POSIX
3307 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3308 #endif
3309
3310 #ifdef _WIN
3311 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3312 #endif
3313 {
3314 hc_signal (NULL);
3315
3316 dictstat_t d;
3317
3318 d.cnt = 0;
3319
3320 #ifdef _POSIX
3321 fstat (fileno (fd), &d.stat);
3322 #endif
3323
3324 #ifdef _WIN
3325 _fstat64 (fileno (fd), &d.stat);
3326 #endif
3327
3328 d.stat.st_mode = 0;
3329 d.stat.st_nlink = 0;
3330 d.stat.st_uid = 0;
3331 d.stat.st_gid = 0;
3332 d.stat.st_rdev = 0;
3333 d.stat.st_atime = 0;
3334
3335 #ifdef _POSIX
3336 d.stat.st_blksize = 0;
3337 d.stat.st_blocks = 0;
3338 #endif
3339
3340 if (d.stat.st_size == 0) return 0;
3341
3342 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3343
3344 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3345 {
3346 if (d_cache)
3347 {
3348 u64 cnt = d_cache->cnt;
3349
3350 u64 keyspace = cnt;
3351
3352 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3353 {
3354 keyspace *= data.kernel_rules_cnt;
3355 }
3356 else if (data.attack_kern == ATTACK_KERN_COMBI)
3357 {
3358 keyspace *= data.combs_cnt;
3359 }
3360
3361 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);
3362 if (data.quiet == 0) log_info ("");
3363
3364 hc_signal (sigHandler_default);
3365
3366 return (keyspace);
3367 }
3368 }
3369
3370 time_t now = 0;
3371 time_t prev = 0;
3372
3373 u64 comp = 0;
3374 u64 cnt = 0;
3375 u64 cnt2 = 0;
3376
3377 while (!feof (fd))
3378 {
3379 load_segment (wl_data, fd);
3380
3381 comp += wl_data->cnt;
3382
3383 u32 i = 0;
3384
3385 while (i < wl_data->cnt)
3386 {
3387 u32 len;
3388 u32 off;
3389
3390 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3391
3392 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3393 {
3394 char rule_buf_out[BLOCK_SIZE] = { 0 };
3395
3396 int rule_len_out = -1;
3397
3398 if (len < BLOCK_SIZE)
3399 {
3400 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3401 }
3402
3403 if (rule_len_out < 0)
3404 {
3405 len = PW_MAX1;
3406 }
3407 else
3408 {
3409 len = rule_len_out;
3410 }
3411 }
3412
3413 if (len < PW_MAX1)
3414 {
3415 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3416 {
3417 cnt += data.kernel_rules_cnt;
3418 }
3419 else if (data.attack_kern == ATTACK_KERN_COMBI)
3420 {
3421 cnt += data.combs_cnt;
3422 }
3423
3424 d.cnt++;
3425 }
3426
3427 i += off;
3428
3429 cnt2++;
3430 }
3431
3432 time (&now);
3433
3434 if ((now - prev) == 0) continue;
3435
3436 float percent = (float) comp / (float) d.stat.st_size;
3437
3438 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);
3439
3440 time (&prev);
3441 }
3442
3443 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);
3444 if (data.quiet == 0) log_info ("");
3445
3446 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3447
3448 hc_signal (sigHandler_default);
3449
3450 return (cnt);
3451 }
3452
3453 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3454 {
3455 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3456 }
3457
3458 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3459 {
3460 if (data.devices_status == STATUS_BYPASS) return 0;
3461
3462 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3463
3464 uint cache_cnt = pw_cache->cnt;
3465
3466 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3467
3468 memcpy (pw_hc1, pw_buf, pw_len);
3469
3470 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3471
3472 uint pws_cnt = device_param->pws_cnt;
3473
3474 cache_cnt++;
3475
3476 pw_t *pw = device_param->pws_buf + pws_cnt;
3477
3478 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3479
3480 pw->pw_len = pw_len;
3481
3482 pws_cnt++;
3483
3484 device_param->pws_cnt = pws_cnt;
3485 device_param->pw_cnt = pws_cnt * 1;
3486
3487 cache_cnt = 0;
3488
3489 pw_cache->cnt = cache_cnt;
3490
3491 return pws_cnt;
3492 }
3493
3494 static void *thread_monitor (void *p)
3495 {
3496 uint runtime_check = 0;
3497 uint remove_check = 0;
3498 uint status_check = 0;
3499 uint restore_check = 0;
3500
3501 uint restore_left = data.restore_timer;
3502 uint remove_left = data.remove_timer;
3503 uint status_left = data.status_timer;
3504
3505 #ifdef HAVE_HWMON
3506 uint hwmon_check = 0;
3507
3508 // these variables are mainly used for fan control (AMD only)
3509
3510 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3511
3512 // temperature controller "loopback" values
3513
3514 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3515 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3516
3517 #ifdef HAVE_ADL
3518 int temp_threshold = 1; // degrees celcius
3519
3520 int fan_speed_min = 15; // in percentage
3521 int fan_speed_max = 100;
3522 #endif // HAVE_ADL
3523
3524 time_t last_temp_check_time;
3525 #endif // HAVE_HWMON
3526
3527 uint sleep_time = 1;
3528
3529 if (data.runtime)
3530 {
3531 runtime_check = 1;
3532 }
3533
3534 if (data.restore_timer)
3535 {
3536 restore_check = 1;
3537 }
3538
3539 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3540 {
3541 remove_check = 1;
3542 }
3543
3544 if (data.status == 1)
3545 {
3546 status_check = 1;
3547 }
3548
3549 #ifdef HAVE_HWMON
3550 if (data.gpu_temp_disable == 0)
3551 {
3552 time (&last_temp_check_time);
3553
3554 hwmon_check = 1;
3555 }
3556 #endif
3557
3558 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3559 {
3560 #ifdef HAVE_HWMON
3561 if (hwmon_check == 0)
3562 #endif
3563 return (p);
3564 }
3565
3566 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3567 {
3568 hc_sleep (sleep_time);
3569
3570 if (data.devices_status != STATUS_RUNNING) continue;
3571
3572 #ifdef HAVE_HWMON
3573 if (hwmon_check == 1)
3574 {
3575 hc_thread_mutex_lock (mux_adl);
3576
3577 time_t temp_check_time;
3578
3579 time (&temp_check_time);
3580
3581 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3582
3583 if (Ta == 0) Ta = 1;
3584
3585 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3586 {
3587 hc_device_param_t *device_param = &data.devices_param[device_id];
3588
3589 if (device_param->skipped) continue;
3590
3591 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3592
3593 const int temperature = hm_get_temperature_with_device_id (device_id);
3594
3595 if (temperature > (int) data.gpu_temp_abort)
3596 {
3597 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3598
3599 if (data.devices_status != STATUS_QUIT) myabort ();
3600
3601 break;
3602 }
3603
3604 #ifdef HAVE_ADL
3605 const int gpu_temp_retain = data.gpu_temp_retain;
3606
3607 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3608 {
3609 if (data.hm_device[device_id].fan_supported == 1)
3610 {
3611 int temp_cur = temperature;
3612
3613 int temp_diff_new = gpu_temp_retain - temp_cur;
3614
3615 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3616
3617 // calculate Ta value (time difference in seconds between the last check and this check)
3618
3619 last_temp_check_time = temp_check_time;
3620
3621 float Kp = 1.8;
3622 float Ki = 0.005;
3623 float Kd = 6;
3624
3625 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3626
3627 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);
3628
3629 if (abs (fan_diff_required) >= temp_threshold)
3630 {
3631 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3632
3633 int fan_speed_level = fan_speed_cur;
3634
3635 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3636
3637 int fan_speed_new = fan_speed_level - fan_diff_required;
3638
3639 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3640 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3641
3642 if (fan_speed_new != fan_speed_cur)
3643 {
3644 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3645 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3646
3647 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3648 {
3649 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3650
3651 fan_speed_chgd[device_id] = 1;
3652 }
3653
3654 temp_diff_old[device_id] = temp_diff_new;
3655 }
3656 }
3657 }
3658 }
3659 #endif // HAVE_ADL
3660 }
3661
3662 hc_thread_mutex_unlock (mux_adl);
3663 }
3664 #endif // HAVE_HWMON
3665
3666 if (restore_check == 1)
3667 {
3668 restore_left--;
3669
3670 if (restore_left == 0)
3671 {
3672 if (data.restore_disable == 0) cycle_restore ();
3673
3674 restore_left = data.restore_timer;
3675 }
3676 }
3677
3678 if ((runtime_check == 1) && (data.runtime_start > 0))
3679 {
3680 time_t runtime_cur;
3681
3682 time (&runtime_cur);
3683
3684 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3685
3686 if (runtime_left <= 0)
3687 {
3688 if (data.benchmark == 0)
3689 {
3690 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3691 }
3692
3693 if (data.devices_status != STATUS_QUIT) myabort ();
3694 }
3695 }
3696
3697 if (remove_check == 1)
3698 {
3699 remove_left--;
3700
3701 if (remove_left == 0)
3702 {
3703 if (data.digests_saved != data.digests_done)
3704 {
3705 data.digests_saved = data.digests_done;
3706
3707 save_hash ();
3708 }
3709
3710 remove_left = data.remove_timer;
3711 }
3712 }
3713
3714 if (status_check == 1)
3715 {
3716 status_left--;
3717
3718 if (status_left == 0)
3719 {
3720 hc_thread_mutex_lock (mux_display);
3721
3722 if (data.quiet == 0) clear_prompt ();
3723
3724 if (data.quiet == 0) log_info ("");
3725
3726 status_display ();
3727
3728 if (data.quiet == 0) log_info ("");
3729
3730 hc_thread_mutex_unlock (mux_display);
3731
3732 status_left = data.status_timer;
3733 }
3734 }
3735 }
3736
3737 #ifdef HAVE_HWMON
3738 myfree (fan_speed_chgd);
3739
3740 myfree (temp_diff_old);
3741 myfree (temp_diff_sum);
3742 #endif
3743
3744 p = NULL;
3745
3746 return (p);
3747 }
3748
3749 static void *thread_outfile_remove (void *p)
3750 {
3751 // some hash-dependent constants
3752 char *outfile_dir = data.outfile_check_directory;
3753 uint dgst_size = data.dgst_size;
3754 uint isSalted = data.isSalted;
3755 uint esalt_size = data.esalt_size;
3756 uint hash_mode = data.hash_mode;
3757
3758 uint outfile_check_timer = data.outfile_check_timer;
3759
3760 char separator = data.separator;
3761
3762 // some hash-dependent functions
3763 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3764 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3765
3766 // buffers
3767 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3768
3769 hash_buf.digest = mymalloc (dgst_size);
3770
3771 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3772
3773 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3774
3775 uint digest_buf[64] = { 0 };
3776
3777 outfile_data_t *out_info = NULL;
3778
3779 char **out_files = NULL;
3780
3781 time_t folder_mtime = 0;
3782
3783 int out_cnt = 0;
3784
3785 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3786
3787 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3788 {
3789 hc_sleep (1);
3790
3791 if (data.devices_status != STATUS_RUNNING) continue;
3792
3793 check_left--;
3794
3795 if (check_left == 0)
3796 {
3797 struct stat outfile_check_stat;
3798
3799 if (stat (outfile_dir, &outfile_check_stat) == 0)
3800 {
3801 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3802
3803 if (is_dir == 1)
3804 {
3805 if (outfile_check_stat.st_mtime > folder_mtime)
3806 {
3807 char **out_files_new = scan_directory (outfile_dir);
3808
3809 int out_cnt_new = count_dictionaries (out_files_new);
3810
3811 outfile_data_t *out_info_new = NULL;
3812
3813 if (out_cnt_new > 0)
3814 {
3815 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3816
3817 for (int i = 0; i < out_cnt_new; i++)
3818 {
3819 out_info_new[i].file_name = out_files_new[i];
3820
3821 // check if there are files that we have seen/checked before (and not changed)
3822
3823 for (int j = 0; j < out_cnt; j++)
3824 {
3825 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3826 {
3827 struct stat outfile_stat;
3828
3829 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3830 {
3831 if (outfile_stat.st_ctime == out_info[j].ctime)
3832 {
3833 out_info_new[i].ctime = out_info[j].ctime;
3834 out_info_new[i].seek = out_info[j].seek;
3835 }
3836 }
3837 }
3838 }
3839 }
3840 }
3841
3842 local_free (out_info);
3843 local_free (out_files);
3844
3845 out_files = out_files_new;
3846 out_cnt = out_cnt_new;
3847 out_info = out_info_new;
3848
3849 folder_mtime = outfile_check_stat.st_mtime;
3850 }
3851
3852 for (int j = 0; j < out_cnt; j++)
3853 {
3854 FILE *fp = fopen (out_info[j].file_name, "rb");
3855
3856 if (fp != NULL)
3857 {
3858 //hc_thread_mutex_lock (mux_display);
3859
3860 #ifdef _POSIX
3861 struct stat outfile_stat;
3862
3863 fstat (fileno (fp), &outfile_stat);
3864 #endif
3865
3866 #ifdef _WIN
3867 struct stat64 outfile_stat;
3868
3869 _fstat64 (fileno (fp), &outfile_stat);
3870 #endif
3871
3872 if (outfile_stat.st_ctime > out_info[j].ctime)
3873 {
3874 out_info[j].ctime = outfile_stat.st_ctime;
3875 out_info[j].seek = 0;
3876 }
3877
3878 fseek (fp, out_info[j].seek, SEEK_SET);
3879
3880 while (!feof (fp))
3881 {
3882 char line_buf[BUFSIZ] = { 0 };
3883
3884 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3885
3886 if (ptr == NULL) break;
3887
3888 int line_len = strlen (line_buf);
3889
3890 if (line_len <= 0) continue;
3891
3892 int iter = MAX_CUT_TRIES;
3893
3894 for (uint i = line_len - 1; i && iter; i--, line_len--)
3895 {
3896 if (line_buf[i] != separator) continue;
3897
3898 int parser_status = PARSER_OK;
3899
3900 if ((hash_mode != 2500) && (hash_mode != 6800))
3901 {
3902 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3903 }
3904
3905 uint found = 0;
3906
3907 if (parser_status == PARSER_OK)
3908 {
3909 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3910 {
3911 if (data.salts_shown[salt_pos] == 1) continue;
3912
3913 salt_t *salt_buf = &data.salts_buf[salt_pos];
3914
3915 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3916 {
3917 uint idx = salt_buf->digests_offset + digest_pos;
3918
3919 if (data.digests_shown[idx] == 1) continue;
3920
3921 uint cracked = 0;
3922
3923 if (hash_mode == 6800)
3924 {
3925 if (i == salt_buf->salt_len)
3926 {
3927 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3928 }
3929 }
3930 else if (hash_mode == 2500)
3931 {
3932 // BSSID : MAC1 : MAC2 (:plain)
3933 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3934 {
3935 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3936
3937 if (!cracked) continue;
3938
3939 // now compare MAC1 and MAC2 too, since we have this additional info
3940 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3941 char *mac2_pos = mac1_pos + 12 + 1;
3942
3943 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3944 wpa_t *wpa = &wpas[salt_pos];
3945
3946 uint pke[25] = { 0 };
3947
3948 char *pke_ptr = (char *) pke;
3949
3950 for (uint i = 0; i < 25; i++)
3951 {
3952 pke[i] = byte_swap_32 (wpa->pke[i]);
3953 }
3954
3955 u8 mac1[6] = { 0 };
3956 u8 mac2[6] = { 0 };
3957
3958 memcpy (mac1, pke_ptr + 23, 6);
3959 memcpy (mac2, pke_ptr + 29, 6);
3960
3961 // compare hex string(s) vs binary MAC address(es)
3962
3963 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3964 {
3965 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3966 {
3967 cracked = 0;
3968 break;
3969 }
3970 }
3971
3972 // early skip ;)
3973 if (!cracked) continue;
3974
3975 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3976 {
3977 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3978 {
3979 cracked = 0;
3980 break;
3981 }
3982 }
3983 }
3984 }
3985 else
3986 {
3987 char *digests_buf_ptr = (char *) data.digests_buf;
3988
3989 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3990
3991 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3992 }
3993
3994 if (cracked == 1)
3995 {
3996 found = 1;
3997
3998 data.digests_shown[idx] = 1;
3999
4000 data.digests_done++;
4001
4002 salt_buf->digests_done++;
4003
4004 if (salt_buf->digests_done == salt_buf->digests_cnt)
4005 {
4006 data.salts_shown[salt_pos] = 1;
4007
4008 data.salts_done++;
4009
4010 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4011 }
4012 }
4013 }
4014
4015 if (data.devices_status == STATUS_CRACKED) break;
4016 }
4017 }
4018
4019 if (found) break;
4020
4021 if (data.devices_status == STATUS_CRACKED) break;
4022
4023 iter--;
4024 }
4025
4026 if (data.devices_status == STATUS_CRACKED) break;
4027 }
4028
4029 out_info[j].seek = ftell (fp);
4030
4031 //hc_thread_mutex_unlock (mux_display);
4032
4033 fclose (fp);
4034 }
4035 }
4036 }
4037 }
4038
4039 check_left = outfile_check_timer;
4040 }
4041 }
4042
4043 if (esalt_size) local_free (hash_buf.esalt);
4044
4045 if (isSalted) local_free (hash_buf.salt);
4046
4047 local_free (hash_buf.digest);
4048
4049 local_free (out_info);
4050
4051 local_free (out_files);
4052
4053 p = NULL;
4054
4055 return (p);
4056 }
4057
4058 static uint get_work (hc_device_param_t *device_param, const u64 max)
4059 {
4060 hc_thread_mutex_lock (mux_dispatcher);
4061
4062 const u64 words_cur = data.words_cur;
4063 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4064
4065 device_param->words_off = words_cur;
4066
4067 const u64 words_left = words_base - words_cur;
4068
4069 if (data.kernel_blocks_all > words_left)
4070 {
4071 if (data.kernel_blocks_div == 0)
4072 {
4073 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4074 }
4075 }
4076
4077 if (data.kernel_blocks_div)
4078 {
4079 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4080 {
4081 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4082 const u32 kernel_power_new = kernel_blocks_new;
4083
4084 if (kernel_blocks_new < device_param->kernel_blocks)
4085 {
4086 device_param->kernel_blocks = kernel_blocks_new;
4087 device_param->kernel_power = kernel_power_new;
4088 }
4089 }
4090 }
4091
4092 const uint kernel_blocks = device_param->kernel_blocks;
4093
4094 uint work = MIN (words_left, kernel_blocks);
4095
4096 work = MIN (work, max);
4097
4098 data.words_cur += work;
4099
4100 hc_thread_mutex_unlock (mux_dispatcher);
4101
4102 return work;
4103 }
4104
4105 static void *thread_calc_stdin (void *p)
4106 {
4107 hc_device_param_t *device_param = (hc_device_param_t *) p;
4108
4109 if (device_param->skipped) return NULL;
4110
4111 const uint attack_kern = data.attack_kern;
4112
4113 const uint kernel_blocks = device_param->kernel_blocks;
4114
4115 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4116 {
4117 hc_thread_mutex_lock (mux_dispatcher);
4118
4119 if (feof (stdin) != 0)
4120 {
4121 hc_thread_mutex_unlock (mux_dispatcher);
4122
4123 break;
4124 }
4125
4126 uint words_cur = 0;
4127
4128 while (words_cur < kernel_blocks)
4129 {
4130 char buf[BUFSIZ] = { 0 };
4131
4132 char *line_buf = fgets (buf, sizeof (buf), stdin);
4133
4134 if (line_buf == NULL) break;
4135
4136 uint line_len = in_superchop (line_buf);
4137
4138 line_len = convert_from_hex (line_buf, line_len);
4139
4140 // post-process rule engine
4141
4142 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4143 {
4144 char rule_buf_out[BLOCK_SIZE] = { 0 };
4145
4146 int rule_len_out = -1;
4147
4148 if (line_len < BLOCK_SIZE)
4149 {
4150 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4151 }
4152
4153 if (rule_len_out < 0) continue;
4154
4155 line_buf = rule_buf_out;
4156 line_len = rule_len_out;
4157 }
4158
4159 if (line_len > PW_MAX)
4160 {
4161 continue;
4162 }
4163
4164 if (attack_kern == ATTACK_KERN_STRAIGHT)
4165 {
4166 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4167 {
4168 hc_thread_mutex_lock (mux_counter);
4169
4170 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4171 {
4172 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4173 }
4174
4175 hc_thread_mutex_unlock (mux_counter);
4176
4177 continue;
4178 }
4179 }
4180 else if (attack_kern == ATTACK_KERN_COMBI)
4181 {
4182 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4183 // since we still need to combine the plains
4184
4185 if (line_len > data.pw_max)
4186 {
4187 hc_thread_mutex_lock (mux_counter);
4188
4189 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4190 {
4191 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4192 }
4193
4194 hc_thread_mutex_unlock (mux_counter);
4195
4196 continue;
4197 }
4198 }
4199
4200 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4201
4202 words_cur++;
4203
4204 if (data.devices_status == STATUS_CRACKED) break;
4205 if (data.devices_status == STATUS_ABORTED) break;
4206 if (data.devices_status == STATUS_QUIT) break;
4207 if (data.devices_status == STATUS_BYPASS) break;
4208 }
4209
4210 hc_thread_mutex_unlock (mux_dispatcher);
4211
4212 if (data.devices_status == STATUS_CRACKED) break;
4213 if (data.devices_status == STATUS_ABORTED) break;
4214 if (data.devices_status == STATUS_QUIT) break;
4215 if (data.devices_status == STATUS_BYPASS) break;
4216
4217 // we need 2 flushing because we have two independant caches and it can occur
4218 // that one buffer is already at threshold plus for that length also exists
4219 // more data in the 2nd buffer so it would overflow
4220
4221 // flush session 1
4222
4223 {
4224 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4225 {
4226 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4227
4228 const uint pw_cache_cnt = pw_cache->cnt;
4229
4230 if (pw_cache_cnt == 0) continue;
4231
4232 pw_cache->cnt = 0;
4233
4234 uint pws_cnt = device_param->pws_cnt;
4235
4236 pw_t *pw = device_param->pws_buf + pws_cnt;
4237
4238 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4239
4240 pw->pw_len = pw_len;
4241
4242 uint pw_cnt = device_param->pw_cnt;
4243
4244 pw_cnt += pw_cache_cnt;
4245
4246 device_param->pw_cnt = pw_cnt;
4247
4248 pws_cnt++;
4249
4250 device_param->pws_cnt = pws_cnt;
4251
4252 if (pws_cnt == device_param->kernel_power_user) break;
4253 }
4254
4255 const uint pw_cnt = device_param->pw_cnt;
4256 const uint pws_cnt = device_param->pws_cnt;
4257
4258 if (pws_cnt)
4259 {
4260 run_copy (device_param, pws_cnt);
4261
4262 run_cracker (device_param, pw_cnt, pws_cnt);
4263
4264 device_param->pw_cnt = 0;
4265 device_param->pws_cnt = 0;
4266 }
4267 }
4268
4269 // flush session 2
4270
4271 {
4272 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4273 {
4274 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4275
4276 const uint pw_cache_cnt = pw_cache->cnt;
4277
4278 if (pw_cache_cnt == 0) continue;
4279
4280 pw_cache->cnt = 0;
4281
4282 uint pws_cnt = device_param->pws_cnt;
4283
4284 pw_t *pw = device_param->pws_buf + pws_cnt;
4285
4286 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4287
4288 pw->pw_len = pw_len;
4289
4290 uint pw_cnt = device_param->pw_cnt;
4291
4292 pw_cnt += pw_cache_cnt;
4293
4294 device_param->pw_cnt = pw_cnt;
4295
4296 pws_cnt++;
4297
4298 device_param->pws_cnt = pws_cnt;
4299 }
4300
4301 const uint pw_cnt = device_param->pw_cnt;
4302 const uint pws_cnt = device_param->pws_cnt;
4303
4304 if (pws_cnt)
4305 {
4306 run_copy (device_param, pws_cnt);
4307
4308 run_cracker (device_param, pw_cnt, pws_cnt);
4309
4310 device_param->pw_cnt = 0;
4311 device_param->pws_cnt = 0;
4312 }
4313 }
4314 }
4315
4316 return NULL;
4317 }
4318
4319 static void *thread_calc (void *p)
4320 {
4321 hc_device_param_t *device_param = (hc_device_param_t *) p;
4322
4323 if (device_param->skipped) return NULL;
4324
4325 const uint attack_mode = data.attack_mode;
4326 const uint attack_kern = data.attack_kern;
4327
4328 if (attack_mode == ATTACK_MODE_BF)
4329 {
4330 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4331 {
4332 const uint work = get_work (device_param, -1);
4333
4334 if (work == 0) break;
4335
4336 const u64 words_off = device_param->words_off;
4337 const u64 words_fin = words_off + work;
4338
4339 const uint pw_cnt = work;
4340 const uint pws_cnt = work;
4341
4342 device_param->pw_cnt = pw_cnt;
4343 device_param->pws_cnt = pws_cnt;
4344
4345 if (pws_cnt)
4346 {
4347 run_copy (device_param, pws_cnt);
4348
4349 run_cracker (device_param, pw_cnt, pws_cnt);
4350
4351 device_param->pw_cnt = 0;
4352 device_param->pws_cnt = 0;
4353 }
4354
4355 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4356
4357 if (data.devices_status == STATUS_CRACKED) break;
4358 if (data.devices_status == STATUS_ABORTED) break;
4359 if (data.devices_status == STATUS_QUIT) break;
4360 if (data.devices_status == STATUS_BYPASS) break;
4361
4362 device_param->words_done = words_fin;
4363 }
4364 }
4365 else
4366 {
4367 const uint segment_size = data.segment_size;
4368
4369 char *dictfile = data.dictfile;
4370
4371 if (attack_mode == ATTACK_MODE_COMBI)
4372 {
4373 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4374 {
4375 dictfile = data.dictfile2;
4376 }
4377 }
4378
4379 FILE *fd = fopen (dictfile, "rb");
4380
4381 if (fd == NULL)
4382 {
4383 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4384
4385 return NULL;
4386 }
4387
4388 if (attack_mode == ATTACK_MODE_COMBI)
4389 {
4390 const uint combs_mode = data.combs_mode;
4391
4392 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4393 {
4394 const char *dictfilec = data.dictfile2;
4395
4396 FILE *combs_fp = fopen (dictfilec, "rb");
4397
4398 if (combs_fp == NULL)
4399 {
4400 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4401
4402 fclose (fd);
4403
4404 return NULL;
4405 }
4406
4407 device_param->combs_fp = combs_fp;
4408 }
4409 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4410 {
4411 const char *dictfilec = data.dictfile;
4412
4413 FILE *combs_fp = fopen (dictfilec, "rb");
4414
4415 if (combs_fp == NULL)
4416 {
4417 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4418
4419 fclose (fd);
4420
4421 return NULL;
4422 }
4423
4424 device_param->combs_fp = combs_fp;
4425 }
4426 }
4427
4428 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4429
4430 wl_data->buf = (char *) mymalloc (segment_size);
4431 wl_data->avail = segment_size;
4432 wl_data->incr = segment_size;
4433 wl_data->cnt = 0;
4434 wl_data->pos = 0;
4435
4436 u64 words_cur = 0;
4437
4438 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4439 {
4440 u64 words_off = 0;
4441 u64 words_fin = 0;
4442
4443 u64 max = -1;
4444
4445 while (max)
4446 {
4447 const uint work = get_work (device_param, max);
4448
4449 if (work == 0) break;
4450
4451 words_off = device_param->words_off;
4452 words_fin = words_off + work;
4453
4454 char *line_buf;
4455 uint line_len;
4456
4457 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4458
4459 max = 0;
4460
4461 for ( ; words_cur < words_fin; words_cur++)
4462 {
4463 get_next_word (wl_data, fd, &line_buf, &line_len);
4464
4465 line_len = convert_from_hex (line_buf, line_len);
4466
4467 // post-process rule engine
4468
4469 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4470 {
4471 char rule_buf_out[BLOCK_SIZE] = { 0 };
4472
4473 int rule_len_out = -1;
4474
4475 if (line_len < BLOCK_SIZE)
4476 {
4477 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4478 }
4479
4480 if (rule_len_out < 0) continue;
4481
4482 line_buf = rule_buf_out;
4483 line_len = rule_len_out;
4484 }
4485
4486 if (attack_kern == ATTACK_KERN_STRAIGHT)
4487 {
4488 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4489 {
4490 max++;
4491
4492 hc_thread_mutex_lock (mux_counter);
4493
4494 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4495 {
4496 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4497 }
4498
4499 hc_thread_mutex_unlock (mux_counter);
4500
4501 continue;
4502 }
4503 }
4504 else if (attack_kern == ATTACK_KERN_COMBI)
4505 {
4506 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4507 // since we still need to combine the plains
4508
4509 if (line_len > data.pw_max)
4510 {
4511 max++;
4512
4513 hc_thread_mutex_lock (mux_counter);
4514
4515 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4516 {
4517 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4518 }
4519
4520 hc_thread_mutex_unlock (mux_counter);
4521
4522 continue;
4523 }
4524 }
4525
4526 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4527
4528 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4529
4530 if (data.devices_status == STATUS_CRACKED) break;
4531 if (data.devices_status == STATUS_ABORTED) break;
4532 if (data.devices_status == STATUS_QUIT) break;
4533 if (data.devices_status == STATUS_BYPASS) break;
4534 }
4535
4536 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4537
4538 if (data.devices_status == STATUS_CRACKED) break;
4539 if (data.devices_status == STATUS_ABORTED) break;
4540 if (data.devices_status == STATUS_QUIT) break;
4541 if (data.devices_status == STATUS_BYPASS) break;
4542 }
4543
4544 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4545
4546 if (data.devices_status == STATUS_CRACKED) break;
4547 if (data.devices_status == STATUS_ABORTED) break;
4548 if (data.devices_status == STATUS_QUIT) break;
4549 if (data.devices_status == STATUS_BYPASS) break;
4550
4551 // we need 2 flushing because we have two independant caches and it can occur
4552 // that one buffer is already at threshold plus for that length also exists
4553 // more data in the 2nd buffer so it would overflow
4554
4555 //
4556 // flush session 1
4557 //
4558
4559 {
4560 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4561 {
4562 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4563
4564 const uint pw_cache_cnt = pw_cache->cnt;
4565
4566 if (pw_cache_cnt == 0) continue;
4567
4568 pw_cache->cnt = 0;
4569
4570 uint pws_cnt = device_param->pws_cnt;
4571
4572 pw_t *pw = device_param->pws_buf + pws_cnt;
4573
4574 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4575
4576 pw->pw_len = pw_len;
4577
4578 uint pw_cnt = device_param->pw_cnt;
4579
4580 pw_cnt += pw_cache_cnt;
4581
4582 device_param->pw_cnt = pw_cnt;
4583
4584 pws_cnt++;
4585
4586 device_param->pws_cnt = pws_cnt;
4587
4588 if (pws_cnt == device_param->kernel_power_user) break;
4589 }
4590
4591 const uint pw_cnt = device_param->pw_cnt;
4592 const uint pws_cnt = device_param->pws_cnt;
4593
4594 if (pws_cnt)
4595 {
4596 run_copy (device_param, pws_cnt);
4597
4598 run_cracker (device_param, pw_cnt, pws_cnt);
4599
4600 device_param->pw_cnt = 0;
4601 device_param->pws_cnt = 0;
4602 }
4603
4604 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4605
4606 if (data.devices_status == STATUS_CRACKED) break;
4607 if (data.devices_status == STATUS_ABORTED) break;
4608 if (data.devices_status == STATUS_QUIT) break;
4609 if (data.devices_status == STATUS_BYPASS) break;
4610 }
4611
4612 //
4613 // flush session 2
4614 //
4615
4616 {
4617 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4618 {
4619 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4620
4621 const uint pw_cache_cnt = pw_cache->cnt;
4622
4623 if (pw_cache_cnt == 0) continue;
4624
4625 pw_cache->cnt = 0;
4626
4627 uint pws_cnt = device_param->pws_cnt;
4628
4629 pw_t *pw = device_param->pws_buf + pws_cnt;
4630
4631 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4632
4633 pw->pw_len = pw_len;
4634
4635 uint pw_cnt = device_param->pw_cnt;
4636
4637 pw_cnt += pw_cache_cnt;
4638
4639 device_param->pw_cnt = pw_cnt;
4640
4641 pws_cnt++;
4642
4643 device_param->pws_cnt = pws_cnt;
4644 }
4645
4646 const uint pw_cnt = device_param->pw_cnt;
4647 const uint pws_cnt = device_param->pws_cnt;
4648
4649 if (pws_cnt)
4650 {
4651 run_copy (device_param, pws_cnt);
4652
4653 run_cracker (device_param, pw_cnt, pws_cnt);
4654
4655 device_param->pw_cnt = 0;
4656 device_param->pws_cnt = 0;
4657 }
4658
4659 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4660
4661 if (data.devices_status == STATUS_CRACKED) break;
4662 if (data.devices_status == STATUS_ABORTED) break;
4663 if (data.devices_status == STATUS_QUIT) break;
4664 if (data.devices_status == STATUS_BYPASS) break;
4665 }
4666
4667 if (words_fin == 0) break;
4668
4669 device_param->words_done = words_fin;
4670 }
4671
4672 if (attack_mode == ATTACK_MODE_COMBI)
4673 {
4674 fclose (device_param->combs_fp);
4675 }
4676
4677 free (wl_data->buf);
4678 free (wl_data);
4679
4680 fclose (fd);
4681 }
4682
4683 return NULL;
4684 }
4685
4686 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4687 {
4688 if (!device_param)
4689 {
4690 log_error ("ERROR: %s : Invalid argument", __func__);
4691
4692 exit (-1);
4693 }
4694
4695 const uint kernel_loops = device_param->kernel_loops;
4696
4697 salt_t *salt_buf = &data.salts_buf[salt_pos];
4698
4699 device_param->kernel_params_buf32[24] = salt_pos;
4700 device_param->kernel_params_buf32[27] = 1;
4701 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4702 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4703 device_param->kernel_params_buf32[30] = 0;
4704 device_param->kernel_params_buf32[31] = 1;
4705
4706 char *dictfile_old = data.dictfile;
4707
4708 const char *weak_hash_check = "weak-hash-check";
4709
4710 data.dictfile = (char *) weak_hash_check;
4711
4712 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4713
4714 data.kernel_rules_buf[0].cmds[0] = 0;
4715
4716 /**
4717 * run the kernel
4718 */
4719
4720 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4721 {
4722 run_kernel (KERN_RUN_1, device_param, 1, false);
4723 }
4724 else
4725 {
4726 run_kernel (KERN_RUN_1, device_param, 1, false);
4727
4728 const uint iter = salt_buf->salt_iter;
4729
4730 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4731 {
4732 uint loop_left = iter - loop_pos;
4733
4734 loop_left = MIN (loop_left, kernel_loops);
4735
4736 device_param->kernel_params_buf32[25] = loop_pos;
4737 device_param->kernel_params_buf32[26] = loop_left;
4738
4739 run_kernel (KERN_RUN_2, device_param, 1, false);
4740 }
4741
4742 run_kernel (KERN_RUN_3, device_param, 1, false);
4743 }
4744
4745 /**
4746 * result
4747 */
4748
4749 check_cracked (device_param, salt_pos);
4750
4751 /**
4752 * cleanup
4753 */
4754
4755 device_param->kernel_params_buf32[24] = 0;
4756 device_param->kernel_params_buf32[25] = 0;
4757 device_param->kernel_params_buf32[26] = 0;
4758 device_param->kernel_params_buf32[27] = 0;
4759 device_param->kernel_params_buf32[28] = 0;
4760 device_param->kernel_params_buf32[29] = 0;
4761 device_param->kernel_params_buf32[30] = 0;
4762 device_param->kernel_params_buf32[31] = 0;
4763
4764 data.dictfile = dictfile_old;
4765
4766 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4767 }
4768
4769 // hlfmt hashcat
4770
4771 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4772 {
4773 if (data.username == 0)
4774 {
4775 *hashbuf_pos = line_buf;
4776 *hashbuf_len = line_len;
4777 }
4778 else
4779 {
4780 char *pos = line_buf;
4781 int len = line_len;
4782
4783 for (int i = 0; i < line_len; i++, pos++, len--)
4784 {
4785 if (line_buf[i] == data.separator)
4786 {
4787 pos++;
4788
4789 len--;
4790
4791 break;
4792 }
4793 }
4794
4795 *hashbuf_pos = pos;
4796 *hashbuf_len = len;
4797 }
4798 }
4799
4800 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4801 {
4802 char *pos = NULL;
4803 int len = 0;
4804
4805 int sep_cnt = 0;
4806
4807 for (int i = 0; i < line_len; i++)
4808 {
4809 if (line_buf[i] == data.separator)
4810 {
4811 sep_cnt++;
4812
4813 continue;
4814 }
4815
4816 if (sep_cnt == 0)
4817 {
4818 if (pos == NULL) pos = line_buf + i;
4819
4820 len++;
4821 }
4822 }
4823
4824 *userbuf_pos = pos;
4825 *userbuf_len = len;
4826 }
4827
4828 // hlfmt pwdump
4829
4830 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4831 {
4832 int sep_cnt = 0;
4833
4834 int sep2_len = 0;
4835 int sep3_len = 0;
4836
4837 for (int i = 0; i < line_len; i++)
4838 {
4839 if (line_buf[i] == ':')
4840 {
4841 sep_cnt++;
4842
4843 continue;
4844 }
4845
4846 if (sep_cnt == 2) sep2_len++;
4847 if (sep_cnt == 3) sep3_len++;
4848 }
4849
4850 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4851
4852 return 0;
4853 }
4854
4855 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4856 {
4857 char *pos = NULL;
4858 int len = 0;
4859
4860 int sep_cnt = 0;
4861
4862 for (int i = 0; i < line_len; i++)
4863 {
4864 if (line_buf[i] == ':')
4865 {
4866 sep_cnt++;
4867
4868 continue;
4869 }
4870
4871 if (data.hash_mode == 1000)
4872 {
4873 if (sep_cnt == 3)
4874 {
4875 if (pos == NULL) pos = line_buf + i;
4876
4877 len++;
4878 }
4879 }
4880 else if (data.hash_mode == 3000)
4881 {
4882 if (sep_cnt == 2)
4883 {
4884 if (pos == NULL) pos = line_buf + i;
4885
4886 len++;
4887 }
4888 }
4889 }
4890
4891 *hashbuf_pos = pos;
4892 *hashbuf_len = len;
4893 }
4894
4895 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4896 {
4897 char *pos = NULL;
4898 int len = 0;
4899
4900 int sep_cnt = 0;
4901
4902 for (int i = 0; i < line_len; i++)
4903 {
4904 if (line_buf[i] == ':')
4905 {
4906 sep_cnt++;
4907
4908 continue;
4909 }
4910
4911 if (sep_cnt == 0)
4912 {
4913 if (pos == NULL) pos = line_buf + i;
4914
4915 len++;
4916 }
4917 }
4918
4919 *userbuf_pos = pos;
4920 *userbuf_len = len;
4921 }
4922
4923 // hlfmt passwd
4924
4925 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4926 {
4927 int sep_cnt = 0;
4928
4929 char sep5_first = 0;
4930 char sep6_first = 0;
4931
4932 for (int i = 0; i < line_len; i++)
4933 {
4934 if (line_buf[i] == ':')
4935 {
4936 sep_cnt++;
4937
4938 continue;
4939 }
4940
4941 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4942 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4943 }
4944
4945 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4946
4947 return 0;
4948 }
4949
4950 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4951 {
4952 char *pos = NULL;
4953 int len = 0;
4954
4955 int sep_cnt = 0;
4956
4957 for (int i = 0; i < line_len; i++)
4958 {
4959 if (line_buf[i] == ':')
4960 {
4961 sep_cnt++;
4962
4963 continue;
4964 }
4965
4966 if (sep_cnt == 1)
4967 {
4968 if (pos == NULL) pos = line_buf + i;
4969
4970 len++;
4971 }
4972 }
4973
4974 *hashbuf_pos = pos;
4975 *hashbuf_len = len;
4976 }
4977
4978 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4979 {
4980 char *pos = NULL;
4981 int len = 0;
4982
4983 int sep_cnt = 0;
4984
4985 for (int i = 0; i < line_len; i++)
4986 {
4987 if (line_buf[i] == ':')
4988 {
4989 sep_cnt++;
4990
4991 continue;
4992 }
4993
4994 if (sep_cnt == 0)
4995 {
4996 if (pos == NULL) pos = line_buf + i;
4997
4998 len++;
4999 }
5000 }
5001
5002 *userbuf_pos = pos;
5003 *userbuf_len = len;
5004 }
5005
5006 // hlfmt shadow
5007
5008 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5009 {
5010 int sep_cnt = 0;
5011
5012 for (int i = 0; i < line_len; i++)
5013 {
5014 if (line_buf[i] == ':') sep_cnt++;
5015 }
5016
5017 if (sep_cnt == 8) return 1;
5018
5019 return 0;
5020 }
5021
5022 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5023 {
5024 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5025 }
5026
5027 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5028 {
5029 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5030 }
5031
5032 // hlfmt main
5033
5034 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5035 {
5036 switch (hashfile_format)
5037 {
5038 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5039 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5040 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5041 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5042 }
5043 }
5044
5045 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5046 {
5047 switch (hashfile_format)
5048 {
5049 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5050 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5051 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5052 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5053 }
5054 }
5055
5056 static uint hlfmt_detect (FILE *fp, uint max_check)
5057 {
5058 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5059
5060 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5061 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5062
5063 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5064
5065 uint num_check = 0;
5066
5067 while (!feof (fp))
5068 {
5069 char line_buf[BUFSIZ] = { 0 };
5070
5071 int line_len = fgetl (fp, line_buf);
5072
5073 if (line_len == 0) continue;
5074
5075 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5076 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5077 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5078
5079 if (num_check == max_check) break;
5080
5081 num_check++;
5082 }
5083
5084 uint hashlist_format = HLFMT_HASHCAT;
5085
5086 for (int i = 1; i < HLFMTS_CNT; i++)
5087 {
5088 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5089
5090 hashlist_format = i;
5091 }
5092
5093 free (formats_cnt);
5094
5095 return hashlist_format;
5096 }
5097
5098 /**
5099 * some further helper function
5100 */
5101
5102 // wrapper around mymalloc for ADL
5103
5104 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5105 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5106 {
5107 return mymalloc (iSize);
5108 }
5109 #endif
5110
5111 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)
5112 {
5113 u64 collisions = 0;
5114
5115 const uint dgst_pos0 = data.dgst_pos0;
5116 const uint dgst_pos1 = data.dgst_pos1;
5117 const uint dgst_pos2 = data.dgst_pos2;
5118 const uint dgst_pos3 = data.dgst_pos3;
5119
5120 memset (bitmap_a, 0, bitmap_size);
5121 memset (bitmap_b, 0, bitmap_size);
5122 memset (bitmap_c, 0, bitmap_size);
5123 memset (bitmap_d, 0, bitmap_size);
5124
5125 for (uint i = 0; i < digests_cnt; i++)
5126 {
5127 uint *digest_ptr = (uint *) digests_buf_ptr;
5128
5129 digests_buf_ptr += dgst_size;
5130
5131 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5132 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5133 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5134 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5135
5136 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5137 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5138 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5139 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5140
5141 if (bitmap_a[idx0] & val0) collisions++;
5142 if (bitmap_b[idx1] & val1) collisions++;
5143 if (bitmap_c[idx2] & val2) collisions++;
5144 if (bitmap_d[idx3] & val3) collisions++;
5145
5146 bitmap_a[idx0] |= val0;
5147 bitmap_b[idx1] |= val1;
5148 bitmap_c[idx2] |= val2;
5149 bitmap_d[idx3] |= val3;
5150
5151 if (collisions >= collisions_max) return 0x7fffffff;
5152 }
5153
5154 return collisions;
5155 }
5156
5157 /**
5158 * main
5159 */
5160
5161 int main (int argc, char **argv)
5162 {
5163 /**
5164 * To help users a bit
5165 */
5166
5167 char *compute = getenv ("COMPUTE");
5168
5169 if (compute)
5170 {
5171 static char display[100];
5172
5173 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5174
5175 putenv (display);
5176 }
5177 else
5178 {
5179 if (getenv ("DISPLAY") == NULL)
5180 putenv ((char *) "DISPLAY=:0");
5181 }
5182
5183 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5184 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5185
5186 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5187 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5188
5189 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5190 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5191
5192 /**
5193 * Real init
5194 */
5195
5196 memset (&data, 0, sizeof (hc_global_data_t));
5197
5198 time_t proc_start;
5199
5200 time (&proc_start);
5201
5202 data.proc_start = proc_start;
5203
5204 int myargc = argc;
5205 char **myargv = argv;
5206
5207 hc_thread_mutex_init (mux_dispatcher);
5208 hc_thread_mutex_init (mux_counter);
5209 hc_thread_mutex_init (mux_display);
5210 hc_thread_mutex_init (mux_adl);
5211
5212 /**
5213 * commandline parameters
5214 */
5215
5216 uint usage = USAGE;
5217 uint version = VERSION;
5218 uint quiet = QUIET;
5219 uint benchmark = BENCHMARK;
5220 uint benchmark_mode = BENCHMARK_MODE;
5221 uint show = SHOW;
5222 uint left = LEFT;
5223 uint username = USERNAME;
5224 uint remove = REMOVE;
5225 uint remove_timer = REMOVE_TIMER;
5226 u64 skip = SKIP;
5227 u64 limit = LIMIT;
5228 uint keyspace = KEYSPACE;
5229 uint potfile_disable = POTFILE_DISABLE;
5230 uint debug_mode = DEBUG_MODE;
5231 char *debug_file = NULL;
5232 char *induction_dir = NULL;
5233 char *outfile_check_dir = NULL;
5234 uint force = FORCE;
5235 uint runtime = RUNTIME;
5236 uint hash_mode = HASH_MODE;
5237 uint attack_mode = ATTACK_MODE;
5238 uint markov_disable = MARKOV_DISABLE;
5239 uint markov_classic = MARKOV_CLASSIC;
5240 uint markov_threshold = MARKOV_THRESHOLD;
5241 char *markov_hcstat = NULL;
5242 char *outfile = NULL;
5243 uint outfile_format = OUTFILE_FORMAT;
5244 uint outfile_autohex = OUTFILE_AUTOHEX;
5245 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5246 uint restore = RESTORE;
5247 uint restore_timer = RESTORE_TIMER;
5248 uint restore_disable = RESTORE_DISABLE;
5249 uint status = STATUS;
5250 uint status_timer = STATUS_TIMER;
5251 uint status_automat = STATUS_AUTOMAT;
5252 uint loopback = LOOPBACK;
5253 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5254 char *session = NULL;
5255 uint hex_charset = HEX_CHARSET;
5256 uint hex_salt = HEX_SALT;
5257 uint hex_wordlist = HEX_WORDLIST;
5258 uint rp_gen = RP_GEN;
5259 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5260 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5261 uint rp_gen_seed = RP_GEN_SEED;
5262 char *rule_buf_l = (char *) RULE_BUF_L;
5263 char *rule_buf_r = (char *) RULE_BUF_R;
5264 uint increment = INCREMENT;
5265 uint increment_min = INCREMENT_MIN;
5266 uint increment_max = INCREMENT_MAX;
5267 char *cpu_affinity = NULL;
5268 OCL_PTR *ocl = NULL;
5269 char *opencl_devices = NULL;
5270 char *opencl_platforms = NULL;
5271 char *opencl_device_types = NULL;
5272 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5273 char *truecrypt_keyfiles = NULL;
5274 uint workload_profile = WORKLOAD_PROFILE;
5275 uint kernel_accel = KERNEL_ACCEL;
5276 uint kernel_loops = KERNEL_LOOPS;
5277 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5278 #ifdef HAVE_HWMON
5279 uint gpu_temp_abort = GPU_TEMP_ABORT;
5280 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5281 #ifdef HAVE_ADL
5282 uint powertune_enable = POWERTUNE_ENABLE;
5283 #endif
5284 #endif
5285 uint logfile_disable = LOGFILE_DISABLE;
5286 uint segment_size = SEGMENT_SIZE;
5287 uint scrypt_tmto = SCRYPT_TMTO;
5288 char separator = SEPARATOR;
5289 uint bitmap_min = BITMAP_MIN;
5290 uint bitmap_max = BITMAP_MAX;
5291 char *custom_charset_1 = NULL;
5292 char *custom_charset_2 = NULL;
5293 char *custom_charset_3 = NULL;
5294 char *custom_charset_4 = NULL;
5295
5296 #define IDX_HELP 'h'
5297 #define IDX_VERSION 'V'
5298 #define IDX_VERSION_LOWER 'v'
5299 #define IDX_QUIET 0xff02
5300 #define IDX_SHOW 0xff03
5301 #define IDX_LEFT 0xff04
5302 #define IDX_REMOVE 0xff05
5303 #define IDX_REMOVE_TIMER 0xff37
5304 #define IDX_SKIP 's'
5305 #define IDX_LIMIT 'l'
5306 #define IDX_KEYSPACE 0xff35
5307 #define IDX_POTFILE_DISABLE 0xff06
5308 #define IDX_DEBUG_MODE 0xff43
5309 #define IDX_DEBUG_FILE 0xff44
5310 #define IDX_INDUCTION_DIR 0xff46
5311 #define IDX_OUTFILE_CHECK_DIR 0xff47
5312 #define IDX_USERNAME 0xff07
5313 #define IDX_FORCE 0xff08
5314 #define IDX_RUNTIME 0xff09
5315 #define IDX_BENCHMARK 'b'
5316 #define IDX_BENCHMARK_MODE 0xff32
5317 #define IDX_HASH_MODE 'm'
5318 #define IDX_ATTACK_MODE 'a'
5319 #define IDX_RP_FILE 'r'
5320 #define IDX_RP_GEN 'g'
5321 #define IDX_RP_GEN_FUNC_MIN 0xff10
5322 #define IDX_RP_GEN_FUNC_MAX 0xff11
5323 #define IDX_RP_GEN_SEED 0xff34
5324 #define IDX_RULE_BUF_L 'j'
5325 #define IDX_RULE_BUF_R 'k'
5326 #define IDX_INCREMENT 'i'
5327 #define IDX_INCREMENT_MIN 0xff12
5328 #define IDX_INCREMENT_MAX 0xff13
5329 #define IDX_OUTFILE 'o'
5330 #define IDX_OUTFILE_FORMAT 0xff14
5331 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5332 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5333 #define IDX_RESTORE 0xff15
5334 #define IDX_RESTORE_DISABLE 0xff27
5335 #define IDX_STATUS 0xff17
5336 #define IDX_STATUS_TIMER 0xff18
5337 #define IDX_STATUS_AUTOMAT 0xff50
5338 #define IDX_LOOPBACK 0xff38
5339 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5340 #define IDX_SESSION 0xff19
5341 #define IDX_HEX_CHARSET 0xff20
5342 #define IDX_HEX_SALT 0xff21
5343 #define IDX_HEX_WORDLIST 0xff40
5344 #define IDX_MARKOV_DISABLE 0xff22
5345 #define IDX_MARKOV_CLASSIC 0xff23
5346 #define IDX_MARKOV_THRESHOLD 't'
5347 #define IDX_MARKOV_HCSTAT 0xff24
5348 #define IDX_CPU_AFFINITY 0xff25
5349 #define IDX_OPENCL_DEVICES 'd'
5350 #define IDX_OPENCL_PLATFORMS 0xff72
5351 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5352 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5353 #define IDX_WORKLOAD_PROFILE 'w'
5354 #define IDX_KERNEL_ACCEL 'n'
5355 #define IDX_KERNEL_LOOPS 'u'
5356 #define IDX_GPU_TEMP_DISABLE 0xff29
5357 #define IDX_GPU_TEMP_ABORT 0xff30
5358 #define IDX_GPU_TEMP_RETAIN 0xff31
5359 #define IDX_POWERTUNE_ENABLE 0xff41
5360 #define IDX_LOGFILE_DISABLE 0xff51
5361 #define IDX_TRUECRYPT_KEYFILES 0xff52
5362 #define IDX_SCRYPT_TMTO 0xff61
5363 #define IDX_SEGMENT_SIZE 'c'
5364 #define IDX_SEPARATOR 'p'
5365 #define IDX_BITMAP_MIN 0xff70
5366 #define IDX_BITMAP_MAX 0xff71
5367 #define IDX_CUSTOM_CHARSET_1 '1'
5368 #define IDX_CUSTOM_CHARSET_2 '2'
5369 #define IDX_CUSTOM_CHARSET_3 '3'
5370 #define IDX_CUSTOM_CHARSET_4 '4'
5371
5372 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5373
5374 struct option long_options[] =
5375 {
5376 {"help", no_argument, 0, IDX_HELP},
5377 {"version", no_argument, 0, IDX_VERSION},
5378 {"quiet", no_argument, 0, IDX_QUIET},
5379 {"show", no_argument, 0, IDX_SHOW},
5380 {"left", no_argument, 0, IDX_LEFT},
5381 {"username", no_argument, 0, IDX_USERNAME},
5382 {"remove", no_argument, 0, IDX_REMOVE},
5383 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5384 {"skip", required_argument, 0, IDX_SKIP},
5385 {"limit", required_argument, 0, IDX_LIMIT},
5386 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5387 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5388 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5389 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5390 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5391 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5392 {"force", no_argument, 0, IDX_FORCE},
5393 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5394 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5395 {"restore", no_argument, 0, IDX_RESTORE},
5396 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5397 {"status", no_argument, 0, IDX_STATUS},
5398 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5399 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5400 {"loopback", no_argument, 0, IDX_LOOPBACK},
5401 {"weak-hash-threshold",
5402 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5403 {"session", required_argument, 0, IDX_SESSION},
5404 {"runtime", required_argument, 0, IDX_RUNTIME},
5405 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5406 {"generate-rules-func-min",
5407 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5408 {"generate-rules-func-max",
5409 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5410 {"generate-rules-seed",
5411 required_argument, 0, IDX_RP_GEN_SEED},
5412 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5413 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5414 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5415 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5416 {"rules-file", required_argument, 0, IDX_RP_FILE},
5417 {"outfile", required_argument, 0, IDX_OUTFILE},
5418 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5419 {"outfile-autohex-disable",
5420 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5421 {"outfile-check-timer",
5422 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5423 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5424 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5425 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5426 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5427 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5428 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5429 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5430 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5431 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5432 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5433 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5434 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5435 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5436 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5437 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5438 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5439 #ifdef HAVE_HWMON
5440 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5441 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5442 #ifdef HAVE_ADL
5443 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5444 #endif
5445 #endif // HAVE_HWMON
5446 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5447 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5448 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5449 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5450 // deprecated
5451 {"seperator", required_argument, 0, IDX_SEPARATOR},
5452 {"separator", required_argument, 0, IDX_SEPARATOR},
5453 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5454 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5455 {"increment", no_argument, 0, IDX_INCREMENT},
5456 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5457 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5458 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5459 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5460 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5461 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5462
5463 {0, 0, 0, 0}
5464 };
5465
5466 uint rp_files_cnt = 0;
5467
5468 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5469
5470 int option_index = 0;
5471 int c = -1;
5472
5473 optind = 1;
5474 optopt = 0;
5475
5476 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5477 {
5478 switch (c)
5479 {
5480 case IDX_HELP: usage = 1; break;
5481 case IDX_VERSION:
5482 case IDX_VERSION_LOWER: version = 1; break;
5483 case IDX_RESTORE: restore = 1; break;
5484 case IDX_SESSION: session = optarg; break;
5485 case IDX_SHOW: show = 1; break;
5486 case IDX_LEFT: left = 1; break;
5487 case '?': return (-1);
5488 }
5489 }
5490
5491 if (optopt != 0)
5492 {
5493 log_error ("ERROR: Invalid argument specified");
5494
5495 return (-1);
5496 }
5497
5498 /**
5499 * exit functions
5500 */
5501
5502 if (version)
5503 {
5504 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5505
5506 return (0);
5507 }
5508
5509 if (usage)
5510 {
5511 usage_big_print (PROGNAME);
5512
5513 return (0);
5514 }
5515
5516 /**
5517 * session needs to be set, always!
5518 */
5519
5520 if (session == NULL) session = (char *) PROGNAME;
5521
5522 /**
5523 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5524 */
5525
5526 char *exec_path = get_exec_path ();
5527
5528 #ifdef LINUX
5529
5530 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5531 char *resolved_exec_path = realpath (exec_path, NULL);
5532
5533 char *install_dir = get_install_dir (resolved_exec_path);
5534 char *profile_dir = NULL;
5535 char *session_dir = NULL;
5536 char *shared_dir = NULL;
5537
5538 if (strcmp (install_dir, resolved_install_folder) == 0)
5539 {
5540 struct passwd *pw = getpwuid (getuid ());
5541
5542 const char *homedir = pw->pw_dir;
5543
5544 profile_dir = get_profile_dir (homedir);
5545 session_dir = get_session_dir (profile_dir);
5546 shared_dir = strdup (SHARED_FOLDER);
5547
5548 mkdir (profile_dir, 0700);
5549 mkdir (session_dir, 0700);
5550 }
5551 else
5552 {
5553 profile_dir = install_dir;
5554 session_dir = install_dir;
5555 shared_dir = install_dir;
5556 }
5557
5558 myfree (resolved_install_folder);
5559 myfree (resolved_exec_path);
5560
5561 #else
5562
5563 char *install_dir = get_install_dir (exec_path);
5564 char *profile_dir = install_dir;
5565 char *session_dir = install_dir;
5566 char *shared_dir = install_dir;
5567
5568 #endif
5569
5570 data.install_dir = install_dir;
5571 data.profile_dir = profile_dir;
5572 data.session_dir = session_dir;
5573 data.shared_dir = shared_dir;
5574
5575 myfree (exec_path);
5576
5577 /**
5578 * kernel cache, we need to make sure folder exist
5579 */
5580
5581 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5582
5583 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5584
5585 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5586
5587 mkdir (kernels_folder, 0700);
5588
5589 myfree (kernels_folder);
5590
5591 /**
5592 * session
5593 */
5594
5595 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5596
5597 data.session = session;
5598
5599 char *eff_restore_file = (char *) mymalloc (session_size);
5600 char *new_restore_file = (char *) mymalloc (session_size);
5601
5602 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5603 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5604
5605 data.eff_restore_file = eff_restore_file;
5606 data.new_restore_file = new_restore_file;
5607
5608 if (((show == 1) || (left == 1)) && (restore == 1))
5609 {
5610 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5611 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5612
5613 return (-1);
5614 }
5615
5616 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5617 if ((show == 1) || (left == 1))
5618 {
5619 restore_disable = 1;
5620
5621 restore = 0;
5622 }
5623
5624 data.restore_disable = restore_disable;
5625
5626 restore_data_t *rd = init_restore (argc, argv);
5627
5628 data.rd = rd;
5629
5630 /**
5631 * restore file
5632 */
5633
5634 if (restore == 1)
5635 {
5636 read_restore (eff_restore_file, rd);
5637
5638 if (rd->version_bin < RESTORE_MIN)
5639 {
5640 log_error ("ERROR: Incompatible restore-file version");
5641
5642 return (-1);
5643 }
5644
5645 myargc = rd->argc;
5646 myargv = rd->argv;
5647
5648 #ifdef _POSIX
5649 rd->pid = getpid ();
5650 #elif _WIN
5651 rd->pid = GetCurrentProcessId ();
5652 #endif
5653 }
5654
5655 uint hash_mode_chgd = 0;
5656 uint runtime_chgd = 0;
5657 uint kernel_loops_chgd = 0;
5658 uint kernel_accel_chgd = 0;
5659 uint attack_mode_chgd = 0;
5660 uint outfile_format_chgd = 0;
5661 uint rp_gen_seed_chgd = 0;
5662 uint remove_timer_chgd = 0;
5663 uint increment_min_chgd = 0;
5664 uint increment_max_chgd = 0;
5665 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5666 uint gpu_temp_retain_chgd = 0;
5667 uint gpu_temp_abort_chgd = 0;
5668 #endif
5669
5670 optind = 1;
5671 optopt = 0;
5672 option_index = 0;
5673
5674 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5675 {
5676 switch (c)
5677 {
5678 //case IDX_HELP: usage = 1; break;
5679 //case IDX_VERSION: version = 1; break;
5680 //case IDX_RESTORE: restore = 1; break;
5681 case IDX_QUIET: quiet = 1; break;
5682 //case IDX_SHOW: show = 1; break;
5683 case IDX_SHOW: break;
5684 //case IDX_LEFT: left = 1; break;
5685 case IDX_LEFT: break;
5686 case IDX_USERNAME: username = 1; break;
5687 case IDX_REMOVE: remove = 1; break;
5688 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5689 remove_timer_chgd = 1; break;
5690 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5691 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5692 case IDX_DEBUG_FILE: debug_file = optarg; break;
5693 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5694 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5695 case IDX_FORCE: force = 1; break;
5696 case IDX_SKIP: skip = atoll (optarg); break;
5697 case IDX_LIMIT: limit = atoll (optarg); break;
5698 case IDX_KEYSPACE: keyspace = 1; break;
5699 case IDX_BENCHMARK: benchmark = 1; break;
5700 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5701 case IDX_RESTORE: break;
5702 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5703 case IDX_STATUS: status = 1; break;
5704 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5705 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5706 case IDX_LOOPBACK: loopback = 1; break;
5707 case IDX_WEAK_HASH_THRESHOLD:
5708 weak_hash_threshold = atoi (optarg); break;
5709 //case IDX_SESSION: session = optarg; break;
5710 case IDX_SESSION: break;
5711 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5712 hash_mode_chgd = 1; break;
5713 case IDX_RUNTIME: runtime = atoi (optarg);
5714 runtime_chgd = 1; break;
5715 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5716 attack_mode_chgd = 1; break;
5717 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5718 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5719 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5720 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5721 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5722 rp_gen_seed_chgd = 1; break;
5723 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5724 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5725 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5726 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5727 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5728 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5729 case IDX_OUTFILE: outfile = optarg; break;
5730 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5731 outfile_format_chgd = 1; break;
5732 case IDX_OUTFILE_AUTOHEX_DISABLE:
5733 outfile_autohex = 0; break;
5734 case IDX_OUTFILE_CHECK_TIMER:
5735 outfile_check_timer = atoi (optarg); break;
5736 case IDX_HEX_CHARSET: hex_charset = 1; break;
5737 case IDX_HEX_SALT: hex_salt = 1; break;
5738 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5739 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5740 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5741 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5742 case IDX_OPENCL_DEVICE_TYPES:
5743 opencl_device_types = optarg; break;
5744 case IDX_OPENCL_VECTOR_WIDTH:
5745 opencl_vector_width = atoi (optarg); break;
5746 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5747 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5748 kernel_accel_chgd = 1; break;
5749 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5750 kernel_loops_chgd = 1; break;
5751 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5752 #ifdef HAVE_HWMON
5753 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5754 #ifdef HAVE_ADL
5755 gpu_temp_abort_chgd = 1;
5756 #endif
5757 break;
5758 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5759 #ifdef HAVE_ADL
5760 gpu_temp_retain_chgd = 1;
5761 #endif
5762 break;
5763 #ifdef HAVE_ADL
5764 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5765 #endif
5766 #endif // HAVE_HWMON
5767 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5768 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5769 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5770 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5771 case IDX_SEPARATOR: separator = optarg[0]; break;
5772 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5773 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5774 case IDX_INCREMENT: increment = 1; break;
5775 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5776 increment_min_chgd = 1; break;
5777 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5778 increment_max_chgd = 1; break;
5779 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5780 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5781 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5782 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5783
5784 default:
5785 log_error ("ERROR: Invalid argument specified");
5786 return (-1);
5787 }
5788 }
5789
5790 if (optopt != 0)
5791 {
5792 log_error ("ERROR: Invalid argument specified");
5793
5794 return (-1);
5795 }
5796
5797 /**
5798 * Inform user things getting started,
5799 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5800 * - we do not need to check algorithm_pos
5801 */
5802
5803 if (quiet == 0)
5804 {
5805 if (benchmark == 1)
5806 {
5807 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5808
5809 log_info ("");
5810 }
5811 else if (restore == 1)
5812 {
5813 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5814
5815 log_info ("");
5816 }
5817 else
5818 {
5819 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5820
5821 log_info ("");
5822 }
5823 }
5824
5825 /**
5826 * sanity check
5827 */
5828
5829 if (attack_mode > 7)
5830 {
5831 log_error ("ERROR: Invalid attack-mode specified");
5832
5833 return (-1);
5834 }
5835
5836 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5837 {
5838 log_error ("ERROR: Invalid runtime specified");
5839
5840 return (-1);
5841 }
5842
5843 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5844 {
5845 log_error ("ERROR: Invalid hash-type specified");
5846
5847 return (-1);
5848 }
5849
5850 // renamed hash modes
5851
5852 if (hash_mode_chgd)
5853 {
5854 int n = -1;
5855
5856 switch (hash_mode)
5857 {
5858 case 123: n = 124;
5859 break;
5860 }
5861
5862 if (n >= 0)
5863 {
5864 log_error ("Old -m specified, use -m %d instead", n);
5865
5866 return (-1);
5867 }
5868 }
5869
5870 if (username == 1)
5871 {
5872 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5873 {
5874 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5875
5876 return (-1);
5877 }
5878 }
5879
5880 if (outfile_format > 16)
5881 {
5882 log_error ("ERROR: Invalid outfile-format specified");
5883
5884 return (-1);
5885 }
5886
5887 if (left == 1)
5888 {
5889 if (outfile_format_chgd == 1)
5890 {
5891 if (outfile_format > 1)
5892 {
5893 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5894
5895 return (-1);
5896 }
5897 }
5898 else
5899 {
5900 outfile_format = OUTFILE_FMT_HASH;
5901 }
5902 }
5903
5904 if (show == 1)
5905 {
5906 if (outfile_format_chgd == 1)
5907 {
5908 if ((outfile_format > 7) && (outfile_format < 16))
5909 {
5910 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5911
5912 return (-1);
5913 }
5914 }
5915 }
5916
5917 if (increment_min < INCREMENT_MIN)
5918 {
5919 log_error ("ERROR: Invalid increment-min specified");
5920
5921 return (-1);
5922 }
5923
5924 if (increment_max > INCREMENT_MAX)
5925 {
5926 log_error ("ERROR: Invalid increment-max specified");
5927
5928 return (-1);
5929 }
5930
5931 if (increment_min > increment_max)
5932 {
5933 log_error ("ERROR: Invalid increment-min specified");
5934
5935 return (-1);
5936 }
5937
5938 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5939 {
5940 log_error ("ERROR: increment is not allowed in attack-mode 0");
5941
5942 return (-1);
5943 }
5944
5945 if ((increment == 0) && (increment_min_chgd == 1))
5946 {
5947 log_error ("ERROR: increment-min is only supported together with increment switch");
5948
5949 return (-1);
5950 }
5951
5952 if ((increment == 0) && (increment_max_chgd == 1))
5953 {
5954 log_error ("ERROR: increment-max is only supported together with increment switch");
5955
5956 return (-1);
5957 }
5958
5959 if (rp_files_cnt && rp_gen)
5960 {
5961 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5962
5963 return (-1);
5964 }
5965
5966 if (rp_files_cnt || rp_gen)
5967 {
5968 if (attack_mode != ATTACK_MODE_STRAIGHT)
5969 {
5970 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5971
5972 return (-1);
5973 }
5974 }
5975
5976 if (rp_gen_func_min > rp_gen_func_max)
5977 {
5978 log_error ("ERROR: Invalid rp-gen-func-min specified");
5979
5980 return (-1);
5981 }
5982
5983 if (kernel_accel_chgd == 1)
5984 {
5985 if (workload_profile != WORKLOAD_PROFILE)
5986 {
5987 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5988
5989 return (-1);
5990 }
5991
5992 if (kernel_accel < 1)
5993 {
5994 log_error ("ERROR: Invalid kernel-accel specified");
5995
5996 return (-1);
5997 }
5998
5999 if (kernel_accel > 1024)
6000 {
6001 log_error ("ERROR: Invalid kernel-accel specified");
6002
6003 return (-1);
6004 }
6005 }
6006
6007 if (kernel_loops_chgd == 1)
6008 {
6009 if (workload_profile != WORKLOAD_PROFILE)
6010 {
6011 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6012
6013 return (-1);
6014 }
6015
6016 if (kernel_loops < 1)
6017 {
6018 log_error ("ERROR: Invalid kernel-loops specified");
6019
6020 return (-1);
6021 }
6022
6023 if (kernel_loops > 1024)
6024 {
6025 log_error ("ERROR: Invalid kernel-loops specified");
6026
6027 return (-1);
6028 }
6029 }
6030
6031 if (benchmark == 1)
6032 {
6033 if (workload_profile != WORKLOAD_PROFILE)
6034 {
6035 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6036
6037 return (-1);
6038 }
6039 }
6040
6041 if ((workload_profile < 1) || (workload_profile > 3))
6042 {
6043 log_error ("ERROR: workload-profile %i not available", workload_profile);
6044
6045 return (-1);
6046 }
6047
6048 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6049 {
6050 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6051
6052 return (-1);
6053 }
6054
6055 if (show == 1 || left == 1)
6056 {
6057 attack_mode = ATTACK_MODE_NONE;
6058
6059 if (remove == 1)
6060 {
6061 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6062
6063 return (-1);
6064 }
6065
6066 if (potfile_disable == 1)
6067 {
6068 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6069
6070 return (-1);
6071 }
6072 }
6073
6074 uint attack_kern = ATTACK_KERN_NONE;
6075
6076 switch (attack_mode)
6077 {
6078 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6079 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6080 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6081 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6082 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6083 }
6084
6085 if (benchmark == 0)
6086 {
6087 if (keyspace == 1)
6088 {
6089 int num_additional_params = 1;
6090
6091 if (attack_kern == ATTACK_KERN_COMBI)
6092 {
6093 num_additional_params = 2;
6094 }
6095
6096 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6097
6098 if (keyspace_wordlist_specified == 0) optind--;
6099 }
6100
6101 if (attack_kern == ATTACK_KERN_NONE)
6102 {
6103 if ((optind + 1) != myargc)
6104 {
6105 usage_mini_print (myargv[0]);
6106
6107 return (-1);
6108 }
6109 }
6110 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6111 {
6112 if ((optind + 1) > myargc)
6113 {
6114 usage_mini_print (myargv[0]);
6115
6116 return (-1);
6117 }
6118 }
6119 else if (attack_kern == ATTACK_KERN_COMBI)
6120 {
6121 if ((optind + 3) != myargc)
6122 {
6123 usage_mini_print (myargv[0]);
6124
6125 return (-1);
6126 }
6127 }
6128 else if (attack_kern == ATTACK_KERN_BF)
6129 {
6130 if ((optind + 1) > myargc)
6131 {
6132 usage_mini_print (myargv[0]);
6133
6134 return (-1);
6135 }
6136 }
6137 else
6138 {
6139 usage_mini_print (myargv[0]);
6140
6141 return (-1);
6142 }
6143 }
6144 else
6145 {
6146 if (myargv[optind] != 0)
6147 {
6148 log_error ("ERROR: Invalid argument for benchmark mode specified");
6149
6150 return (-1);
6151 }
6152
6153 if (attack_mode_chgd == 1)
6154 {
6155 if (attack_mode != ATTACK_MODE_BF)
6156 {
6157 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if (benchmark_mode == 0)
6164 {
6165 // nothing to do
6166 }
6167 else if (benchmark_mode == 1)
6168 {
6169 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6170 {
6171 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6172
6173 return (-1);
6174 }
6175 }
6176 else
6177 {
6178 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6179
6180 return (-1);
6181 }
6182 }
6183
6184 if (skip != 0 && limit != 0)
6185 {
6186 limit += skip;
6187 }
6188
6189 if (keyspace == 1)
6190 {
6191 if (show == 1)
6192 {
6193 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6194
6195 return (-1);
6196 }
6197 else if (left == 1)
6198 {
6199 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6200
6201 return (-1);
6202 }
6203
6204 potfile_disable = 1;
6205
6206 restore_disable = 1;
6207
6208 restore = 0;
6209
6210 weak_hash_threshold = 0;
6211
6212 quiet = 1;
6213 }
6214
6215 if (remove_timer_chgd == 1)
6216 {
6217 if (remove == 0)
6218 {
6219 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6220
6221 return (-1);
6222 }
6223
6224 if (remove_timer < 1)
6225 {
6226 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6227
6228 return (-1);
6229 }
6230 }
6231
6232 if (loopback == 1)
6233 {
6234 if (attack_mode == ATTACK_MODE_BF)
6235 {
6236 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6237
6238 return (-1);
6239 }
6240 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6241 {
6242 if ((rp_files_cnt == 0) && (rp_gen == 0))
6243 {
6244 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6245
6246 return (-1);
6247 }
6248 }
6249 }
6250
6251 if (debug_mode > 0)
6252 {
6253 if (attack_mode != ATTACK_MODE_STRAIGHT)
6254 {
6255 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6256
6257 return (-1);
6258 }
6259
6260 if ((rp_files_cnt == 0) && (rp_gen == 0))
6261 {
6262 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6263
6264 return (-1);
6265 }
6266 }
6267
6268 if (debug_mode > 4)
6269 {
6270 log_error ("ERROR: Invalid debug-mode specified");
6271
6272 return (-1);
6273 }
6274
6275 if (debug_file != NULL)
6276 {
6277 if (debug_mode < 1)
6278 {
6279 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6280
6281 return (-1);
6282 }
6283 }
6284
6285 if (induction_dir != NULL)
6286 {
6287 if (attack_mode == ATTACK_MODE_BF)
6288 {
6289 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6290
6291 return (-1);
6292 }
6293 }
6294
6295 if (attack_mode != ATTACK_MODE_STRAIGHT)
6296 {
6297 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6298 {
6299 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6300
6301 return (-1);
6302 }
6303
6304 weak_hash_threshold = 0;
6305 }
6306
6307 /**
6308 * induction directory
6309 */
6310
6311 char *induction_directory = NULL;
6312
6313 if (attack_mode != ATTACK_MODE_BF)
6314 {
6315 if (induction_dir == NULL)
6316 {
6317 induction_directory = (char *) mymalloc (session_size);
6318
6319 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6320
6321 // create induction folder if it does not already exist
6322
6323 if (keyspace == 0)
6324 {
6325 if (rmdir (induction_directory) == -1)
6326 {
6327 if (errno == ENOENT)
6328 {
6329 // good, we can ignore
6330 }
6331 else if (errno == ENOTEMPTY)
6332 {
6333 char *induction_directory_mv = (char *) mymalloc (session_size);
6334
6335 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6336
6337 if (rename (induction_directory, induction_directory_mv) != 0)
6338 {
6339 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6340
6341 return (-1);
6342 }
6343 }
6344 else
6345 {
6346 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6347
6348 return (-1);
6349 }
6350 }
6351
6352 if (mkdir (induction_directory, 0700) == -1)
6353 {
6354 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6355
6356 return (-1);
6357 }
6358 }
6359 }
6360 else
6361 {
6362 induction_directory = induction_dir;
6363 }
6364 }
6365
6366 data.induction_directory = induction_directory;
6367
6368 /**
6369 * loopback
6370 */
6371
6372 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6373
6374 char *loopback_file = (char *) mymalloc (loopback_size);
6375
6376 /**
6377 * tuning db
6378 */
6379
6380 char tuning_db_file[256] = { 0 };
6381
6382 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6383
6384 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6385
6386 /**
6387 * outfile-check directory
6388 */
6389
6390 char *outfile_check_directory = NULL;
6391
6392 if (outfile_check_dir == NULL)
6393 {
6394 outfile_check_directory = (char *) mymalloc (session_size);
6395
6396 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6397 }
6398 else
6399 {
6400 outfile_check_directory = outfile_check_dir;
6401 }
6402
6403 data.outfile_check_directory = outfile_check_directory;
6404
6405 if (keyspace == 0)
6406 {
6407 struct stat outfile_check_stat;
6408
6409 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6410 {
6411 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6412
6413 if (is_dir == 0)
6414 {
6415 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6416
6417 return (-1);
6418 }
6419 }
6420 else if (outfile_check_dir == NULL)
6421 {
6422 if (mkdir (outfile_check_directory, 0700) == -1)
6423 {
6424 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6425
6426 return (-1);
6427 }
6428 }
6429 }
6430
6431 /**
6432 * special other stuff
6433 */
6434
6435 if (hash_mode == 9710)
6436 {
6437 outfile_format = 5;
6438 outfile_format_chgd = 1;
6439 }
6440
6441 if (hash_mode == 9810)
6442 {
6443 outfile_format = 5;
6444 outfile_format_chgd = 1;
6445 }
6446
6447 if (hash_mode == 10410)
6448 {
6449 outfile_format = 5;
6450 outfile_format_chgd = 1;
6451 }
6452
6453 /**
6454 * store stuff
6455 */
6456
6457 data.hash_mode = hash_mode;
6458 data.restore = restore;
6459 data.restore_timer = restore_timer;
6460 data.restore_disable = restore_disable;
6461 data.status = status;
6462 data.status_timer = status_timer;
6463 data.status_automat = status_automat;
6464 data.loopback = loopback;
6465 data.runtime = runtime;
6466 data.remove = remove;
6467 data.remove_timer = remove_timer;
6468 data.debug_mode = debug_mode;
6469 data.debug_file = debug_file;
6470 data.username = username;
6471 data.quiet = quiet;
6472 data.outfile = outfile;
6473 data.outfile_format = outfile_format;
6474 data.outfile_autohex = outfile_autohex;
6475 data.hex_charset = hex_charset;
6476 data.hex_salt = hex_salt;
6477 data.hex_wordlist = hex_wordlist;
6478 data.separator = separator;
6479 data.rp_files = rp_files;
6480 data.rp_files_cnt = rp_files_cnt;
6481 data.rp_gen = rp_gen;
6482 data.rp_gen_seed = rp_gen_seed;
6483 data.force = force;
6484 data.benchmark = benchmark;
6485 data.skip = skip;
6486 data.limit = limit;
6487 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6488 data.powertune_enable = powertune_enable;
6489 #endif
6490 data.logfile_disable = logfile_disable;
6491 data.truecrypt_keyfiles = truecrypt_keyfiles;
6492 data.scrypt_tmto = scrypt_tmto;
6493
6494 /**
6495 * cpu affinity
6496 */
6497
6498 if (cpu_affinity)
6499 {
6500 set_cpu_affinity (cpu_affinity);
6501 }
6502
6503 if (rp_gen_seed_chgd == 0)
6504 {
6505 srand (proc_start);
6506 }
6507 else
6508 {
6509 srand (rp_gen_seed);
6510 }
6511
6512 /**
6513 * logfile init
6514 */
6515
6516 if (logfile_disable == 0)
6517 {
6518 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6519
6520 char *logfile = (char *) mymalloc (logfile_size);
6521
6522 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6523
6524 data.logfile = logfile;
6525
6526 char *topid = logfile_generate_topid ();
6527
6528 data.topid = topid;
6529 }
6530
6531 // logfile_append() checks for logfile_disable internally to make it easier from here
6532
6533 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6534 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6535 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6536 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6537 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6538 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6539 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6540 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6541 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6542 #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));
6543
6544 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6545 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6546 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6547 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6548 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6549 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6550 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6551 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6552
6553 logfile_top_msg ("START");
6554
6555 logfile_top_uint (attack_mode);
6556 logfile_top_uint (attack_kern);
6557 logfile_top_uint (benchmark);
6558 logfile_top_uint (benchmark_mode);
6559 logfile_top_uint (bitmap_min);
6560 logfile_top_uint (bitmap_max);
6561 logfile_top_uint (debug_mode);
6562 logfile_top_uint (force);
6563 logfile_top_uint (kernel_accel);
6564 logfile_top_uint (kernel_loops);
6565 logfile_top_uint (gpu_temp_disable);
6566 #ifdef HAVE_HWMON
6567 logfile_top_uint (gpu_temp_abort);
6568 logfile_top_uint (gpu_temp_retain);
6569 #endif
6570 logfile_top_uint (hash_mode);
6571 logfile_top_uint (hex_charset);
6572 logfile_top_uint (hex_salt);
6573 logfile_top_uint (hex_wordlist);
6574 logfile_top_uint (increment);
6575 logfile_top_uint (increment_max);
6576 logfile_top_uint (increment_min);
6577 logfile_top_uint (keyspace);
6578 logfile_top_uint (left);
6579 logfile_top_uint (logfile_disable);
6580 logfile_top_uint (loopback);
6581 logfile_top_uint (markov_classic);
6582 logfile_top_uint (markov_disable);
6583 logfile_top_uint (markov_threshold);
6584 logfile_top_uint (outfile_autohex);
6585 logfile_top_uint (outfile_check_timer);
6586 logfile_top_uint (outfile_format);
6587 logfile_top_uint (potfile_disable);
6588 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6589 logfile_top_uint (powertune_enable);
6590 #endif
6591 logfile_top_uint (scrypt_tmto);
6592 logfile_top_uint (quiet);
6593 logfile_top_uint (remove);
6594 logfile_top_uint (remove_timer);
6595 logfile_top_uint (restore);
6596 logfile_top_uint (restore_disable);
6597 logfile_top_uint (restore_timer);
6598 logfile_top_uint (rp_gen);
6599 logfile_top_uint (rp_gen_func_max);
6600 logfile_top_uint (rp_gen_func_min);
6601 logfile_top_uint (rp_gen_seed);
6602 logfile_top_uint (runtime);
6603 logfile_top_uint (segment_size);
6604 logfile_top_uint (show);
6605 logfile_top_uint (status);
6606 logfile_top_uint (status_automat);
6607 logfile_top_uint (status_timer);
6608 logfile_top_uint (usage);
6609 logfile_top_uint (username);
6610 logfile_top_uint (version);
6611 logfile_top_uint (weak_hash_threshold);
6612 logfile_top_uint (workload_profile);
6613 logfile_top_uint64 (limit);
6614 logfile_top_uint64 (skip);
6615 logfile_top_char (separator);
6616 logfile_top_string (cpu_affinity);
6617 logfile_top_string (custom_charset_1);
6618 logfile_top_string (custom_charset_2);
6619 logfile_top_string (custom_charset_3);
6620 logfile_top_string (custom_charset_4);
6621 logfile_top_string (debug_file);
6622 logfile_top_string (opencl_devices);
6623 logfile_top_string (opencl_platforms);
6624 logfile_top_string (opencl_device_types);
6625 logfile_top_uint (opencl_vector_width);
6626 logfile_top_string (induction_dir);
6627 logfile_top_string (markov_hcstat);
6628 logfile_top_string (outfile);
6629 logfile_top_string (outfile_check_dir);
6630 logfile_top_string (rule_buf_l);
6631 logfile_top_string (rule_buf_r);
6632 logfile_top_string (session);
6633 logfile_top_string (truecrypt_keyfiles);
6634
6635 /**
6636 * Init OpenCL library loader
6637 */
6638
6639 if (keyspace == 0)
6640 {
6641 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6642
6643 ocl_init (ocl);
6644
6645 data.ocl = ocl;
6646 }
6647
6648 /**
6649 * OpenCL platform selection
6650 */
6651
6652 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6653
6654 /**
6655 * OpenCL device selection
6656 */
6657
6658 u32 devices_filter = setup_devices_filter (opencl_devices);
6659
6660 /**
6661 * OpenCL device type selection
6662 */
6663
6664 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6665
6666 /**
6667 * benchmark
6668 */
6669
6670 if (benchmark == 1)
6671 {
6672 /**
6673 * disable useless stuff for benchmark
6674 */
6675
6676 restore_timer = 0;
6677 status_timer = 0;
6678 restore_disable = 1;
6679 potfile_disable = 1;
6680 weak_hash_threshold = 0;
6681
6682 data.restore_timer = restore_timer;
6683 data.status_timer = status_timer;
6684 data.restore_disable = restore_disable;
6685
6686 if (benchmark_mode == 1)
6687 {
6688 markov_disable = 1;
6689
6690 workload_profile = 3;
6691 }
6692
6693 /**
6694 * force attack mode to be bruteforce
6695 */
6696
6697 attack_mode = ATTACK_MODE_BF;
6698 attack_kern = ATTACK_KERN_BF;
6699
6700 if (runtime_chgd == 0)
6701 {
6702 runtime = 8;
6703
6704 if (benchmark_mode == 1) runtime = 17;
6705
6706 data.runtime = runtime;
6707 }
6708 }
6709
6710 /**
6711 * config
6712 */
6713
6714 uint hash_type = 0;
6715 uint salt_type = 0;
6716 uint attack_exec = 0;
6717 uint opts_type = 0;
6718 uint kern_type = 0;
6719 uint dgst_size = 0;
6720 uint esalt_size = 0;
6721 uint opti_type = 0;
6722 uint dgst_pos0 = -1;
6723 uint dgst_pos1 = -1;
6724 uint dgst_pos2 = -1;
6725 uint dgst_pos3 = -1;
6726
6727 int (*parse_func) (char *, uint, hash_t *);
6728 int (*sort_by_digest) (const void *, const void *);
6729
6730 uint algorithm_pos = 0;
6731 uint algorithm_max = 1;
6732
6733 uint *algorithms = default_benchmark_algorithms;
6734
6735 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6736
6737 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6738 {
6739 /*
6740 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6741 * the following algos are skipped entirely
6742 */
6743
6744 if (algorithm_pos > 0)
6745 {
6746 local_free (rd);
6747
6748 rd = init_restore (argc, argv);
6749
6750 data.rd = rd;
6751 }
6752
6753 /**
6754 * update hash_mode in case of multihash benchmark
6755 */
6756
6757 if (benchmark == 1)
6758 {
6759 if (hash_mode_chgd == 0)
6760 {
6761 hash_mode = algorithms[algorithm_pos];
6762
6763 data.hash_mode = hash_mode;
6764 }
6765
6766 quiet = 1;
6767
6768 data.quiet = quiet;
6769 }
6770
6771 switch (hash_mode)
6772 {
6773 case 0: hash_type = HASH_TYPE_MD5;
6774 salt_type = SALT_TYPE_NONE;
6775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6776 opts_type = OPTS_TYPE_PT_GENERATE_LE
6777 | OPTS_TYPE_PT_ADD80
6778 | OPTS_TYPE_PT_ADDBITS14;
6779 kern_type = KERN_TYPE_MD5;
6780 dgst_size = DGST_SIZE_4_4;
6781 parse_func = md5_parse_hash;
6782 sort_by_digest = sort_by_digest_4_4;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_PRECOMPUTE_INIT
6785 | OPTI_TYPE_PRECOMPUTE_MERKLE
6786 | OPTI_TYPE_MEET_IN_MIDDLE
6787 | OPTI_TYPE_EARLY_SKIP
6788 | OPTI_TYPE_NOT_ITERATED
6789 | OPTI_TYPE_NOT_SALTED
6790 | OPTI_TYPE_RAW_HASH;
6791 dgst_pos0 = 0;
6792 dgst_pos1 = 3;
6793 dgst_pos2 = 2;
6794 dgst_pos3 = 1;
6795 break;
6796
6797 case 10: hash_type = HASH_TYPE_MD5;
6798 salt_type = SALT_TYPE_INTERN;
6799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6800 opts_type = OPTS_TYPE_PT_GENERATE_LE
6801 | OPTS_TYPE_ST_ADD80
6802 | OPTS_TYPE_ST_ADDBITS14;
6803 kern_type = KERN_TYPE_MD5_PWSLT;
6804 dgst_size = DGST_SIZE_4_4;
6805 parse_func = md5s_parse_hash;
6806 sort_by_digest = sort_by_digest_4_4;
6807 opti_type = OPTI_TYPE_ZERO_BYTE
6808 | OPTI_TYPE_PRECOMPUTE_INIT
6809 | OPTI_TYPE_PRECOMPUTE_MERKLE
6810 | OPTI_TYPE_MEET_IN_MIDDLE
6811 | OPTI_TYPE_EARLY_SKIP
6812 | OPTI_TYPE_NOT_ITERATED
6813 | OPTI_TYPE_APPENDED_SALT
6814 | OPTI_TYPE_RAW_HASH;
6815 dgst_pos0 = 0;
6816 dgst_pos1 = 3;
6817 dgst_pos2 = 2;
6818 dgst_pos3 = 1;
6819 break;
6820
6821 case 11: hash_type = HASH_TYPE_MD5;
6822 salt_type = SALT_TYPE_INTERN;
6823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6824 opts_type = OPTS_TYPE_PT_GENERATE_LE
6825 | OPTS_TYPE_ST_ADD80
6826 | OPTS_TYPE_ST_ADDBITS14;
6827 kern_type = KERN_TYPE_MD5_PWSLT;
6828 dgst_size = DGST_SIZE_4_4;
6829 parse_func = joomla_parse_hash;
6830 sort_by_digest = sort_by_digest_4_4;
6831 opti_type = OPTI_TYPE_ZERO_BYTE
6832 | OPTI_TYPE_PRECOMPUTE_INIT
6833 | OPTI_TYPE_PRECOMPUTE_MERKLE
6834 | OPTI_TYPE_MEET_IN_MIDDLE
6835 | OPTI_TYPE_EARLY_SKIP
6836 | OPTI_TYPE_NOT_ITERATED
6837 | OPTI_TYPE_APPENDED_SALT
6838 | OPTI_TYPE_RAW_HASH;
6839 dgst_pos0 = 0;
6840 dgst_pos1 = 3;
6841 dgst_pos2 = 2;
6842 dgst_pos3 = 1;
6843 break;
6844
6845 case 12: hash_type = HASH_TYPE_MD5;
6846 salt_type = SALT_TYPE_INTERN;
6847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6848 opts_type = OPTS_TYPE_PT_GENERATE_LE
6849 | OPTS_TYPE_ST_ADD80
6850 | OPTS_TYPE_ST_ADDBITS14;
6851 kern_type = KERN_TYPE_MD5_PWSLT;
6852 dgst_size = DGST_SIZE_4_4;
6853 parse_func = postgresql_parse_hash;
6854 sort_by_digest = sort_by_digest_4_4;
6855 opti_type = OPTI_TYPE_ZERO_BYTE
6856 | OPTI_TYPE_PRECOMPUTE_INIT
6857 | OPTI_TYPE_PRECOMPUTE_MERKLE
6858 | OPTI_TYPE_MEET_IN_MIDDLE
6859 | OPTI_TYPE_EARLY_SKIP
6860 | OPTI_TYPE_NOT_ITERATED
6861 | OPTI_TYPE_APPENDED_SALT
6862 | OPTI_TYPE_RAW_HASH;
6863 dgst_pos0 = 0;
6864 dgst_pos1 = 3;
6865 dgst_pos2 = 2;
6866 dgst_pos3 = 1;
6867 break;
6868
6869 case 20: hash_type = HASH_TYPE_MD5;
6870 salt_type = SALT_TYPE_INTERN;
6871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6872 opts_type = OPTS_TYPE_PT_GENERATE_LE
6873 | OPTS_TYPE_PT_ADD80
6874 | OPTS_TYPE_PT_ADDBITS14;
6875 kern_type = KERN_TYPE_MD5_SLTPW;
6876 dgst_size = DGST_SIZE_4_4;
6877 parse_func = md5s_parse_hash;
6878 sort_by_digest = sort_by_digest_4_4;
6879 opti_type = OPTI_TYPE_ZERO_BYTE
6880 | OPTI_TYPE_PRECOMPUTE_INIT
6881 | OPTI_TYPE_PRECOMPUTE_MERKLE
6882 | OPTI_TYPE_EARLY_SKIP
6883 | OPTI_TYPE_NOT_ITERATED
6884 | OPTI_TYPE_PREPENDED_SALT
6885 | OPTI_TYPE_RAW_HASH;
6886 dgst_pos0 = 0;
6887 dgst_pos1 = 3;
6888 dgst_pos2 = 2;
6889 dgst_pos3 = 1;
6890 break;
6891
6892 case 21: hash_type = HASH_TYPE_MD5;
6893 salt_type = SALT_TYPE_INTERN;
6894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6895 opts_type = OPTS_TYPE_PT_GENERATE_LE
6896 | OPTS_TYPE_PT_ADD80
6897 | OPTS_TYPE_PT_ADDBITS14;
6898 kern_type = KERN_TYPE_MD5_SLTPW;
6899 dgst_size = DGST_SIZE_4_4;
6900 parse_func = osc_parse_hash;
6901 sort_by_digest = sort_by_digest_4_4;
6902 opti_type = OPTI_TYPE_ZERO_BYTE
6903 | OPTI_TYPE_PRECOMPUTE_INIT
6904 | OPTI_TYPE_PRECOMPUTE_MERKLE
6905 | OPTI_TYPE_EARLY_SKIP
6906 | OPTI_TYPE_NOT_ITERATED
6907 | OPTI_TYPE_PREPENDED_SALT
6908 | OPTI_TYPE_RAW_HASH;
6909 dgst_pos0 = 0;
6910 dgst_pos1 = 3;
6911 dgst_pos2 = 2;
6912 dgst_pos3 = 1;
6913 break;
6914
6915 case 22: hash_type = HASH_TYPE_MD5;
6916 salt_type = SALT_TYPE_EMBEDDED;
6917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6918 opts_type = OPTS_TYPE_PT_GENERATE_LE
6919 | OPTS_TYPE_PT_ADD80
6920 | OPTS_TYPE_PT_ADDBITS14;
6921 kern_type = KERN_TYPE_MD5_SLTPW;
6922 dgst_size = DGST_SIZE_4_4;
6923 parse_func = netscreen_parse_hash;
6924 sort_by_digest = sort_by_digest_4_4;
6925 opti_type = OPTI_TYPE_ZERO_BYTE
6926 | OPTI_TYPE_PRECOMPUTE_INIT
6927 | OPTI_TYPE_PRECOMPUTE_MERKLE
6928 | OPTI_TYPE_EARLY_SKIP
6929 | OPTI_TYPE_NOT_ITERATED
6930 | OPTI_TYPE_PREPENDED_SALT
6931 | OPTI_TYPE_RAW_HASH;
6932 dgst_pos0 = 0;
6933 dgst_pos1 = 3;
6934 dgst_pos2 = 2;
6935 dgst_pos3 = 1;
6936 break;
6937
6938 case 23: hash_type = HASH_TYPE_MD5;
6939 salt_type = SALT_TYPE_EMBEDDED;
6940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6941 opts_type = OPTS_TYPE_PT_GENERATE_LE
6942 | OPTS_TYPE_PT_ADD80
6943 | OPTS_TYPE_PT_ADDBITS14;
6944 kern_type = KERN_TYPE_MD5_SLTPW;
6945 dgst_size = DGST_SIZE_4_4;
6946 parse_func = skype_parse_hash;
6947 sort_by_digest = sort_by_digest_4_4;
6948 opti_type = OPTI_TYPE_ZERO_BYTE
6949 | OPTI_TYPE_PRECOMPUTE_INIT
6950 | OPTI_TYPE_PRECOMPUTE_MERKLE
6951 | OPTI_TYPE_EARLY_SKIP
6952 | OPTI_TYPE_NOT_ITERATED
6953 | OPTI_TYPE_PREPENDED_SALT
6954 | OPTI_TYPE_RAW_HASH;
6955 dgst_pos0 = 0;
6956 dgst_pos1 = 3;
6957 dgst_pos2 = 2;
6958 dgst_pos3 = 1;
6959 break;
6960
6961 case 30: hash_type = HASH_TYPE_MD5;
6962 salt_type = SALT_TYPE_INTERN;
6963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6964 opts_type = OPTS_TYPE_PT_GENERATE_LE
6965 | OPTS_TYPE_PT_UNICODE
6966 | OPTS_TYPE_ST_ADD80
6967 | OPTS_TYPE_ST_ADDBITS14;
6968 kern_type = KERN_TYPE_MD5_PWUSLT;
6969 dgst_size = DGST_SIZE_4_4;
6970 parse_func = md5s_parse_hash;
6971 sort_by_digest = sort_by_digest_4_4;
6972 opti_type = OPTI_TYPE_ZERO_BYTE
6973 | OPTI_TYPE_PRECOMPUTE_INIT
6974 | OPTI_TYPE_PRECOMPUTE_MERKLE
6975 | OPTI_TYPE_MEET_IN_MIDDLE
6976 | OPTI_TYPE_EARLY_SKIP
6977 | OPTI_TYPE_NOT_ITERATED
6978 | OPTI_TYPE_APPENDED_SALT
6979 | OPTI_TYPE_RAW_HASH;
6980 dgst_pos0 = 0;
6981 dgst_pos1 = 3;
6982 dgst_pos2 = 2;
6983 dgst_pos3 = 1;
6984 break;
6985
6986 case 40: hash_type = HASH_TYPE_MD5;
6987 salt_type = SALT_TYPE_INTERN;
6988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6989 opts_type = OPTS_TYPE_PT_GENERATE_LE
6990 | OPTS_TYPE_PT_ADD80
6991 | OPTS_TYPE_PT_ADDBITS14
6992 | OPTS_TYPE_PT_UNICODE;
6993 kern_type = KERN_TYPE_MD5_SLTPWU;
6994 dgst_size = DGST_SIZE_4_4;
6995 parse_func = md5s_parse_hash;
6996 sort_by_digest = sort_by_digest_4_4;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_EARLY_SKIP
7001 | OPTI_TYPE_NOT_ITERATED
7002 | OPTI_TYPE_PREPENDED_SALT
7003 | OPTI_TYPE_RAW_HASH;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 50: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_INTERN;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_ST_ADD80
7015 | OPTS_TYPE_ST_ADDBITS14;
7016 kern_type = KERN_TYPE_HMACMD5_PW;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = hmacmd5_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_NOT_ITERATED;
7022 dgst_pos0 = 0;
7023 dgst_pos1 = 3;
7024 dgst_pos2 = 2;
7025 dgst_pos3 = 1;
7026 break;
7027
7028 case 60: hash_type = HASH_TYPE_MD5;
7029 salt_type = SALT_TYPE_INTERN;
7030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7031 opts_type = OPTS_TYPE_PT_GENERATE_LE
7032 | OPTS_TYPE_PT_ADD80
7033 | OPTS_TYPE_PT_ADDBITS14;
7034 kern_type = KERN_TYPE_HMACMD5_SLT;
7035 dgst_size = DGST_SIZE_4_4;
7036 parse_func = hmacmd5_parse_hash;
7037 sort_by_digest = sort_by_digest_4_4;
7038 opti_type = OPTI_TYPE_ZERO_BYTE
7039 | OPTI_TYPE_NOT_ITERATED;
7040 dgst_pos0 = 0;
7041 dgst_pos1 = 3;
7042 dgst_pos2 = 2;
7043 dgst_pos3 = 1;
7044 break;
7045
7046 case 100: hash_type = HASH_TYPE_SHA1;
7047 salt_type = SALT_TYPE_NONE;
7048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7049 opts_type = OPTS_TYPE_PT_GENERATE_BE
7050 | OPTS_TYPE_PT_ADD80
7051 | OPTS_TYPE_PT_ADDBITS15;
7052 kern_type = KERN_TYPE_SHA1;
7053 dgst_size = DGST_SIZE_4_5;
7054 parse_func = sha1_parse_hash;
7055 sort_by_digest = sort_by_digest_4_5;
7056 opti_type = OPTI_TYPE_ZERO_BYTE
7057 | OPTI_TYPE_PRECOMPUTE_INIT
7058 | OPTI_TYPE_PRECOMPUTE_MERKLE
7059 | OPTI_TYPE_EARLY_SKIP
7060 | OPTI_TYPE_NOT_ITERATED
7061 | OPTI_TYPE_NOT_SALTED
7062 | OPTI_TYPE_RAW_HASH;
7063 dgst_pos0 = 3;
7064 dgst_pos1 = 4;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 101: hash_type = HASH_TYPE_SHA1;
7070 salt_type = SALT_TYPE_NONE;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_BE
7073 | OPTS_TYPE_PT_ADD80
7074 | OPTS_TYPE_PT_ADDBITS15;
7075 kern_type = KERN_TYPE_SHA1;
7076 dgst_size = DGST_SIZE_4_5;
7077 parse_func = sha1b64_parse_hash;
7078 sort_by_digest = sort_by_digest_4_5;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_NOT_SALTED
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 3;
7087 dgst_pos1 = 4;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 110: hash_type = HASH_TYPE_SHA1;
7093 salt_type = SALT_TYPE_INTERN;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_BE
7096 | OPTS_TYPE_ST_ADD80
7097 | OPTS_TYPE_ST_ADDBITS15;
7098 kern_type = KERN_TYPE_SHA1_PWSLT;
7099 dgst_size = DGST_SIZE_4_5;
7100 parse_func = sha1s_parse_hash;
7101 sort_by_digest = sort_by_digest_4_5;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_PRECOMPUTE_INIT
7104 | OPTI_TYPE_PRECOMPUTE_MERKLE
7105 | OPTI_TYPE_EARLY_SKIP
7106 | OPTI_TYPE_NOT_ITERATED
7107 | OPTI_TYPE_APPENDED_SALT
7108 | OPTI_TYPE_RAW_HASH;
7109 dgst_pos0 = 3;
7110 dgst_pos1 = 4;
7111 dgst_pos2 = 2;
7112 dgst_pos3 = 1;
7113 break;
7114
7115 case 111: hash_type = HASH_TYPE_SHA1;
7116 salt_type = SALT_TYPE_EMBEDDED;
7117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7118 opts_type = OPTS_TYPE_PT_GENERATE_BE
7119 | OPTS_TYPE_ST_ADD80
7120 | OPTS_TYPE_ST_ADDBITS15;
7121 kern_type = KERN_TYPE_SHA1_PWSLT;
7122 dgst_size = DGST_SIZE_4_5;
7123 parse_func = sha1b64s_parse_hash;
7124 sort_by_digest = sort_by_digest_4_5;
7125 opti_type = OPTI_TYPE_ZERO_BYTE
7126 | OPTI_TYPE_PRECOMPUTE_INIT
7127 | OPTI_TYPE_PRECOMPUTE_MERKLE
7128 | OPTI_TYPE_EARLY_SKIP
7129 | OPTI_TYPE_NOT_ITERATED
7130 | OPTI_TYPE_APPENDED_SALT
7131 | OPTI_TYPE_RAW_HASH;
7132 dgst_pos0 = 3;
7133 dgst_pos1 = 4;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 112: hash_type = HASH_TYPE_SHA1;
7139 salt_type = SALT_TYPE_INTERN;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_BE
7142 | OPTS_TYPE_ST_ADD80
7143 | OPTS_TYPE_ST_ADDBITS15
7144 | OPTS_TYPE_ST_HEX;
7145 kern_type = KERN_TYPE_SHA1_PWSLT;
7146 dgst_size = DGST_SIZE_4_5;
7147 parse_func = oracles_parse_hash;
7148 sort_by_digest = sort_by_digest_4_5;
7149 opti_type = OPTI_TYPE_ZERO_BYTE
7150 | OPTI_TYPE_PRECOMPUTE_INIT
7151 | OPTI_TYPE_PRECOMPUTE_MERKLE
7152 | OPTI_TYPE_EARLY_SKIP
7153 | OPTI_TYPE_NOT_ITERATED
7154 | OPTI_TYPE_APPENDED_SALT
7155 | OPTI_TYPE_RAW_HASH;
7156 dgst_pos0 = 3;
7157 dgst_pos1 = 4;
7158 dgst_pos2 = 2;
7159 dgst_pos3 = 1;
7160 break;
7161
7162 case 120: hash_type = HASH_TYPE_SHA1;
7163 salt_type = SALT_TYPE_INTERN;
7164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7165 opts_type = OPTS_TYPE_PT_GENERATE_BE
7166 | OPTS_TYPE_PT_ADD80
7167 | OPTS_TYPE_PT_ADDBITS15;
7168 kern_type = KERN_TYPE_SHA1_SLTPW;
7169 dgst_size = DGST_SIZE_4_5;
7170 parse_func = sha1s_parse_hash;
7171 sort_by_digest = sort_by_digest_4_5;
7172 opti_type = OPTI_TYPE_ZERO_BYTE
7173 | OPTI_TYPE_PRECOMPUTE_INIT
7174 | OPTI_TYPE_PRECOMPUTE_MERKLE
7175 | OPTI_TYPE_EARLY_SKIP
7176 | OPTI_TYPE_NOT_ITERATED
7177 | OPTI_TYPE_PREPENDED_SALT
7178 | OPTI_TYPE_RAW_HASH;
7179 dgst_pos0 = 3;
7180 dgst_pos1 = 4;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 1;
7183 break;
7184
7185 case 121: hash_type = HASH_TYPE_SHA1;
7186 salt_type = SALT_TYPE_INTERN;
7187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7188 opts_type = OPTS_TYPE_PT_GENERATE_BE
7189 | OPTS_TYPE_PT_ADD80
7190 | OPTS_TYPE_PT_ADDBITS15
7191 | OPTS_TYPE_ST_LOWER;
7192 kern_type = KERN_TYPE_SHA1_SLTPW;
7193 dgst_size = DGST_SIZE_4_5;
7194 parse_func = smf_parse_hash;
7195 sort_by_digest = sort_by_digest_4_5;
7196 opti_type = OPTI_TYPE_ZERO_BYTE
7197 | OPTI_TYPE_PRECOMPUTE_INIT
7198 | OPTI_TYPE_PRECOMPUTE_MERKLE
7199 | OPTI_TYPE_EARLY_SKIP
7200 | OPTI_TYPE_NOT_ITERATED
7201 | OPTI_TYPE_PREPENDED_SALT
7202 | OPTI_TYPE_RAW_HASH;
7203 dgst_pos0 = 3;
7204 dgst_pos1 = 4;
7205 dgst_pos2 = 2;
7206 dgst_pos3 = 1;
7207 break;
7208
7209 case 122: hash_type = HASH_TYPE_SHA1;
7210 salt_type = SALT_TYPE_EMBEDDED;
7211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7212 opts_type = OPTS_TYPE_PT_GENERATE_BE
7213 | OPTS_TYPE_PT_ADD80
7214 | OPTS_TYPE_PT_ADDBITS15
7215 | OPTS_TYPE_ST_HEX;
7216 kern_type = KERN_TYPE_SHA1_SLTPW;
7217 dgst_size = DGST_SIZE_4_5;
7218 parse_func = osx1_parse_hash;
7219 sort_by_digest = sort_by_digest_4_5;
7220 opti_type = OPTI_TYPE_ZERO_BYTE
7221 | OPTI_TYPE_PRECOMPUTE_INIT
7222 | OPTI_TYPE_PRECOMPUTE_MERKLE
7223 | OPTI_TYPE_EARLY_SKIP
7224 | OPTI_TYPE_NOT_ITERATED
7225 | OPTI_TYPE_PREPENDED_SALT
7226 | OPTI_TYPE_RAW_HASH;
7227 dgst_pos0 = 3;
7228 dgst_pos1 = 4;
7229 dgst_pos2 = 2;
7230 dgst_pos3 = 1;
7231 break;
7232
7233 case 124: hash_type = HASH_TYPE_SHA1;
7234 salt_type = SALT_TYPE_EMBEDDED;
7235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7236 opts_type = OPTS_TYPE_PT_GENERATE_BE
7237 | OPTS_TYPE_PT_ADD80
7238 | OPTS_TYPE_PT_ADDBITS15;
7239 kern_type = KERN_TYPE_SHA1_SLTPW;
7240 dgst_size = DGST_SIZE_4_5;
7241 parse_func = djangosha1_parse_hash;
7242 sort_by_digest = sort_by_digest_4_5;
7243 opti_type = OPTI_TYPE_ZERO_BYTE
7244 | OPTI_TYPE_PRECOMPUTE_INIT
7245 | OPTI_TYPE_PRECOMPUTE_MERKLE
7246 | OPTI_TYPE_EARLY_SKIP
7247 | OPTI_TYPE_NOT_ITERATED
7248 | OPTI_TYPE_PREPENDED_SALT
7249 | OPTI_TYPE_RAW_HASH;
7250 dgst_pos0 = 3;
7251 dgst_pos1 = 4;
7252 dgst_pos2 = 2;
7253 dgst_pos3 = 1;
7254 break;
7255
7256 case 130: hash_type = HASH_TYPE_SHA1;
7257 salt_type = SALT_TYPE_INTERN;
7258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7259 opts_type = OPTS_TYPE_PT_GENERATE_BE
7260 | OPTS_TYPE_PT_UNICODE
7261 | OPTS_TYPE_ST_ADD80
7262 | OPTS_TYPE_ST_ADDBITS15;
7263 kern_type = KERN_TYPE_SHA1_PWUSLT;
7264 dgst_size = DGST_SIZE_4_5;
7265 parse_func = sha1s_parse_hash;
7266 sort_by_digest = sort_by_digest_4_5;
7267 opti_type = OPTI_TYPE_ZERO_BYTE
7268 | OPTI_TYPE_PRECOMPUTE_INIT
7269 | OPTI_TYPE_PRECOMPUTE_MERKLE
7270 | OPTI_TYPE_EARLY_SKIP
7271 | OPTI_TYPE_NOT_ITERATED
7272 | OPTI_TYPE_APPENDED_SALT
7273 | OPTI_TYPE_RAW_HASH;
7274 dgst_pos0 = 3;
7275 dgst_pos1 = 4;
7276 dgst_pos2 = 2;
7277 dgst_pos3 = 1;
7278 break;
7279
7280 case 131: hash_type = HASH_TYPE_SHA1;
7281 salt_type = SALT_TYPE_EMBEDDED;
7282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7283 opts_type = OPTS_TYPE_PT_GENERATE_BE
7284 | OPTS_TYPE_PT_UNICODE
7285 | OPTS_TYPE_PT_UPPER
7286 | OPTS_TYPE_ST_ADD80
7287 | OPTS_TYPE_ST_ADDBITS15
7288 | OPTS_TYPE_ST_HEX;
7289 kern_type = KERN_TYPE_SHA1_PWUSLT;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = mssql2000_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_APPENDED_SALT
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 132: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_UNICODE
7311 | OPTS_TYPE_ST_ADD80
7312 | OPTS_TYPE_ST_ADDBITS15
7313 | OPTS_TYPE_ST_HEX;
7314 kern_type = KERN_TYPE_SHA1_PWUSLT;
7315 dgst_size = DGST_SIZE_4_5;
7316 parse_func = mssql2005_parse_hash;
7317 sort_by_digest = sort_by_digest_4_5;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_PRECOMPUTE_INIT
7320 | OPTI_TYPE_PRECOMPUTE_MERKLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_APPENDED_SALT
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 3;
7326 dgst_pos1 = 4;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 133: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_EMBEDDED;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_UNICODE
7336 | OPTS_TYPE_ST_ADD80
7337 | OPTS_TYPE_ST_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1_PWUSLT;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = peoplesoft_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_APPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 140: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_INTERN;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_ADD80
7360 | OPTS_TYPE_PT_ADDBITS15
7361 | OPTS_TYPE_PT_UNICODE;
7362 kern_type = KERN_TYPE_SHA1_SLTPWU;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = sha1s_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_PREPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 141: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_EMBEDDED;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_ADD80
7384 | OPTS_TYPE_PT_ADDBITS15
7385 | OPTS_TYPE_PT_UNICODE
7386 | OPTS_TYPE_ST_BASE64;
7387 kern_type = KERN_TYPE_SHA1_SLTPWU;
7388 dgst_size = DGST_SIZE_4_5;
7389 parse_func = episerver_parse_hash;
7390 sort_by_digest = sort_by_digest_4_5;
7391 opti_type = OPTI_TYPE_ZERO_BYTE
7392 | OPTI_TYPE_PRECOMPUTE_INIT
7393 | OPTI_TYPE_PRECOMPUTE_MERKLE
7394 | OPTI_TYPE_EARLY_SKIP
7395 | OPTI_TYPE_NOT_ITERATED
7396 | OPTI_TYPE_PREPENDED_SALT
7397 | OPTI_TYPE_RAW_HASH;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 4;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 1;
7402 break;
7403
7404 case 150: hash_type = HASH_TYPE_SHA1;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_ST_ADD80
7409 | OPTS_TYPE_ST_ADDBITS15;
7410 kern_type = KERN_TYPE_HMACSHA1_PW;
7411 dgst_size = DGST_SIZE_4_5;
7412 parse_func = hmacsha1_parse_hash;
7413 sort_by_digest = sort_by_digest_4_5;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_NOT_ITERATED;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 160: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_ADD80
7427 | OPTS_TYPE_PT_ADDBITS15;
7428 kern_type = KERN_TYPE_HMACSHA1_SLT;
7429 dgst_size = DGST_SIZE_4_5;
7430 parse_func = hmacsha1_parse_hash;
7431 sort_by_digest = sort_by_digest_4_5;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_NOT_ITERATED;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 190: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_NONE;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_ADD80
7445 | OPTS_TYPE_PT_ADDBITS15;
7446 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7447 dgst_size = DGST_SIZE_4_5;
7448 parse_func = sha1linkedin_parse_hash;
7449 sort_by_digest = sort_by_digest_4_5;
7450 opti_type = OPTI_TYPE_ZERO_BYTE
7451 | OPTI_TYPE_PRECOMPUTE_INIT
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_NOT_SALTED;
7455 dgst_pos0 = 0;
7456 dgst_pos1 = 4;
7457 dgst_pos2 = 3;
7458 dgst_pos3 = 2;
7459 break;
7460
7461 case 200: hash_type = HASH_TYPE_MYSQL;
7462 salt_type = SALT_TYPE_NONE;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = 0;
7465 kern_type = KERN_TYPE_MYSQL;
7466 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7467 parse_func = mysql323_parse_hash;
7468 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7469 opti_type = OPTI_TYPE_ZERO_BYTE;
7470 dgst_pos0 = 0;
7471 dgst_pos1 = 1;
7472 dgst_pos2 = 2;
7473 dgst_pos3 = 3;
7474 break;
7475
7476 case 300: hash_type = HASH_TYPE_SHA1;
7477 salt_type = SALT_TYPE_NONE;
7478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7479 opts_type = OPTS_TYPE_PT_GENERATE_BE
7480 | OPTS_TYPE_PT_ADD80
7481 | OPTS_TYPE_PT_ADDBITS15;
7482 kern_type = KERN_TYPE_MYSQL41;
7483 dgst_size = DGST_SIZE_4_5;
7484 parse_func = sha1_parse_hash;
7485 sort_by_digest = sort_by_digest_4_5;
7486 opti_type = OPTI_TYPE_ZERO_BYTE
7487 | OPTI_TYPE_PRECOMPUTE_INIT
7488 | OPTI_TYPE_PRECOMPUTE_MERKLE
7489 | OPTI_TYPE_EARLY_SKIP
7490 | OPTI_TYPE_NOT_ITERATED
7491 | OPTI_TYPE_NOT_SALTED;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 400: hash_type = HASH_TYPE_MD5;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7502 kern_type = KERN_TYPE_PHPASS;
7503 dgst_size = DGST_SIZE_4_4;
7504 parse_func = phpass_parse_hash;
7505 sort_by_digest = sort_by_digest_4_4;
7506 opti_type = OPTI_TYPE_ZERO_BYTE;
7507 dgst_pos0 = 0;
7508 dgst_pos1 = 1;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 3;
7511 break;
7512
7513 case 500: hash_type = HASH_TYPE_MD5;
7514 salt_type = SALT_TYPE_EMBEDDED;
7515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7517 kern_type = KERN_TYPE_MD5CRYPT;
7518 dgst_size = DGST_SIZE_4_4;
7519 parse_func = md5crypt_parse_hash;
7520 sort_by_digest = sort_by_digest_4_4;
7521 opti_type = OPTI_TYPE_ZERO_BYTE;
7522 dgst_pos0 = 0;
7523 dgst_pos1 = 1;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 3;
7526 break;
7527
7528 case 501: hash_type = HASH_TYPE_MD5;
7529 salt_type = SALT_TYPE_EMBEDDED;
7530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_LE
7532 | OPTS_TYPE_HASH_COPY;
7533 kern_type = KERN_TYPE_MD5CRYPT;
7534 dgst_size = DGST_SIZE_4_4;
7535 parse_func = juniper_parse_hash;
7536 sort_by_digest = sort_by_digest_4_4;
7537 opti_type = OPTI_TYPE_ZERO_BYTE;
7538 dgst_pos0 = 0;
7539 dgst_pos1 = 1;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 3;
7542 break;
7543
7544 case 900: hash_type = HASH_TYPE_MD4;
7545 salt_type = SALT_TYPE_NONE;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_LE
7548 | OPTS_TYPE_PT_ADD80
7549 | OPTS_TYPE_PT_ADDBITS14;
7550 kern_type = KERN_TYPE_MD4;
7551 dgst_size = DGST_SIZE_4_4;
7552 parse_func = md4_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_MEET_IN_MIDDLE
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_NOT_SALTED
7561 | OPTI_TYPE_RAW_HASH;
7562 dgst_pos0 = 0;
7563 dgst_pos1 = 3;
7564 dgst_pos2 = 2;
7565 dgst_pos3 = 1;
7566 break;
7567
7568 case 1000: hash_type = HASH_TYPE_MD4;
7569 salt_type = SALT_TYPE_NONE;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = OPTS_TYPE_PT_GENERATE_LE
7572 | OPTS_TYPE_PT_ADD80
7573 | OPTS_TYPE_PT_ADDBITS14
7574 | OPTS_TYPE_PT_UNICODE;
7575 kern_type = KERN_TYPE_MD4_PWU;
7576 dgst_size = DGST_SIZE_4_4;
7577 parse_func = md4_parse_hash;
7578 sort_by_digest = sort_by_digest_4_4;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_MEET_IN_MIDDLE
7583 | OPTI_TYPE_EARLY_SKIP
7584 | OPTI_TYPE_NOT_ITERATED
7585 | OPTI_TYPE_NOT_SALTED
7586 | OPTI_TYPE_RAW_HASH;
7587 dgst_pos0 = 0;
7588 dgst_pos1 = 3;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 1;
7591 break;
7592
7593 case 1100: hash_type = HASH_TYPE_MD4;
7594 salt_type = SALT_TYPE_INTERN;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_LE
7597 | OPTS_TYPE_PT_ADD80
7598 | OPTS_TYPE_PT_ADDBITS14
7599 | OPTS_TYPE_PT_UNICODE
7600 | OPTS_TYPE_ST_ADD80
7601 | OPTS_TYPE_ST_UNICODE
7602 | OPTS_TYPE_ST_LOWER;
7603 kern_type = KERN_TYPE_MD44_PWUSLT;
7604 dgst_size = DGST_SIZE_4_4;
7605 parse_func = dcc_parse_hash;
7606 sort_by_digest = sort_by_digest_4_4;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED;
7612 dgst_pos0 = 0;
7613 dgst_pos1 = 3;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 1;
7616 break;
7617
7618 case 1400: hash_type = HASH_TYPE_SHA256;
7619 salt_type = SALT_TYPE_NONE;
7620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_BE
7622 | OPTS_TYPE_PT_ADD80
7623 | OPTS_TYPE_PT_ADDBITS15;
7624 kern_type = KERN_TYPE_SHA256;
7625 dgst_size = DGST_SIZE_4_8;
7626 parse_func = sha256_parse_hash;
7627 sort_by_digest = sort_by_digest_4_8;
7628 opti_type = OPTI_TYPE_ZERO_BYTE
7629 | OPTI_TYPE_PRECOMPUTE_INIT
7630 | OPTI_TYPE_PRECOMPUTE_MERKLE
7631 | OPTI_TYPE_EARLY_SKIP
7632 | OPTI_TYPE_NOT_ITERATED
7633 | OPTI_TYPE_NOT_SALTED
7634 | OPTI_TYPE_RAW_HASH;
7635 dgst_pos0 = 3;
7636 dgst_pos1 = 7;
7637 dgst_pos2 = 2;
7638 dgst_pos3 = 6;
7639 break;
7640
7641 case 1410: hash_type = HASH_TYPE_SHA256;
7642 salt_type = SALT_TYPE_INTERN;
7643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7644 opts_type = OPTS_TYPE_PT_GENERATE_BE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA256_PWSLT;
7648 dgst_size = DGST_SIZE_4_8;
7649 parse_func = sha256s_parse_hash;
7650 sort_by_digest = sort_by_digest_4_8;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_APPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 3;
7659 dgst_pos1 = 7;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 6;
7662 break;
7663
7664 case 1420: hash_type = HASH_TYPE_SHA256;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_BE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS15;
7670 kern_type = KERN_TYPE_SHA256_SLTPW;
7671 dgst_size = DGST_SIZE_4_8;
7672 parse_func = sha256s_parse_hash;
7673 sort_by_digest = sort_by_digest_4_8;
7674 opti_type = OPTI_TYPE_ZERO_BYTE
7675 | OPTI_TYPE_PRECOMPUTE_INIT
7676 | OPTI_TYPE_PRECOMPUTE_MERKLE
7677 | OPTI_TYPE_EARLY_SKIP
7678 | OPTI_TYPE_NOT_ITERATED
7679 | OPTI_TYPE_PREPENDED_SALT
7680 | OPTI_TYPE_RAW_HASH;
7681 dgst_pos0 = 3;
7682 dgst_pos1 = 7;
7683 dgst_pos2 = 2;
7684 dgst_pos3 = 6;
7685 break;
7686
7687 case 1421: hash_type = HASH_TYPE_SHA256;
7688 salt_type = SALT_TYPE_EMBEDDED;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = OPTS_TYPE_PT_GENERATE_BE
7691 | OPTS_TYPE_PT_ADD80
7692 | OPTS_TYPE_PT_ADDBITS15;
7693 kern_type = KERN_TYPE_SHA256_SLTPW;
7694 dgst_size = DGST_SIZE_4_8;
7695 parse_func = hmailserver_parse_hash;
7696 sort_by_digest = sort_by_digest_4_8;
7697 opti_type = OPTI_TYPE_ZERO_BYTE
7698 | OPTI_TYPE_PRECOMPUTE_INIT
7699 | OPTI_TYPE_PRECOMPUTE_MERKLE
7700 | OPTI_TYPE_EARLY_SKIP
7701 | OPTI_TYPE_NOT_ITERATED
7702 | OPTI_TYPE_PREPENDED_SALT
7703 | OPTI_TYPE_RAW_HASH;
7704 dgst_pos0 = 3;
7705 dgst_pos1 = 7;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 6;
7708 break;
7709
7710 case 1430: hash_type = HASH_TYPE_SHA256;
7711 salt_type = SALT_TYPE_INTERN;
7712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7713 opts_type = OPTS_TYPE_PT_GENERATE_BE
7714 | OPTS_TYPE_PT_UNICODE
7715 | OPTS_TYPE_ST_ADD80
7716 | OPTS_TYPE_ST_ADDBITS15;
7717 kern_type = KERN_TYPE_SHA256_PWUSLT;
7718 dgst_size = DGST_SIZE_4_8;
7719 parse_func = sha256s_parse_hash;
7720 sort_by_digest = sort_by_digest_4_8;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_APPENDED_SALT
7727 | OPTI_TYPE_RAW_HASH;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 7;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 6;
7732 break;
7733
7734 case 1440: hash_type = HASH_TYPE_SHA256;
7735 salt_type = SALT_TYPE_INTERN;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS15
7740 | OPTS_TYPE_PT_UNICODE;
7741 kern_type = KERN_TYPE_SHA256_SLTPWU;
7742 dgst_size = DGST_SIZE_4_8;
7743 parse_func = sha256s_parse_hash;
7744 sort_by_digest = sort_by_digest_4_8;
7745 opti_type = OPTI_TYPE_ZERO_BYTE
7746 | OPTI_TYPE_PRECOMPUTE_INIT
7747 | OPTI_TYPE_PRECOMPUTE_MERKLE
7748 | OPTI_TYPE_EARLY_SKIP
7749 | OPTI_TYPE_NOT_ITERATED
7750 | OPTI_TYPE_PREPENDED_SALT
7751 | OPTI_TYPE_RAW_HASH;
7752 dgst_pos0 = 3;
7753 dgst_pos1 = 7;
7754 dgst_pos2 = 2;
7755 dgst_pos3 = 6;
7756 break;
7757
7758 case 1441: hash_type = HASH_TYPE_SHA256;
7759 salt_type = SALT_TYPE_EMBEDDED;
7760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7761 opts_type = OPTS_TYPE_PT_GENERATE_BE
7762 | OPTS_TYPE_PT_ADD80
7763 | OPTS_TYPE_PT_ADDBITS15
7764 | OPTS_TYPE_PT_UNICODE
7765 | OPTS_TYPE_ST_BASE64;
7766 kern_type = KERN_TYPE_SHA256_SLTPWU;
7767 dgst_size = DGST_SIZE_4_8;
7768 parse_func = episerver4_parse_hash;
7769 sort_by_digest = sort_by_digest_4_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_PREPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1450: hash_type = HASH_TYPE_SHA256;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_ST_ADD80;
7788 kern_type = KERN_TYPE_HMACSHA256_PW;
7789 dgst_size = DGST_SIZE_4_8;
7790 parse_func = hmacsha256_parse_hash;
7791 sort_by_digest = sort_by_digest_4_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_NOT_ITERATED;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 7;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 6;
7798 break;
7799
7800 case 1460: hash_type = HASH_TYPE_SHA256;
7801 salt_type = SALT_TYPE_INTERN;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_BE
7804 | OPTS_TYPE_PT_ADD80
7805 | OPTS_TYPE_PT_ADDBITS15;
7806 kern_type = KERN_TYPE_HMACSHA256_SLT;
7807 dgst_size = DGST_SIZE_4_8;
7808 parse_func = hmacsha256_parse_hash;
7809 sort_by_digest = sort_by_digest_4_8;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_NOT_ITERATED;
7812 dgst_pos0 = 3;
7813 dgst_pos1 = 7;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 6;
7816 break;
7817
7818 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7819 salt_type = SALT_TYPE_EMBEDDED;
7820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_LE
7822 | OPTS_TYPE_PT_BITSLICE;
7823 kern_type = KERN_TYPE_DESCRYPT;
7824 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7825 parse_func = descrypt_parse_hash;
7826 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7829 dgst_pos0 = 0;
7830 dgst_pos1 = 1;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 3;
7833 break;
7834
7835 case 1600: hash_type = HASH_TYPE_MD5;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7839 kern_type = KERN_TYPE_APR1CRYPT;
7840 dgst_size = DGST_SIZE_4_4;
7841 parse_func = md5apr1_parse_hash;
7842 sort_by_digest = sort_by_digest_4_4;
7843 opti_type = OPTI_TYPE_ZERO_BYTE;
7844 dgst_pos0 = 0;
7845 dgst_pos1 = 1;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 3;
7848 break;
7849
7850 case 1700: hash_type = HASH_TYPE_SHA512;
7851 salt_type = SALT_TYPE_NONE;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15;
7856 kern_type = KERN_TYPE_SHA512;
7857 dgst_size = DGST_SIZE_8_8;
7858 parse_func = sha512_parse_hash;
7859 sort_by_digest = sort_by_digest_8_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_PRECOMPUTE_INIT
7862 | OPTI_TYPE_PRECOMPUTE_MERKLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED
7865 | OPTI_TYPE_NOT_SALTED
7866 | OPTI_TYPE_USES_BITS_64
7867 | OPTI_TYPE_RAW_HASH;
7868 dgst_pos0 = 14;
7869 dgst_pos1 = 15;
7870 dgst_pos2 = 6;
7871 dgst_pos3 = 7;
7872 break;
7873
7874 case 1710: hash_type = HASH_TYPE_SHA512;
7875 salt_type = SALT_TYPE_INTERN;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_BE
7878 | OPTS_TYPE_ST_ADD80
7879 | OPTS_TYPE_ST_ADDBITS15;
7880 kern_type = KERN_TYPE_SHA512_PWSLT;
7881 dgst_size = DGST_SIZE_8_8;
7882 parse_func = sha512s_parse_hash;
7883 sort_by_digest = sort_by_digest_8_8;
7884 opti_type = OPTI_TYPE_ZERO_BYTE
7885 | OPTI_TYPE_PRECOMPUTE_INIT
7886 | OPTI_TYPE_PRECOMPUTE_MERKLE
7887 | OPTI_TYPE_EARLY_SKIP
7888 | OPTI_TYPE_NOT_ITERATED
7889 | OPTI_TYPE_APPENDED_SALT
7890 | OPTI_TYPE_USES_BITS_64
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 14;
7893 dgst_pos1 = 15;
7894 dgst_pos2 = 6;
7895 dgst_pos3 = 7;
7896 break;
7897
7898 case 1711: hash_type = HASH_TYPE_SHA512;
7899 salt_type = SALT_TYPE_EMBEDDED;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_BE
7902 | OPTS_TYPE_ST_ADD80
7903 | OPTS_TYPE_ST_ADDBITS15;
7904 kern_type = KERN_TYPE_SHA512_PWSLT;
7905 dgst_size = DGST_SIZE_8_8;
7906 parse_func = sha512b64s_parse_hash;
7907 sort_by_digest = sort_by_digest_8_8;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_APPENDED_SALT
7914 | OPTI_TYPE_USES_BITS_64
7915 | OPTI_TYPE_RAW_HASH;
7916 dgst_pos0 = 14;
7917 dgst_pos1 = 15;
7918 dgst_pos2 = 6;
7919 dgst_pos3 = 7;
7920 break;
7921
7922 case 1720: hash_type = HASH_TYPE_SHA512;
7923 salt_type = SALT_TYPE_INTERN;
7924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925 opts_type = OPTS_TYPE_PT_GENERATE_BE
7926 | OPTS_TYPE_PT_ADD80
7927 | OPTS_TYPE_PT_ADDBITS15;
7928 kern_type = KERN_TYPE_SHA512_SLTPW;
7929 dgst_size = DGST_SIZE_8_8;
7930 parse_func = sha512s_parse_hash;
7931 sort_by_digest = sort_by_digest_8_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_USES_BITS_64
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 14;
7941 dgst_pos1 = 15;
7942 dgst_pos2 = 6;
7943 dgst_pos3 = 7;
7944 break;
7945
7946 case 1722: hash_type = HASH_TYPE_SHA512;
7947 salt_type = SALT_TYPE_EMBEDDED;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_PT_ADD80
7951 | OPTS_TYPE_PT_ADDBITS15
7952 | OPTS_TYPE_ST_HEX;
7953 kern_type = KERN_TYPE_SHA512_SLTPW;
7954 dgst_size = DGST_SIZE_8_8;
7955 parse_func = osx512_parse_hash;
7956 sort_by_digest = sort_by_digest_8_8;
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_INIT
7959 | OPTI_TYPE_PRECOMPUTE_MERKLE
7960 | OPTI_TYPE_EARLY_SKIP
7961 | OPTI_TYPE_NOT_ITERATED
7962 | OPTI_TYPE_PREPENDED_SALT
7963 | OPTI_TYPE_USES_BITS_64
7964 | OPTI_TYPE_RAW_HASH;
7965 dgst_pos0 = 14;
7966 dgst_pos1 = 15;
7967 dgst_pos2 = 6;
7968 dgst_pos3 = 7;
7969 break;
7970
7971 case 1730: hash_type = HASH_TYPE_SHA512;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_BE
7975 | OPTS_TYPE_PT_UNICODE
7976 | OPTS_TYPE_ST_ADD80
7977 | OPTS_TYPE_ST_ADDBITS15;
7978 kern_type = KERN_TYPE_SHA512_PWSLTU;
7979 dgst_size = DGST_SIZE_8_8;
7980 parse_func = sha512s_parse_hash;
7981 sort_by_digest = sort_by_digest_8_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_APPENDED_SALT
7988 | OPTI_TYPE_USES_BITS_64
7989 | OPTI_TYPE_RAW_HASH;
7990 dgst_pos0 = 14;
7991 dgst_pos1 = 15;
7992 dgst_pos2 = 6;
7993 dgst_pos3 = 7;
7994 break;
7995
7996 case 1731: hash_type = HASH_TYPE_SHA512;
7997 salt_type = SALT_TYPE_EMBEDDED;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_BE
8000 | OPTS_TYPE_PT_UNICODE
8001 | OPTS_TYPE_ST_ADD80
8002 | OPTS_TYPE_ST_ADDBITS15
8003 | OPTS_TYPE_ST_HEX;
8004 kern_type = KERN_TYPE_SHA512_PWSLTU;
8005 dgst_size = DGST_SIZE_8_8;
8006 parse_func = mssql2012_parse_hash;
8007 sort_by_digest = sort_by_digest_8_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP
8012 | OPTI_TYPE_NOT_ITERATED
8013 | OPTI_TYPE_APPENDED_SALT
8014 | OPTI_TYPE_USES_BITS_64
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 14;
8017 dgst_pos1 = 15;
8018 dgst_pos2 = 6;
8019 dgst_pos3 = 7;
8020 break;
8021
8022 case 1740: hash_type = HASH_TYPE_SHA512;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS15
8028 | OPTS_TYPE_PT_UNICODE;
8029 kern_type = KERN_TYPE_SHA512_SLTPWU;
8030 dgst_size = DGST_SIZE_8_8;
8031 parse_func = sha512s_parse_hash;
8032 sort_by_digest = sort_by_digest_8_8;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_PREPENDED_SALT
8039 | OPTI_TYPE_USES_BITS_64
8040 | OPTI_TYPE_RAW_HASH;
8041 dgst_pos0 = 14;
8042 dgst_pos1 = 15;
8043 dgst_pos2 = 6;
8044 dgst_pos3 = 7;
8045 break;
8046
8047 case 1750: hash_type = HASH_TYPE_SHA512;
8048 salt_type = SALT_TYPE_INTERN;
8049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_BE
8051 | OPTS_TYPE_ST_ADD80;
8052 kern_type = KERN_TYPE_HMACSHA512_PW;
8053 dgst_size = DGST_SIZE_8_8;
8054 parse_func = hmacsha512_parse_hash;
8055 sort_by_digest = sort_by_digest_8_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_USES_BITS_64
8058 | OPTI_TYPE_NOT_ITERATED;
8059 dgst_pos0 = 14;
8060 dgst_pos1 = 15;
8061 dgst_pos2 = 6;
8062 dgst_pos3 = 7;
8063 break;
8064
8065 case 1760: hash_type = HASH_TYPE_SHA512;
8066 salt_type = SALT_TYPE_INTERN;
8067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8068 opts_type = OPTS_TYPE_PT_GENERATE_BE
8069 | OPTS_TYPE_PT_ADD80
8070 | OPTS_TYPE_PT_ADDBITS15;
8071 kern_type = KERN_TYPE_HMACSHA512_SLT;
8072 dgst_size = DGST_SIZE_8_8;
8073 parse_func = hmacsha512_parse_hash;
8074 sort_by_digest = sort_by_digest_8_8;
8075 opti_type = OPTI_TYPE_ZERO_BYTE
8076 | OPTI_TYPE_USES_BITS_64
8077 | OPTI_TYPE_NOT_ITERATED;
8078 dgst_pos0 = 14;
8079 dgst_pos1 = 15;
8080 dgst_pos2 = 6;
8081 dgst_pos3 = 7;
8082 break;
8083
8084 case 1800: hash_type = HASH_TYPE_SHA512;
8085 salt_type = SALT_TYPE_EMBEDDED;
8086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8087 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8088 kern_type = KERN_TYPE_SHA512CRYPT;
8089 dgst_size = DGST_SIZE_8_8;
8090 parse_func = sha512crypt_parse_hash;
8091 sort_by_digest = sort_by_digest_8_8;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_USES_BITS_64;
8094 dgst_pos0 = 0;
8095 dgst_pos1 = 1;
8096 dgst_pos2 = 2;
8097 dgst_pos3 = 3;
8098 break;
8099
8100 case 2100: hash_type = HASH_TYPE_DCC2;
8101 salt_type = SALT_TYPE_EMBEDDED;
8102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8104 | OPTS_TYPE_ST_LOWER
8105 | OPTS_TYPE_ST_UNICODE;
8106 kern_type = KERN_TYPE_DCC2;
8107 dgst_size = DGST_SIZE_4_4;
8108 parse_func = dcc2_parse_hash;
8109 sort_by_digest = sort_by_digest_4_4;
8110 opti_type = OPTI_TYPE_ZERO_BYTE;
8111 dgst_pos0 = 0;
8112 dgst_pos1 = 1;
8113 dgst_pos2 = 2;
8114 dgst_pos3 = 3;
8115 break;
8116
8117 case 2400: hash_type = HASH_TYPE_MD5;
8118 salt_type = SALT_TYPE_NONE;
8119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8121 kern_type = KERN_TYPE_MD5PIX;
8122 dgst_size = DGST_SIZE_4_4;
8123 parse_func = md5pix_parse_hash;
8124 sort_by_digest = sort_by_digest_4_4;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_PRECOMPUTE_INIT
8127 | OPTI_TYPE_PRECOMPUTE_MERKLE
8128 | OPTI_TYPE_EARLY_SKIP
8129 | OPTI_TYPE_NOT_ITERATED
8130 | OPTI_TYPE_NOT_SALTED;
8131 dgst_pos0 = 0;
8132 dgst_pos1 = 3;
8133 dgst_pos2 = 2;
8134 dgst_pos3 = 1;
8135 break;
8136
8137 case 2410: hash_type = HASH_TYPE_MD5;
8138 salt_type = SALT_TYPE_INTERN;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8141 kern_type = KERN_TYPE_MD5ASA;
8142 dgst_size = DGST_SIZE_4_4;
8143 parse_func = md5asa_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 dgst_pos0 = 0;
8151 dgst_pos1 = 3;
8152 dgst_pos2 = 2;
8153 dgst_pos3 = 1;
8154 break;
8155
8156 case 2500: hash_type = HASH_TYPE_WPA;
8157 salt_type = SALT_TYPE_EMBEDDED;
8158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8160 kern_type = KERN_TYPE_WPA;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = wpa_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE;
8165 dgst_pos0 = 0;
8166 dgst_pos1 = 1;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 3;
8169 break;
8170
8171 case 2600: hash_type = HASH_TYPE_MD5;
8172 salt_type = SALT_TYPE_VIRTUAL;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_LE
8175 | OPTS_TYPE_PT_ADD80
8176 | OPTS_TYPE_PT_ADDBITS14
8177 | OPTS_TYPE_ST_ADD80;
8178 kern_type = KERN_TYPE_MD55_PWSLT1;
8179 dgst_size = DGST_SIZE_4_4;
8180 parse_func = md5md5_parse_hash;
8181 sort_by_digest = sort_by_digest_4_4;
8182 opti_type = OPTI_TYPE_ZERO_BYTE
8183 | OPTI_TYPE_PRECOMPUTE_INIT
8184 | OPTI_TYPE_PRECOMPUTE_MERKLE
8185 | OPTI_TYPE_EARLY_SKIP;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 3;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 1;
8190 break;
8191
8192 case 2611: hash_type = HASH_TYPE_MD5;
8193 salt_type = SALT_TYPE_INTERN;
8194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE
8196 | OPTS_TYPE_PT_ADD80
8197 | OPTS_TYPE_PT_ADDBITS14
8198 | OPTS_TYPE_ST_ADD80;
8199 kern_type = KERN_TYPE_MD55_PWSLT1;
8200 dgst_size = DGST_SIZE_4_4;
8201 parse_func = vb3_parse_hash;
8202 sort_by_digest = sort_by_digest_4_4;
8203 opti_type = OPTI_TYPE_ZERO_BYTE
8204 | OPTI_TYPE_PRECOMPUTE_INIT
8205 | OPTI_TYPE_PRECOMPUTE_MERKLE
8206 | OPTI_TYPE_EARLY_SKIP;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 2612: hash_type = HASH_TYPE_MD5;
8214 salt_type = SALT_TYPE_EMBEDDED;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE
8217 | OPTS_TYPE_PT_ADD80
8218 | OPTS_TYPE_PT_ADDBITS14
8219 | OPTS_TYPE_ST_ADD80
8220 | OPTS_TYPE_ST_HEX;
8221 kern_type = KERN_TYPE_MD55_PWSLT1;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = phps_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 3;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 1;
8233 break;
8234
8235 case 2711: hash_type = HASH_TYPE_MD5;
8236 salt_type = SALT_TYPE_INTERN;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE
8239 | OPTS_TYPE_PT_ADD80
8240 | OPTS_TYPE_PT_ADDBITS14
8241 | OPTS_TYPE_ST_ADD80;
8242 kern_type = KERN_TYPE_MD55_PWSLT2;
8243 dgst_size = DGST_SIZE_4_4;
8244 parse_func = vb30_parse_hash;
8245 sort_by_digest = sort_by_digest_4_4;
8246 opti_type = OPTI_TYPE_ZERO_BYTE
8247 | OPTI_TYPE_PRECOMPUTE_INIT
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 2811: hash_type = HASH_TYPE_MD5;
8256 salt_type = SALT_TYPE_INTERN;
8257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE
8259 | OPTS_TYPE_PT_ADD80
8260 | OPTS_TYPE_PT_ADDBITS14;
8261 kern_type = KERN_TYPE_MD55_SLTPW;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = ipb2_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_EARLY_SKIP;
8268 dgst_pos0 = 0;
8269 dgst_pos1 = 3;
8270 dgst_pos2 = 2;
8271 dgst_pos3 = 1;
8272 break;
8273
8274 case 3000: hash_type = HASH_TYPE_LM;
8275 salt_type = SALT_TYPE_NONE;
8276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_LE
8278 | OPTS_TYPE_PT_UPPER
8279 | OPTS_TYPE_PT_BITSLICE;
8280 kern_type = KERN_TYPE_LM;
8281 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8282 parse_func = lm_parse_hash;
8283 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8284 opti_type = OPTI_TYPE_ZERO_BYTE
8285 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 1;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 3;
8290 break;
8291
8292 case 3100: hash_type = HASH_TYPE_ORACLEH;
8293 salt_type = SALT_TYPE_INTERN;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE
8296 | OPTS_TYPE_PT_UPPER
8297 | OPTS_TYPE_ST_UPPER;
8298 kern_type = KERN_TYPE_ORACLEH;
8299 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8300 parse_func = oracleh_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8302 opti_type = OPTI_TYPE_ZERO_BYTE;
8303 dgst_pos0 = 0;
8304 dgst_pos1 = 1;
8305 dgst_pos2 = 2;
8306 dgst_pos3 = 3;
8307 break;
8308
8309 case 3200: hash_type = HASH_TYPE_BCRYPT;
8310 salt_type = SALT_TYPE_EMBEDDED;
8311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8312 opts_type = OPTS_TYPE_PT_GENERATE_LE
8313 | OPTS_TYPE_ST_GENERATE_LE;
8314 kern_type = KERN_TYPE_BCRYPT;
8315 dgst_size = DGST_SIZE_4_6;
8316 parse_func = bcrypt_parse_hash;
8317 sort_by_digest = sort_by_digest_4_6;
8318 opti_type = OPTI_TYPE_ZERO_BYTE;
8319 dgst_pos0 = 0;
8320 dgst_pos1 = 1;
8321 dgst_pos2 = 2;
8322 dgst_pos3 = 3;
8323 break;
8324
8325 case 3710: hash_type = HASH_TYPE_MD5;
8326 salt_type = SALT_TYPE_INTERN;
8327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8328 opts_type = OPTS_TYPE_PT_GENERATE_LE
8329 | OPTS_TYPE_PT_ADD80
8330 | OPTS_TYPE_PT_ADDBITS14;
8331 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8332 dgst_size = DGST_SIZE_4_4;
8333 parse_func = md5s_parse_hash;
8334 sort_by_digest = sort_by_digest_4_4;
8335 opti_type = OPTI_TYPE_ZERO_BYTE
8336 | OPTI_TYPE_PRECOMPUTE_INIT
8337 | OPTI_TYPE_PRECOMPUTE_MERKLE
8338 | OPTI_TYPE_EARLY_SKIP;
8339 dgst_pos0 = 0;
8340 dgst_pos1 = 3;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 1;
8343 break;
8344
8345 case 3711: hash_type = HASH_TYPE_MD5;
8346 salt_type = SALT_TYPE_EMBEDDED;
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 = mediawiki_b_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 3800: hash_type = HASH_TYPE_MD5;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_ST_ADDBITS14;
8370 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8371 dgst_size = DGST_SIZE_4_4;
8372 parse_func = md5s_parse_hash;
8373 sort_by_digest = sort_by_digest_4_4;
8374 opti_type = OPTI_TYPE_ZERO_BYTE
8375 | OPTI_TYPE_PRECOMPUTE_INIT
8376 | OPTI_TYPE_PRECOMPUTE_MERKLE
8377 | OPTI_TYPE_EARLY_SKIP
8378 | OPTI_TYPE_NOT_ITERATED
8379 | OPTI_TYPE_RAW_HASH;
8380 dgst_pos0 = 0;
8381 dgst_pos1 = 3;
8382 dgst_pos2 = 2;
8383 dgst_pos3 = 1;
8384 break;
8385
8386 case 4300: hash_type = HASH_TYPE_MD5;
8387 salt_type = SALT_TYPE_VIRTUAL;
8388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8389 opts_type = OPTS_TYPE_PT_GENERATE_LE
8390 | OPTS_TYPE_PT_ADD80
8391 | OPTS_TYPE_PT_ADDBITS14
8392 | OPTS_TYPE_ST_ADD80;
8393 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8394 dgst_size = DGST_SIZE_4_4;
8395 parse_func = md5md5_parse_hash;
8396 sort_by_digest = sort_by_digest_4_4;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_PRECOMPUTE_INIT
8399 | OPTI_TYPE_PRECOMPUTE_MERKLE
8400 | OPTI_TYPE_EARLY_SKIP;
8401 dgst_pos0 = 0;
8402 dgst_pos1 = 3;
8403 dgst_pos2 = 2;
8404 dgst_pos3 = 1;
8405 break;
8406
8407
8408 case 4400: hash_type = HASH_TYPE_MD5;
8409 salt_type = SALT_TYPE_NONE;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_BE
8412 | OPTS_TYPE_PT_ADD80
8413 | OPTS_TYPE_PT_ADDBITS15;
8414 kern_type = KERN_TYPE_MD5_SHA1;
8415 dgst_size = DGST_SIZE_4_4;
8416 parse_func = md5_parse_hash;
8417 sort_by_digest = sort_by_digest_4_4;
8418 opti_type = OPTI_TYPE_ZERO_BYTE
8419 | OPTI_TYPE_PRECOMPUTE_INIT
8420 | OPTI_TYPE_PRECOMPUTE_MERKLE
8421 | OPTI_TYPE_EARLY_SKIP
8422 | OPTI_TYPE_NOT_ITERATED
8423 | OPTI_TYPE_NOT_SALTED
8424 | OPTI_TYPE_RAW_HASH;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 3;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 1;
8429 break;
8430
8431 case 4500: hash_type = HASH_TYPE_SHA1;
8432 salt_type = SALT_TYPE_NONE;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_BE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS15;
8437 kern_type = KERN_TYPE_SHA11;
8438 dgst_size = DGST_SIZE_4_5;
8439 parse_func = sha1_parse_hash;
8440 sort_by_digest = sort_by_digest_4_5;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP
8445 | OPTI_TYPE_NOT_SALTED;
8446 dgst_pos0 = 3;
8447 dgst_pos1 = 4;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 1;
8450 break;
8451
8452 case 4700: hash_type = HASH_TYPE_SHA1;
8453 salt_type = SALT_TYPE_NONE;
8454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_LE
8456 | OPTS_TYPE_PT_ADD80
8457 | OPTS_TYPE_PT_ADDBITS14;
8458 kern_type = KERN_TYPE_SHA1_MD5;
8459 dgst_size = DGST_SIZE_4_5;
8460 parse_func = sha1_parse_hash;
8461 sort_by_digest = sort_by_digest_4_5;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP
8466 | OPTI_TYPE_NOT_ITERATED
8467 | OPTI_TYPE_NOT_SALTED
8468 | OPTI_TYPE_RAW_HASH;
8469 dgst_pos0 = 3;
8470 dgst_pos1 = 4;
8471 dgst_pos2 = 2;
8472 dgst_pos3 = 1;
8473 break;
8474
8475 case 4800: hash_type = HASH_TYPE_MD5;
8476 salt_type = SALT_TYPE_EMBEDDED;
8477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8478 opts_type = OPTS_TYPE_PT_GENERATE_LE
8479 | OPTS_TYPE_PT_ADDBITS14;
8480 kern_type = KERN_TYPE_MD5_CHAP;
8481 dgst_size = DGST_SIZE_4_4;
8482 parse_func = chap_parse_hash;
8483 sort_by_digest = sort_by_digest_4_4;
8484 opti_type = OPTI_TYPE_ZERO_BYTE
8485 | OPTI_TYPE_PRECOMPUTE_INIT
8486 | OPTI_TYPE_PRECOMPUTE_MERKLE
8487 | OPTI_TYPE_MEET_IN_MIDDLE
8488 | OPTI_TYPE_EARLY_SKIP
8489 | OPTI_TYPE_NOT_ITERATED
8490 | OPTI_TYPE_RAW_HASH;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 3;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 4900: hash_type = HASH_TYPE_SHA1;
8498 salt_type = SALT_TYPE_INTERN;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8501 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8502 dgst_size = DGST_SIZE_4_5;
8503 parse_func = sha1s_parse_hash;
8504 sort_by_digest = sort_by_digest_4_5;
8505 opti_type = OPTI_TYPE_ZERO_BYTE
8506 | OPTI_TYPE_PRECOMPUTE_INIT
8507 | OPTI_TYPE_PRECOMPUTE_MERKLE
8508 | OPTI_TYPE_EARLY_SKIP;
8509 dgst_pos0 = 3;
8510 dgst_pos1 = 4;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 1;
8513 break;
8514
8515 case 5000: hash_type = HASH_TYPE_KECCAK;
8516 salt_type = SALT_TYPE_EMBEDDED;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_LE
8519 | OPTS_TYPE_PT_ADD01;
8520 kern_type = KERN_TYPE_KECCAK;
8521 dgst_size = DGST_SIZE_8_25;
8522 parse_func = keccak_parse_hash;
8523 sort_by_digest = sort_by_digest_8_25;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_USES_BITS_64
8526 | OPTI_TYPE_RAW_HASH;
8527 dgst_pos0 = 2;
8528 dgst_pos1 = 3;
8529 dgst_pos2 = 4;
8530 dgst_pos3 = 5;
8531 break;
8532
8533 case 5100: hash_type = HASH_TYPE_MD5H;
8534 salt_type = SALT_TYPE_NONE;
8535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE
8537 | OPTS_TYPE_PT_ADD80
8538 | OPTS_TYPE_PT_ADDBITS14;
8539 kern_type = KERN_TYPE_MD5H;
8540 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8541 parse_func = md5half_parse_hash;
8542 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8543 opti_type = OPTI_TYPE_ZERO_BYTE
8544 | OPTI_TYPE_RAW_HASH;
8545 dgst_pos0 = 0;
8546 dgst_pos1 = 1;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 3;
8549 break;
8550
8551 case 5200: hash_type = HASH_TYPE_SHA256;
8552 salt_type = SALT_TYPE_EMBEDDED;
8553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8555 kern_type = KERN_TYPE_PSAFE3;
8556 dgst_size = DGST_SIZE_4_8;
8557 parse_func = psafe3_parse_hash;
8558 sort_by_digest = sort_by_digest_4_8;
8559 opti_type = OPTI_TYPE_ZERO_BYTE;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 1;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 3;
8564 break;
8565
8566 case 5300: hash_type = HASH_TYPE_MD5;
8567 salt_type = SALT_TYPE_EMBEDDED;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_ST_ADD80;
8571 kern_type = KERN_TYPE_IKEPSK_MD5;
8572 dgst_size = DGST_SIZE_4_4;
8573 parse_func = ikepsk_md5_parse_hash;
8574 sort_by_digest = sort_by_digest_4_4;
8575 opti_type = OPTI_TYPE_ZERO_BYTE;
8576 dgst_pos0 = 0;
8577 dgst_pos1 = 3;
8578 dgst_pos2 = 2;
8579 dgst_pos3 = 1;
8580 break;
8581
8582 case 5400: hash_type = HASH_TYPE_SHA1;
8583 salt_type = SALT_TYPE_EMBEDDED;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_BE
8586 | OPTS_TYPE_ST_ADD80;
8587 kern_type = KERN_TYPE_IKEPSK_SHA1;
8588 dgst_size = DGST_SIZE_4_5;
8589 parse_func = ikepsk_sha1_parse_hash;
8590 sort_by_digest = sort_by_digest_4_5;
8591 opti_type = OPTI_TYPE_ZERO_BYTE;
8592 dgst_pos0 = 3;
8593 dgst_pos1 = 4;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 1;
8596 break;
8597
8598 case 5500: hash_type = HASH_TYPE_NETNTLM;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_PT_ADD80
8603 | OPTS_TYPE_PT_ADDBITS14
8604 | OPTS_TYPE_PT_UNICODE
8605 | OPTS_TYPE_ST_HEX;
8606 kern_type = KERN_TYPE_NETNTLMv1;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = netntlmv1_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE
8611 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8612 dgst_pos0 = 0;
8613 dgst_pos1 = 1;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 3;
8616 break;
8617
8618 case 5600: hash_type = HASH_TYPE_MD5;
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 kern_type = KERN_TYPE_NETNTLMv2;
8626 dgst_size = DGST_SIZE_4_4;
8627 parse_func = netntlmv2_parse_hash;
8628 sort_by_digest = sort_by_digest_4_4;
8629 opti_type = OPTI_TYPE_ZERO_BYTE;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 3;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 1;
8634 break;
8635
8636 case 5700: hash_type = HASH_TYPE_SHA256;
8637 salt_type = SALT_TYPE_NONE;
8638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_BE
8640 | OPTS_TYPE_PT_ADD80
8641 | OPTS_TYPE_PT_ADDBITS15;
8642 kern_type = KERN_TYPE_SHA256;
8643 dgst_size = DGST_SIZE_4_8;
8644 parse_func = cisco4_parse_hash;
8645 sort_by_digest = sort_by_digest_4_8;
8646 opti_type = OPTI_TYPE_ZERO_BYTE
8647 | OPTI_TYPE_PRECOMPUTE_INIT
8648 | OPTI_TYPE_PRECOMPUTE_MERKLE
8649 | OPTI_TYPE_EARLY_SKIP
8650 | OPTI_TYPE_NOT_ITERATED
8651 | OPTI_TYPE_NOT_SALTED
8652 | OPTI_TYPE_RAW_HASH;
8653 dgst_pos0 = 3;
8654 dgst_pos1 = 7;
8655 dgst_pos2 = 2;
8656 dgst_pos3 = 6;
8657 break;
8658
8659 case 5800: hash_type = HASH_TYPE_SHA1;
8660 salt_type = SALT_TYPE_INTERN;
8661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8663 | OPTS_TYPE_ST_ADD80;
8664 kern_type = KERN_TYPE_ANDROIDPIN;
8665 dgst_size = DGST_SIZE_4_5;
8666 parse_func = androidpin_parse_hash;
8667 sort_by_digest = sort_by_digest_4_5;
8668 opti_type = OPTI_TYPE_ZERO_BYTE;
8669 dgst_pos0 = 0;
8670 dgst_pos1 = 1;
8671 dgst_pos2 = 2;
8672 dgst_pos3 = 3;
8673 break;
8674
8675 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8676 salt_type = SALT_TYPE_NONE;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_LE
8679 | OPTS_TYPE_PT_ADD80;
8680 kern_type = KERN_TYPE_RIPEMD160;
8681 dgst_size = DGST_SIZE_4_5;
8682 parse_func = ripemd160_parse_hash;
8683 sort_by_digest = sort_by_digest_4_5;
8684 opti_type = OPTI_TYPE_ZERO_BYTE;
8685 dgst_pos0 = 0;
8686 dgst_pos1 = 1;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 3;
8689 break;
8690
8691 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8692 salt_type = SALT_TYPE_NONE;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_BE
8695 | OPTS_TYPE_PT_ADD80;
8696 kern_type = KERN_TYPE_WHIRLPOOL;
8697 dgst_size = DGST_SIZE_4_16;
8698 parse_func = whirlpool_parse_hash;
8699 sort_by_digest = sort_by_digest_4_16;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8711 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8712 dgst_size = DGST_SIZE_4_5;
8713 parse_func = truecrypt_parse_hash_2k;
8714 sort_by_digest = sort_by_digest_4_5;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8726 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8727 dgst_size = DGST_SIZE_4_5;
8728 parse_func = truecrypt_parse_hash_2k;
8729 sort_by_digest = sort_by_digest_4_5;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8741 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8742 dgst_size = DGST_SIZE_4_5;
8743 parse_func = truecrypt_parse_hash_2k;
8744 sort_by_digest = sort_by_digest_4_5;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6221: hash_type = HASH_TYPE_SHA512;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8756 kern_type = KERN_TYPE_TCSHA512_XTS512;
8757 dgst_size = DGST_SIZE_8_8;
8758 parse_func = truecrypt_parse_hash_1k;
8759 sort_by_digest = sort_by_digest_8_8;
8760 opti_type = OPTI_TYPE_ZERO_BYTE
8761 | OPTI_TYPE_USES_BITS_64;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 1;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 3;
8766 break;
8767
8768 case 6222: hash_type = HASH_TYPE_SHA512;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8772 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8773 dgst_size = DGST_SIZE_8_8;
8774 parse_func = truecrypt_parse_hash_1k;
8775 sort_by_digest = sort_by_digest_8_8;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_USES_BITS_64;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 1;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 3;
8782 break;
8783
8784 case 6223: hash_type = HASH_TYPE_SHA512;
8785 salt_type = SALT_TYPE_EMBEDDED;
8786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8788 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8789 dgst_size = DGST_SIZE_8_8;
8790 parse_func = truecrypt_parse_hash_1k;
8791 sort_by_digest = sort_by_digest_8_8;
8792 opti_type = OPTI_TYPE_ZERO_BYTE
8793 | OPTI_TYPE_USES_BITS_64;
8794 dgst_pos0 = 0;
8795 dgst_pos1 = 1;
8796 dgst_pos2 = 2;
8797 dgst_pos3 = 3;
8798 break;
8799
8800 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8801 salt_type = SALT_TYPE_EMBEDDED;
8802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8804 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8805 dgst_size = DGST_SIZE_4_8;
8806 parse_func = truecrypt_parse_hash_1k;
8807 sort_by_digest = sort_by_digest_4_8;
8808 opti_type = OPTI_TYPE_ZERO_BYTE;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 1;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 3;
8813 break;
8814
8815 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8819 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8820 dgst_size = DGST_SIZE_4_8;
8821 parse_func = truecrypt_parse_hash_1k;
8822 sort_by_digest = sort_by_digest_4_8;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8834 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8835 dgst_size = DGST_SIZE_4_8;
8836 parse_func = truecrypt_parse_hash_1k;
8837 sort_by_digest = sort_by_digest_4_8;
8838 opti_type = OPTI_TYPE_ZERO_BYTE;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8849 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8850 dgst_size = DGST_SIZE_4_5;
8851 parse_func = truecrypt_parse_hash_1k;
8852 sort_by_digest = sort_by_digest_4_5;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8864 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8865 dgst_size = DGST_SIZE_4_5;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_4_5;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8879 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8880 dgst_size = DGST_SIZE_4_5;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_4_5;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6300: hash_type = HASH_TYPE_MD5;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8894 kern_type = KERN_TYPE_MD5AIX;
8895 dgst_size = DGST_SIZE_4_4;
8896 parse_func = md5aix_parse_hash;
8897 sort_by_digest = sort_by_digest_4_4;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6400: hash_type = HASH_TYPE_SHA256;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8909 kern_type = KERN_TYPE_SHA256AIX;
8910 dgst_size = DGST_SIZE_4_8;
8911 parse_func = sha256aix_parse_hash;
8912 sort_by_digest = sort_by_digest_4_8;
8913 opti_type = OPTI_TYPE_ZERO_BYTE;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6500: hash_type = HASH_TYPE_SHA512;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8924 kern_type = KERN_TYPE_SHA512AIX;
8925 dgst_size = DGST_SIZE_8_8;
8926 parse_func = sha512aix_parse_hash;
8927 sort_by_digest = sort_by_digest_8_8;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_USES_BITS_64;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6600: hash_type = HASH_TYPE_AES;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_AGILEKEY;
8941 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8942 parse_func = agilekey_parse_hash;
8943 sort_by_digest = sort_by_digest_4_5;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6700: hash_type = HASH_TYPE_SHA1;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8955 kern_type = KERN_TYPE_SHA1AIX;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = sha1aix_parse_hash;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6800: hash_type = HASH_TYPE_AES;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_LASTPASS;
8971 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8972 parse_func = lastpass_parse_hash;
8973 sort_by_digest = sort_by_digest_4_8;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6900: hash_type = HASH_TYPE_GOST;
8982 salt_type = SALT_TYPE_NONE;
8983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_GOST;
8986 dgst_size = DGST_SIZE_4_8;
8987 parse_func = gost_parse_hash;
8988 sort_by_digest = sort_by_digest_4_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 7100: hash_type = HASH_TYPE_SHA512;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9000 kern_type = KERN_TYPE_PBKDF2_SHA512;
9001 dgst_size = DGST_SIZE_8_16;
9002 parse_func = sha512osx_parse_hash;
9003 sort_by_digest = sort_by_digest_8_16;
9004 opti_type = OPTI_TYPE_ZERO_BYTE
9005 | OPTI_TYPE_USES_BITS_64;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 7200: hash_type = HASH_TYPE_SHA512;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9016 kern_type = KERN_TYPE_PBKDF2_SHA512;
9017 dgst_size = DGST_SIZE_8_16;
9018 parse_func = sha512grub_parse_hash;
9019 sort_by_digest = sort_by_digest_8_16;
9020 opti_type = OPTI_TYPE_ZERO_BYTE
9021 | OPTI_TYPE_USES_BITS_64;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 7300: hash_type = HASH_TYPE_SHA1;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_BE
9032 | OPTS_TYPE_ST_ADD80
9033 | OPTS_TYPE_ST_ADDBITS15;
9034 kern_type = KERN_TYPE_RAKP;
9035 dgst_size = DGST_SIZE_4_5;
9036 parse_func = rakp_parse_hash;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE
9039 | OPTI_TYPE_NOT_ITERATED;
9040 dgst_pos0 = 3;
9041 dgst_pos1 = 4;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 1;
9044 break;
9045
9046 case 7400: hash_type = HASH_TYPE_SHA256;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_SHA256CRYPT;
9051 dgst_size = DGST_SIZE_4_8;
9052 parse_func = sha256crypt_parse_hash;
9053 sort_by_digest = sort_by_digest_4_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 7500: hash_type = HASH_TYPE_KRB5PA;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9065 kern_type = KERN_TYPE_KRB5PA;
9066 dgst_size = DGST_SIZE_4_4;
9067 parse_func = krb5pa_parse_hash;
9068 sort_by_digest = sort_by_digest_4_4;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_NOT_ITERATED;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 7600: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_INTERN;
9079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_BE
9081 | OPTS_TYPE_PT_ADD80
9082 | OPTS_TYPE_PT_ADDBITS15;
9083 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = redmine_parse_hash;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_PRECOMPUTE_INIT
9089 | OPTI_TYPE_EARLY_SKIP
9090 | OPTI_TYPE_NOT_ITERATED
9091 | OPTI_TYPE_PREPENDED_SALT;
9092 dgst_pos0 = 3;
9093 dgst_pos1 = 4;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 1;
9096 break;
9097
9098 case 7700: hash_type = HASH_TYPE_SAPB;
9099 salt_type = SALT_TYPE_EMBEDDED;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE
9102 | OPTS_TYPE_PT_UPPER
9103 | OPTS_TYPE_ST_UPPER;
9104 kern_type = KERN_TYPE_SAPB;
9105 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9106 parse_func = sapb_parse_hash;
9107 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_NOT_ITERATED;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 7800: hash_type = HASH_TYPE_SAPG;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_BE
9121 | OPTS_TYPE_ST_ADD80
9122 | OPTS_TYPE_ST_UPPER;
9123 kern_type = KERN_TYPE_SAPG;
9124 dgst_size = DGST_SIZE_4_5;
9125 parse_func = sapg_parse_hash;
9126 sort_by_digest = sort_by_digest_4_5;
9127 opti_type = OPTI_TYPE_ZERO_BYTE
9128 | OPTI_TYPE_PRECOMPUTE_INIT
9129 | OPTI_TYPE_NOT_ITERATED;
9130 dgst_pos0 = 3;
9131 dgst_pos1 = 4;
9132 dgst_pos2 = 2;
9133 dgst_pos3 = 1;
9134 break;
9135
9136 case 7900: hash_type = HASH_TYPE_SHA512;
9137 salt_type = SALT_TYPE_EMBEDDED;
9138 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9139 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9140 kern_type = KERN_TYPE_DRUPAL7;
9141 dgst_size = DGST_SIZE_8_8;
9142 parse_func = drupal7_parse_hash;
9143 sort_by_digest = sort_by_digest_8_8;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_USES_BITS_64;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 8000: hash_type = HASH_TYPE_SHA256;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_BE
9156 | OPTS_TYPE_PT_UNICODE
9157 | OPTS_TYPE_ST_ADD80
9158 | OPTS_TYPE_ST_HEX;
9159 kern_type = KERN_TYPE_SYBASEASE;
9160 dgst_size = DGST_SIZE_4_8;
9161 parse_func = sybasease_parse_hash;
9162 sort_by_digest = sort_by_digest_4_8;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_PRECOMPUTE_INIT
9165 | OPTI_TYPE_EARLY_SKIP
9166 | OPTI_TYPE_NOT_ITERATED
9167 | OPTI_TYPE_RAW_HASH;
9168 dgst_pos0 = 3;
9169 dgst_pos1 = 7;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 6;
9172 break;
9173
9174 case 8100: hash_type = HASH_TYPE_SHA1;
9175 salt_type = SALT_TYPE_EMBEDDED;
9176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9178 kern_type = KERN_TYPE_NETSCALER;
9179 dgst_size = DGST_SIZE_4_5;
9180 parse_func = netscaler_parse_hash;
9181 sort_by_digest = sort_by_digest_4_5;
9182 opti_type = OPTI_TYPE_ZERO_BYTE
9183 | OPTI_TYPE_PRECOMPUTE_INIT
9184 | OPTI_TYPE_PRECOMPUTE_MERKLE
9185 | OPTI_TYPE_EARLY_SKIP
9186 | OPTI_TYPE_NOT_ITERATED
9187 | OPTI_TYPE_PREPENDED_SALT
9188 | OPTI_TYPE_RAW_HASH;
9189 dgst_pos0 = 3;
9190 dgst_pos1 = 4;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 1;
9193 break;
9194
9195 case 8200: hash_type = HASH_TYPE_SHA256;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9199 kern_type = KERN_TYPE_CLOUDKEY;
9200 dgst_size = DGST_SIZE_4_8;
9201 parse_func = cloudkey_parse_hash;
9202 sort_by_digest = sort_by_digest_4_8;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 8300: hash_type = HASH_TYPE_SHA1;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE
9214 | OPTS_TYPE_ST_HEX
9215 | OPTS_TYPE_ST_ADD80;
9216 kern_type = KERN_TYPE_NSEC3;
9217 dgst_size = DGST_SIZE_4_5;
9218 parse_func = nsec3_parse_hash;
9219 sort_by_digest = sort_by_digest_4_5;
9220 opti_type = OPTI_TYPE_ZERO_BYTE;
9221 dgst_pos0 = 3;
9222 dgst_pos1 = 4;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 1;
9225 break;
9226
9227 case 8400: hash_type = HASH_TYPE_SHA1;
9228 salt_type = SALT_TYPE_INTERN;
9229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_BE
9231 | OPTS_TYPE_PT_ADD80
9232 | OPTS_TYPE_PT_ADDBITS15;
9233 kern_type = KERN_TYPE_WBB3;
9234 dgst_size = DGST_SIZE_4_5;
9235 parse_func = wbb3_parse_hash;
9236 sort_by_digest = sort_by_digest_4_5;
9237 opti_type = OPTI_TYPE_ZERO_BYTE
9238 | OPTI_TYPE_PRECOMPUTE_INIT
9239 | OPTI_TYPE_NOT_ITERATED;
9240 dgst_pos0 = 3;
9241 dgst_pos1 = 4;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 1;
9244 break;
9245
9246 case 8500: hash_type = HASH_TYPE_DESRACF;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE
9250 | OPTS_TYPE_ST_UPPER;
9251 kern_type = KERN_TYPE_RACF;
9252 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9253 parse_func = racf_parse_hash;
9254 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9255 opti_type = OPTI_TYPE_ZERO_BYTE
9256 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 8600: hash_type = HASH_TYPE_LOTUS5;
9264 salt_type = SALT_TYPE_NONE;
9265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9267 kern_type = KERN_TYPE_LOTUS5;
9268 dgst_size = DGST_SIZE_4_4;
9269 parse_func = lotus5_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4;
9271 opti_type = OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_NOT_SALTED
9274 | OPTI_TYPE_RAW_HASH;
9275 dgst_pos0 = 0;
9276 dgst_pos1 = 1;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 3;
9279 break;
9280
9281 case 8700: hash_type = HASH_TYPE_LOTUS6;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9285 kern_type = KERN_TYPE_LOTUS6;
9286 dgst_size = DGST_SIZE_4_4;
9287 parse_func = lotus6_parse_hash;
9288 sort_by_digest = sort_by_digest_4_4;
9289 opti_type = OPTI_TYPE_EARLY_SKIP
9290 | OPTI_TYPE_NOT_ITERATED
9291 | OPTI_TYPE_RAW_HASH;
9292 dgst_pos0 = 0;
9293 dgst_pos1 = 1;
9294 dgst_pos2 = 2;
9295 dgst_pos3 = 3;
9296 break;
9297
9298 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9299 salt_type = SALT_TYPE_EMBEDDED;
9300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9302 kern_type = KERN_TYPE_ANDROIDFDE;
9303 dgst_size = DGST_SIZE_4_4;
9304 parse_func = androidfde_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4;
9306 opti_type = OPTI_TYPE_ZERO_BYTE;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 8900: hash_type = HASH_TYPE_SCRYPT;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9317 kern_type = KERN_TYPE_SCRYPT;
9318 dgst_size = DGST_SIZE_4_8;
9319 parse_func = scrypt_parse_hash;
9320 sort_by_digest = sort_by_digest_4_8;
9321 opti_type = OPTI_TYPE_ZERO_BYTE;
9322 dgst_pos0 = 0;
9323 dgst_pos1 = 1;
9324 dgst_pos2 = 2;
9325 dgst_pos3 = 3;
9326 break;
9327
9328 case 9000: hash_type = HASH_TYPE_SHA1;
9329 salt_type = SALT_TYPE_EMBEDDED;
9330 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9331 opts_type = OPTS_TYPE_PT_GENERATE_LE
9332 | OPTS_TYPE_ST_GENERATE_LE;
9333 kern_type = KERN_TYPE_PSAFE2;
9334 dgst_size = DGST_SIZE_4_5;
9335 parse_func = psafe2_parse_hash;
9336 sort_by_digest = sort_by_digest_4_5;
9337 opti_type = OPTI_TYPE_ZERO_BYTE;
9338 dgst_pos0 = 0;
9339 dgst_pos1 = 1;
9340 dgst_pos2 = 2;
9341 dgst_pos3 = 3;
9342 break;
9343
9344 case 9100: hash_type = HASH_TYPE_LOTUS8;
9345 salt_type = SALT_TYPE_EMBEDDED;
9346 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9347 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9348 kern_type = KERN_TYPE_LOTUS8;
9349 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9350 parse_func = lotus8_parse_hash;
9351 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9352 opti_type = OPTI_TYPE_ZERO_BYTE;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 9200: hash_type = HASH_TYPE_SHA256;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9363 kern_type = KERN_TYPE_PBKDF2_SHA256;
9364 dgst_size = DGST_SIZE_4_32;
9365 parse_func = cisco8_parse_hash;
9366 sort_by_digest = sort_by_digest_4_32;
9367 opti_type = OPTI_TYPE_ZERO_BYTE;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 9300: hash_type = HASH_TYPE_SCRYPT;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9378 kern_type = KERN_TYPE_SCRYPT;
9379 dgst_size = DGST_SIZE_4_8;
9380 parse_func = cisco9_parse_hash;
9381 sort_by_digest = sort_by_digest_4_8;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_OFFICE2007;
9394 dgst_size = DGST_SIZE_4_4;
9395 parse_func = office2007_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_OFFICE2010;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = office2010_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_OFFICE2013;
9424 dgst_size = DGST_SIZE_4_4;
9425 parse_func = office2013_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE
9438 | OPTS_TYPE_PT_ADD80
9439 | OPTS_TYPE_PT_UNICODE;
9440 kern_type = KERN_TYPE_OLDOFFICE01;
9441 dgst_size = DGST_SIZE_4_4;
9442 parse_func = oldoffice01_parse_hash;
9443 sort_by_digest = sort_by_digest_4_4;
9444 opti_type = OPTI_TYPE_ZERO_BYTE
9445 | OPTI_TYPE_PRECOMPUTE_INIT
9446 | OPTI_TYPE_NOT_ITERATED;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE
9457 | OPTS_TYPE_PT_ADD80;
9458 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9459 dgst_size = DGST_SIZE_4_4;
9460 parse_func = oldoffice01cm1_parse_hash;
9461 sort_by_digest = sort_by_digest_4_4;
9462 opti_type = OPTI_TYPE_ZERO_BYTE
9463 | OPTI_TYPE_PRECOMPUTE_INIT
9464 | OPTI_TYPE_NOT_ITERATED;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE
9475 | OPTS_TYPE_PT_ADD80
9476 | OPTS_TYPE_PT_UNICODE
9477 | OPTS_TYPE_PT_NEVERCRACK;
9478 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9479 dgst_size = DGST_SIZE_4_4;
9480 parse_func = oldoffice01cm2_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 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_BE
9495 | OPTS_TYPE_PT_ADD80
9496 | OPTS_TYPE_PT_UNICODE;
9497 kern_type = KERN_TYPE_OLDOFFICE34;
9498 dgst_size = DGST_SIZE_4_4;
9499 parse_func = oldoffice34_parse_hash;
9500 sort_by_digest = sort_by_digest_4_4;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_PRECOMPUTE_INIT
9503 | OPTI_TYPE_NOT_ITERATED;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = oldoffice34cm1_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE
9519 | OPTI_TYPE_PRECOMPUTE_INIT
9520 | OPTI_TYPE_NOT_ITERATED;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_BE
9531 | OPTS_TYPE_PT_ADD80
9532 | OPTS_TYPE_PT_UNICODE
9533 | OPTS_TYPE_PT_NEVERCRACK;
9534 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = oldoffice34cm2_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 9900: hash_type = HASH_TYPE_MD5;
9548 salt_type = SALT_TYPE_NONE;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9551 kern_type = KERN_TYPE_RADMIN2;
9552 dgst_size = DGST_SIZE_4_4;
9553 parse_func = radmin2_parse_hash;
9554 sort_by_digest = sort_by_digest_4_4;
9555 opti_type = OPTI_TYPE_ZERO_BYTE
9556 | OPTI_TYPE_PRECOMPUTE_INIT
9557 | OPTI_TYPE_EARLY_SKIP
9558 | OPTI_TYPE_NOT_ITERATED
9559 | OPTI_TYPE_NOT_SALTED;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 3;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 1;
9564 break;
9565
9566 case 10000: hash_type = HASH_TYPE_SHA256;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9570 kern_type = KERN_TYPE_PBKDF2_SHA256;
9571 dgst_size = DGST_SIZE_4_32;
9572 parse_func = djangopbkdf2_parse_hash;
9573 sort_by_digest = sort_by_digest_4_32;
9574 opti_type = OPTI_TYPE_ZERO_BYTE;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 1;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 3;
9579 break;
9580
9581 case 10100: hash_type = HASH_TYPE_SIPHASH;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9585 kern_type = KERN_TYPE_SIPHASH;
9586 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9587 parse_func = siphash_parse_hash;
9588 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9589 opti_type = OPTI_TYPE_ZERO_BYTE
9590 | OPTI_TYPE_NOT_ITERATED
9591 | OPTI_TYPE_RAW_HASH;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 10200: hash_type = HASH_TYPE_MD5;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_LE
9602 | OPTS_TYPE_ST_ADD80
9603 | OPTS_TYPE_ST_ADDBITS14;
9604 kern_type = KERN_TYPE_HMACMD5_PW;
9605 dgst_size = DGST_SIZE_4_4;
9606 parse_func = crammd5_parse_hash;
9607 sort_by_digest = sort_by_digest_4_4;
9608 opti_type = OPTI_TYPE_ZERO_BYTE
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 3;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 1;
9614 break;
9615
9616 case 10300: hash_type = HASH_TYPE_SHA1;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9620 kern_type = KERN_TYPE_SAPH_SHA1;
9621 dgst_size = DGST_SIZE_4_5;
9622 parse_func = saph_sha1_parse_hash;
9623 sort_by_digest = sort_by_digest_4_5;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 10400: hash_type = HASH_TYPE_PDFU16;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9635 kern_type = KERN_TYPE_PDF11;
9636 dgst_size = DGST_SIZE_4_4;
9637 parse_func = pdf11_parse_hash;
9638 sort_by_digest = sort_by_digest_4_4;
9639 opti_type = OPTI_TYPE_ZERO_BYTE
9640 | OPTI_TYPE_NOT_ITERATED;
9641 dgst_pos0 = 0;
9642 dgst_pos1 = 1;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 3;
9645 break;
9646
9647 case 10410: hash_type = HASH_TYPE_PDFU16;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9651 kern_type = KERN_TYPE_PDF11CM1;
9652 dgst_size = DGST_SIZE_4_4;
9653 parse_func = pdf11cm1_parse_hash;
9654 sort_by_digest = sort_by_digest_4_4;
9655 opti_type = OPTI_TYPE_ZERO_BYTE
9656 | OPTI_TYPE_NOT_ITERATED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 10420: hash_type = HASH_TYPE_PDFU16;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_PDF11CM2;
9668 dgst_size = DGST_SIZE_4_4;
9669 parse_func = pdf11cm2_parse_hash;
9670 sort_by_digest = sort_by_digest_4_4;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_NOT_ITERATED;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 10500: hash_type = HASH_TYPE_PDFU16;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9683 kern_type = KERN_TYPE_PDF14;
9684 dgst_size = DGST_SIZE_4_4;
9685 parse_func = pdf14_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4;
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_NOT_ITERATED;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 1;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 3;
9693 break;
9694
9695 case 10600: hash_type = HASH_TYPE_SHA256;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_BE
9699 | OPTS_TYPE_ST_ADD80
9700 | OPTS_TYPE_ST_ADDBITS15
9701 | OPTS_TYPE_HASH_COPY;
9702 kern_type = KERN_TYPE_SHA256_PWSLT;
9703 dgst_size = DGST_SIZE_4_8;
9704 parse_func = pdf17l3_parse_hash;
9705 sort_by_digest = sort_by_digest_4_8;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_PRECOMPUTE_INIT
9708 | OPTI_TYPE_PRECOMPUTE_MERKLE
9709 | OPTI_TYPE_EARLY_SKIP
9710 | OPTI_TYPE_NOT_ITERATED
9711 | OPTI_TYPE_APPENDED_SALT
9712 | OPTI_TYPE_RAW_HASH;
9713 dgst_pos0 = 3;
9714 dgst_pos1 = 7;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 6;
9717 break;
9718
9719 case 10700: hash_type = HASH_TYPE_PDFU32;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE
9723 | OPTS_TYPE_HASH_COPY;
9724 kern_type = KERN_TYPE_PDF17L8;
9725 dgst_size = DGST_SIZE_4_8;
9726 parse_func = pdf17l8_parse_hash;
9727 sort_by_digest = sort_by_digest_4_8;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_NOT_ITERATED;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 10800: hash_type = HASH_TYPE_SHA384;
9737 salt_type = SALT_TYPE_NONE;
9738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_BE
9740 | OPTS_TYPE_PT_ADD80
9741 | OPTS_TYPE_PT_ADDBITS15;
9742 kern_type = KERN_TYPE_SHA384;
9743 dgst_size = DGST_SIZE_8_8;
9744 parse_func = sha384_parse_hash;
9745 sort_by_digest = sort_by_digest_8_8;
9746 opti_type = OPTI_TYPE_ZERO_BYTE
9747 | OPTI_TYPE_PRECOMPUTE_INIT
9748 | OPTI_TYPE_PRECOMPUTE_MERKLE
9749 | OPTI_TYPE_EARLY_SKIP
9750 | OPTI_TYPE_NOT_ITERATED
9751 | OPTI_TYPE_NOT_SALTED
9752 | OPTI_TYPE_USES_BITS_64
9753 | OPTI_TYPE_RAW_HASH;
9754 dgst_pos0 = 6;
9755 dgst_pos1 = 7;
9756 dgst_pos2 = 4;
9757 dgst_pos3 = 5;
9758 break;
9759
9760 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9761 salt_type = SALT_TYPE_EMBEDDED;
9762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9763 opts_type = OPTS_TYPE_PT_GENERATE_LE
9764 | OPTS_TYPE_ST_BASE64
9765 | OPTS_TYPE_HASH_COPY;
9766 kern_type = KERN_TYPE_PBKDF2_SHA256;
9767 dgst_size = DGST_SIZE_4_32;
9768 parse_func = pbkdf2_sha256_parse_hash;
9769 sort_by_digest = sort_by_digest_4_32;
9770 opti_type = OPTI_TYPE_ZERO_BYTE;
9771 dgst_pos0 = 0;
9772 dgst_pos1 = 1;
9773 dgst_pos2 = 2;
9774 dgst_pos3 = 3;
9775 break;
9776
9777 case 11000: hash_type = HASH_TYPE_MD5;
9778 salt_type = SALT_TYPE_INTERN;
9779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE
9781 | OPTS_TYPE_PT_ADD80;
9782 kern_type = KERN_TYPE_PRESTASHOP;
9783 dgst_size = DGST_SIZE_4_4;
9784 parse_func = prestashop_parse_hash;
9785 sort_by_digest = sort_by_digest_4_4;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_PRECOMPUTE_INIT
9788 | OPTI_TYPE_NOT_ITERATED
9789 | OPTI_TYPE_PREPENDED_SALT;
9790 dgst_pos0 = 0;
9791 dgst_pos1 = 3;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 1;
9794 break;
9795
9796 case 11100: hash_type = HASH_TYPE_MD5;
9797 salt_type = SALT_TYPE_EMBEDDED;
9798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_LE
9800 | OPTS_TYPE_ST_ADD80;
9801 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9802 dgst_size = DGST_SIZE_4_4;
9803 parse_func = postgresql_auth_parse_hash;
9804 sort_by_digest = sort_by_digest_4_4;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_PRECOMPUTE_INIT
9807 | OPTI_TYPE_PRECOMPUTE_MERKLE
9808 | OPTI_TYPE_EARLY_SKIP;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 3;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 1;
9813 break;
9814
9815 case 11200: hash_type = HASH_TYPE_SHA1;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_BE
9819 | OPTS_TYPE_PT_ADD80
9820 | OPTS_TYPE_ST_HEX;
9821 kern_type = KERN_TYPE_MYSQL_AUTH;
9822 dgst_size = DGST_SIZE_4_5;
9823 parse_func = mysql_auth_parse_hash;
9824 sort_by_digest = sort_by_digest_4_5;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_EARLY_SKIP;
9827 dgst_pos0 = 3;
9828 dgst_pos1 = 4;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 1;
9831 break;
9832
9833 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9834 salt_type = SALT_TYPE_EMBEDDED;
9835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_ST_HEX
9838 | OPTS_TYPE_ST_ADD80;
9839 kern_type = KERN_TYPE_BITCOIN_WALLET;
9840 dgst_size = DGST_SIZE_4_4;
9841 parse_func = bitcoin_wallet_parse_hash;
9842 sort_by_digest = sort_by_digest_4_4;
9843 opti_type = OPTI_TYPE_ZERO_BYTE;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 11400: hash_type = HASH_TYPE_MD5;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE
9854 | OPTS_TYPE_PT_ADD80
9855 | OPTS_TYPE_HASH_COPY;
9856 kern_type = KERN_TYPE_SIP_AUTH;
9857 dgst_size = DGST_SIZE_4_4;
9858 parse_func = sip_auth_parse_hash;
9859 sort_by_digest = sort_by_digest_4_4;
9860 opti_type = OPTI_TYPE_ZERO_BYTE;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 3;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 1;
9865 break;
9866
9867 case 11500: hash_type = HASH_TYPE_CRC32;
9868 salt_type = SALT_TYPE_INTERN;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE
9871 | OPTS_TYPE_ST_GENERATE_LE
9872 | OPTS_TYPE_ST_HEX;
9873 kern_type = KERN_TYPE_CRC32;
9874 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9875 parse_func = crc32_parse_hash;
9876 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9877 opti_type = OPTI_TYPE_ZERO_BYTE;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 1;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 3;
9882 break;
9883
9884 case 11600: hash_type = HASH_TYPE_AES;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE
9888 | OPTS_TYPE_PT_NEVERCRACK;
9889 kern_type = KERN_TYPE_SEVEN_ZIP;
9890 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9891 parse_func = seven_zip_parse_hash;
9892 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9893 opti_type = OPTI_TYPE_ZERO_BYTE;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9901 salt_type = SALT_TYPE_NONE;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE
9904 | OPTS_TYPE_PT_ADD01;
9905 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9906 dgst_size = DGST_SIZE_4_8;
9907 parse_func = gost2012sbog_256_parse_hash;
9908 sort_by_digest = sort_by_digest_4_8;
9909 opti_type = OPTI_TYPE_ZERO_BYTE;
9910 dgst_pos0 = 0;
9911 dgst_pos1 = 1;
9912 dgst_pos2 = 2;
9913 dgst_pos3 = 3;
9914 break;
9915
9916 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9917 salt_type = SALT_TYPE_NONE;
9918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9919 opts_type = OPTS_TYPE_PT_GENERATE_LE
9920 | OPTS_TYPE_PT_ADD01;
9921 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9922 dgst_size = DGST_SIZE_4_16;
9923 parse_func = gost2012sbog_512_parse_hash;
9924 sort_by_digest = sort_by_digest_4_16;
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_BASE64
9937 | OPTS_TYPE_HASH_COPY;
9938 kern_type = KERN_TYPE_PBKDF2_MD5;
9939 dgst_size = DGST_SIZE_4_32;
9940 parse_func = pbkdf2_md5_parse_hash;
9941 sort_by_digest = sort_by_digest_4_32;
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_ST_BASE64
9954 | OPTS_TYPE_HASH_COPY;
9955 kern_type = KERN_TYPE_PBKDF2_SHA1;
9956 dgst_size = DGST_SIZE_4_32;
9957 parse_func = pbkdf2_sha1_parse_hash;
9958 sort_by_digest = sort_by_digest_4_32;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_ST_BASE64
9971 | OPTS_TYPE_HASH_COPY;
9972 kern_type = KERN_TYPE_PBKDF2_SHA512;
9973 dgst_size = DGST_SIZE_8_16;
9974 parse_func = pbkdf2_sha512_parse_hash;
9975 sort_by_digest = sort_by_digest_8_16;
9976 opti_type = OPTI_TYPE_ZERO_BYTE
9977 | OPTI_TYPE_USES_BITS_64;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9985 salt_type = SALT_TYPE_EMBEDDED;
9986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9988 kern_type = KERN_TYPE_ECRYPTFS;
9989 dgst_size = DGST_SIZE_8_8;
9990 parse_func = ecryptfs_parse_hash;
9991 sort_by_digest = sort_by_digest_8_8;
9992 opti_type = OPTI_TYPE_ZERO_BYTE
9993 | OPTI_TYPE_USES_BITS_64;
9994 dgst_pos0 = 0;
9995 dgst_pos1 = 1;
9996 dgst_pos2 = 2;
9997 dgst_pos3 = 3;
9998 break;
9999
10000 case 12300: hash_type = HASH_TYPE_ORACLET;
10001 salt_type = SALT_TYPE_EMBEDDED;
10002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10004 kern_type = KERN_TYPE_ORACLET;
10005 dgst_size = DGST_SIZE_8_16;
10006 parse_func = oraclet_parse_hash;
10007 sort_by_digest = sort_by_digest_8_16;
10008 opti_type = OPTI_TYPE_ZERO_BYTE
10009 | OPTI_TYPE_USES_BITS_64;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10020 kern_type = KERN_TYPE_BSDICRYPT;
10021 dgst_size = DGST_SIZE_4_4;
10022 parse_func = bsdicrypt_parse_hash;
10023 sort_by_digest = sort_by_digest_4_4;
10024 opti_type = OPTI_TYPE_ZERO_BYTE
10025 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 12500: hash_type = HASH_TYPE_RAR3HP;
10033 salt_type = SALT_TYPE_EMBEDDED;
10034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10036 kern_type = KERN_TYPE_RAR3;
10037 dgst_size = DGST_SIZE_4_4;
10038 parse_func = rar3hp_parse_hash;
10039 sort_by_digest = sort_by_digest_4_4;
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 12600: hash_type = HASH_TYPE_SHA256;
10048 salt_type = SALT_TYPE_INTERN;
10049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_BE
10051 | OPTS_TYPE_PT_ADD80;
10052 kern_type = KERN_TYPE_CF10;
10053 dgst_size = DGST_SIZE_4_8;
10054 parse_func = cf10_parse_hash;
10055 sort_by_digest = sort_by_digest_4_8;
10056 opti_type = OPTI_TYPE_ZERO_BYTE
10057 | OPTI_TYPE_PRECOMPUTE_INIT
10058 | OPTI_TYPE_EARLY_SKIP
10059 | OPTI_TYPE_NOT_ITERATED;
10060 dgst_pos0 = 3;
10061 dgst_pos1 = 7;
10062 dgst_pos2 = 2;
10063 dgst_pos3 = 6;
10064 break;
10065
10066 case 12700: hash_type = HASH_TYPE_AES;
10067 salt_type = SALT_TYPE_EMBEDDED;
10068 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10069 opts_type = OPTS_TYPE_PT_GENERATE_LE
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_MYWALLET;
10072 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10073 parse_func = mywallet_parse_hash;
10074 sort_by_digest = sort_by_digest_4_5;
10075 opti_type = OPTI_TYPE_ZERO_BYTE;
10076 dgst_pos0 = 0;
10077 dgst_pos1 = 1;
10078 dgst_pos2 = 2;
10079 dgst_pos3 = 3;
10080 break;
10081
10082 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10083 salt_type = SALT_TYPE_EMBEDDED;
10084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10086 kern_type = KERN_TYPE_MS_DRSR;
10087 dgst_size = DGST_SIZE_4_8;
10088 parse_func = ms_drsr_parse_hash;
10089 sort_by_digest = sort_by_digest_4_8;
10090 opti_type = OPTI_TYPE_ZERO_BYTE;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10101 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10102 dgst_size = DGST_SIZE_4_8;
10103 parse_func = androidfde_samsung_parse_hash;
10104 sort_by_digest = sort_by_digest_4_8;
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10116 kern_type = KERN_TYPE_RAR5;
10117 dgst_size = DGST_SIZE_4_4;
10118 parse_func = rar5_parse_hash;
10119 sort_by_digest = sort_by_digest_4_4;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 default: usage_mini_print (PROGNAME); return (-1);
10128 }
10129
10130 /**
10131 * transpose
10132 */
10133
10134 data.parse_func = parse_func;
10135
10136 /**
10137 * misc stuff
10138 */
10139
10140 if (hex_salt)
10141 {
10142 if (salt_type == SALT_TYPE_INTERN)
10143 {
10144 opts_type |= OPTS_TYPE_ST_HEX;
10145 }
10146 else
10147 {
10148 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10149
10150 return (-1);
10151 }
10152 }
10153
10154 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10155 | (salt_type == SALT_TYPE_EXTERN)
10156 | (salt_type == SALT_TYPE_EMBEDDED)
10157 | (salt_type == SALT_TYPE_VIRTUAL));
10158
10159 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10160
10161 data.hash_type = hash_type;
10162 data.attack_mode = attack_mode;
10163 data.attack_kern = attack_kern;
10164 data.attack_exec = attack_exec;
10165 data.kern_type = kern_type;
10166 data.opts_type = opts_type;
10167 data.dgst_size = dgst_size;
10168 data.salt_type = salt_type;
10169 data.isSalted = isSalted;
10170 data.sort_by_digest = sort_by_digest;
10171 data.dgst_pos0 = dgst_pos0;
10172 data.dgst_pos1 = dgst_pos1;
10173 data.dgst_pos2 = dgst_pos2;
10174 data.dgst_pos3 = dgst_pos3;
10175
10176 esalt_size = 0;
10177
10178 switch (hash_mode)
10179 {
10180 case 2500: esalt_size = sizeof (wpa_t); break;
10181 case 5300: esalt_size = sizeof (ikepsk_t); break;
10182 case 5400: esalt_size = sizeof (ikepsk_t); break;
10183 case 5500: esalt_size = sizeof (netntlm_t); break;
10184 case 5600: esalt_size = sizeof (netntlm_t); break;
10185 case 6211:
10186 case 6212:
10187 case 6213:
10188 case 6221:
10189 case 6222:
10190 case 6223:
10191 case 6231:
10192 case 6232:
10193 case 6233:
10194 case 6241:
10195 case 6242:
10196 case 6243: esalt_size = sizeof (tc_t); break;
10197 case 6600: esalt_size = sizeof (agilekey_t); break;
10198 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10199 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10200 case 7300: esalt_size = sizeof (rakp_t); break;
10201 case 7500: esalt_size = sizeof (krb5pa_t); break;
10202 case 8200: esalt_size = sizeof (cloudkey_t); break;
10203 case 8800: esalt_size = sizeof (androidfde_t); break;
10204 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10205 case 9400: esalt_size = sizeof (office2007_t); break;
10206 case 9500: esalt_size = sizeof (office2010_t); break;
10207 case 9600: esalt_size = sizeof (office2013_t); break;
10208 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10209 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10210 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10211 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10212 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10213 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10214 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10215 case 10200: esalt_size = sizeof (cram_md5_t); break;
10216 case 10400: esalt_size = sizeof (pdf_t); break;
10217 case 10410: esalt_size = sizeof (pdf_t); break;
10218 case 10420: esalt_size = sizeof (pdf_t); break;
10219 case 10500: esalt_size = sizeof (pdf_t); break;
10220 case 10600: esalt_size = sizeof (pdf_t); break;
10221 case 10700: esalt_size = sizeof (pdf_t); break;
10222 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10223 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10224 case 11400: esalt_size = sizeof (sip_t); break;
10225 case 11600: esalt_size = sizeof (seven_zip_t); break;
10226 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10227 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10228 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10229 case 13000: esalt_size = sizeof (rar5_t); break;
10230 }
10231
10232 data.esalt_size = esalt_size;
10233
10234 /**
10235 * choose dictionary parser
10236 */
10237
10238 if (hash_type == HASH_TYPE_LM)
10239 {
10240 get_next_word_func = get_next_word_lm;
10241 }
10242 else if (opts_type & OPTS_TYPE_PT_UPPER)
10243 {
10244 get_next_word_func = get_next_word_uc;
10245 }
10246 else
10247 {
10248 get_next_word_func = get_next_word_std;
10249 }
10250
10251 /**
10252 * dictstat
10253 */
10254
10255 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10256
10257 #ifdef _POSIX
10258 size_t dictstat_nmemb = 0;
10259 #endif
10260
10261 #ifdef _WIN
10262 uint dictstat_nmemb = 0;
10263 #endif
10264
10265 char dictstat[256] = { 0 };
10266
10267 FILE *dictstat_fp = NULL;
10268
10269 if (keyspace == 0)
10270 {
10271 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10272
10273 dictstat_fp = fopen (dictstat, "rb");
10274
10275 if (dictstat_fp)
10276 {
10277 #ifdef _POSIX
10278 struct stat tmpstat;
10279
10280 fstat (fileno (dictstat_fp), &tmpstat);
10281 #endif
10282
10283 #ifdef _WIN
10284 struct stat64 tmpstat;
10285
10286 _fstat64 (fileno (dictstat_fp), &tmpstat);
10287 #endif
10288
10289 if (tmpstat.st_mtime < COMPTIME)
10290 {
10291 /* with v0.15 the format changed so we have to ensure user is using a good version
10292 since there is no version-header in the dictstat file */
10293
10294 fclose (dictstat_fp);
10295
10296 unlink (dictstat);
10297 }
10298 else
10299 {
10300 while (!feof (dictstat_fp))
10301 {
10302 dictstat_t d;
10303
10304 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10305
10306 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10307
10308 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10309 {
10310 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10311
10312 return -1;
10313 }
10314 }
10315
10316 fclose (dictstat_fp);
10317 }
10318 }
10319 }
10320
10321 /**
10322 * potfile
10323 */
10324
10325 char potfile[256] = { 0 };
10326
10327 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10328
10329 data.pot_fp = NULL;
10330
10331 FILE *out_fp = NULL;
10332 FILE *pot_fp = NULL;
10333
10334 if (show == 1 || left == 1)
10335 {
10336 pot_fp = fopen (potfile, "rb");
10337
10338 if (pot_fp == NULL)
10339 {
10340 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10341
10342 return (-1);
10343 }
10344
10345 if (outfile != NULL)
10346 {
10347 if ((out_fp = fopen (outfile, "ab")) == NULL)
10348 {
10349 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10350
10351 fclose (pot_fp);
10352
10353 return (-1);
10354 }
10355 }
10356 else
10357 {
10358 out_fp = stdout;
10359 }
10360 }
10361 else
10362 {
10363 if (potfile_disable == 0)
10364 {
10365 pot_fp = fopen (potfile, "ab");
10366
10367 if (pot_fp == NULL)
10368 {
10369 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10370
10371 return (-1);
10372 }
10373
10374 data.pot_fp = pot_fp;
10375 }
10376 }
10377
10378 pot_t *pot = NULL;
10379
10380 uint pot_cnt = 0;
10381 uint pot_avail = 0;
10382
10383 if (show == 1 || left == 1)
10384 {
10385 SUPPRESS_OUTPUT = 1;
10386
10387 pot_avail = count_lines (pot_fp);
10388
10389 rewind (pot_fp);
10390
10391 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10392
10393 uint pot_hashes_avail = 0;
10394
10395 uint line_num = 0;
10396
10397 while (!feof (pot_fp))
10398 {
10399 line_num++;
10400
10401 char line_buf[BUFSIZ] = { 0 };
10402
10403 int line_len = fgetl (pot_fp, line_buf);
10404
10405 if (line_len == 0) continue;
10406
10407 char *plain_buf = line_buf + line_len;
10408
10409 pot_t *pot_ptr = &pot[pot_cnt];
10410
10411 hash_t *hashes_buf = &pot_ptr->hash;
10412
10413 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10414 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10415
10416 if (pot_cnt == pot_hashes_avail)
10417 {
10418 uint pos = 0;
10419
10420 for (pos = 0; pos < INCR_POT; pos++)
10421 {
10422 if ((pot_cnt + pos) >= pot_avail) break;
10423
10424 pot_t *tmp_pot = &pot[pot_cnt + pos];
10425
10426 hash_t *tmp_hash = &tmp_pot->hash;
10427
10428 tmp_hash->digest = mymalloc (dgst_size);
10429
10430 if (isSalted)
10431 {
10432 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10433 }
10434
10435 if (esalt_size)
10436 {
10437 tmp_hash->esalt = mymalloc (esalt_size);
10438 }
10439
10440 pot_hashes_avail++;
10441 }
10442 }
10443
10444 int plain_len = 0;
10445
10446 int parser_status;
10447
10448 int iter = MAX_CUT_TRIES;
10449
10450 do
10451 {
10452 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10453 {
10454 if (line_buf[i] == ':')
10455 {
10456 line_len--;
10457
10458 break;
10459 }
10460 }
10461
10462 if (data.hash_mode != 2500)
10463 {
10464 parser_status = parse_func (line_buf, line_len, hashes_buf);
10465 }
10466 else
10467 {
10468 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10469
10470 if (line_len > max_salt_size)
10471 {
10472 parser_status = PARSER_GLOBAL_LENGTH;
10473 }
10474 else
10475 {
10476 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10477
10478 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10479
10480 hashes_buf->salt->salt_len = line_len;
10481
10482 parser_status = PARSER_OK;
10483 }
10484 }
10485
10486 // if NOT parsed without error, we add the ":" to the plain
10487
10488 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10489 {
10490 plain_len++;
10491 plain_buf--;
10492 }
10493
10494 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10495
10496 if (parser_status < PARSER_GLOBAL_ZERO)
10497 {
10498 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10499
10500 continue;
10501 }
10502
10503 if (plain_len >= 255) continue;
10504
10505 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10506
10507 pot_ptr->plain_len = plain_len;
10508
10509 pot_cnt++;
10510 }
10511
10512 fclose (pot_fp);
10513
10514 SUPPRESS_OUTPUT = 0;
10515
10516 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10517 }
10518
10519 /**
10520 * word len
10521 */
10522
10523 uint pw_min = PW_MIN;
10524 uint pw_max = PW_MAX;
10525
10526 switch (hash_mode)
10527 {
10528 case 400: if (pw_max > 40) pw_max = 40;
10529 break;
10530 case 500: if (pw_max > 16) pw_max = 16;
10531 break;
10532 case 1500: if (pw_max > 8) pw_max = 8;
10533 break;
10534 case 1600: if (pw_max > 16) pw_max = 16;
10535 break;
10536 case 1800: if (pw_max > 16) pw_max = 16;
10537 break;
10538 case 2100: if (pw_max > 16) pw_max = 16;
10539 break;
10540 case 2500: if (pw_min < 8) pw_min = 8;
10541 break;
10542 case 3000: if (pw_max > 7) pw_max = 7;
10543 break;
10544 case 5200: if (pw_max > 24) pw_max = 24;
10545 break;
10546 case 5800: if (pw_max > 16) pw_max = 16;
10547 break;
10548 case 6300: if (pw_max > 16) pw_max = 16;
10549 break;
10550 case 7400: if (pw_max > 16) pw_max = 16;
10551 break;
10552 case 7900: if (pw_max > 48) pw_max = 48;
10553 break;
10554 case 8500: if (pw_max > 8) pw_max = 8;
10555 break;
10556 case 8600: if (pw_max > 16) pw_max = 16;
10557 break;
10558 case 9710: pw_min = 5;
10559 pw_max = 5;
10560 break;
10561 case 9810: pw_min = 5;
10562 pw_max = 5;
10563 break;
10564 case 10410: pw_min = 5;
10565 pw_max = 5;
10566 break;
10567 case 10300: if (pw_max < 3) pw_min = 3;
10568 if (pw_max > 40) pw_max = 40;
10569 break;
10570 case 10500: if (pw_max < 3) pw_min = 3;
10571 if (pw_max > 40) pw_max = 40;
10572 break;
10573 case 10700: if (pw_max > 16) pw_max = 16;
10574 break;
10575 case 11300: if (pw_max > 40) pw_max = 40;
10576 break;
10577 case 12500: if (pw_max > 20) pw_max = 20;
10578 break;
10579 case 12800: if (pw_max > 24) pw_max = 24;
10580 break;
10581 }
10582
10583 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10584 {
10585 switch (attack_kern)
10586 {
10587 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10588 break;
10589 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10590 break;
10591 }
10592 }
10593
10594 /**
10595 * charsets : keep them together for more easy maintainnce
10596 */
10597
10598 cs_t mp_sys[6] = { { { 0 }, 0 } };
10599 cs_t mp_usr[4] = { { { 0 }, 0 } };
10600
10601 mp_setup_sys (mp_sys);
10602
10603 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10604 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10605 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10606 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10607
10608 /**
10609 * load hashes, part I: find input mode, count hashes
10610 */
10611
10612 uint hashlist_mode = 0;
10613 uint hashlist_format = HLFMT_HASHCAT;
10614
10615 uint hashes_avail = 0;
10616
10617 if (benchmark == 0)
10618 {
10619 struct stat f;
10620
10621 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10622
10623 if ((hash_mode == 2500) ||
10624 (hash_mode == 5200) ||
10625 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10626 (hash_mode == 9000))
10627 {
10628 hashlist_mode = HL_MODE_ARG;
10629
10630 char *hashfile = myargv[optind];
10631
10632 data.hashfile = hashfile;
10633
10634 logfile_top_var_string ("target", hashfile);
10635 }
10636
10637 if (hashlist_mode == HL_MODE_ARG)
10638 {
10639 if (hash_mode == 2500)
10640 {
10641 struct stat st;
10642
10643 if (stat (data.hashfile, &st) == -1)
10644 {
10645 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10646
10647 return (-1);
10648 }
10649
10650 hashes_avail = st.st_size / sizeof (hccap_t);
10651 }
10652 else
10653 {
10654 hashes_avail = 1;
10655 }
10656 }
10657 else if (hashlist_mode == HL_MODE_FILE)
10658 {
10659 char *hashfile = myargv[optind];
10660
10661 data.hashfile = hashfile;
10662
10663 logfile_top_var_string ("target", hashfile);
10664
10665 FILE *fp = NULL;
10666
10667 if ((fp = fopen (hashfile, "rb")) == NULL)
10668 {
10669 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10670
10671 return (-1);
10672 }
10673
10674 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10675
10676 hashes_avail = count_lines (fp);
10677
10678 rewind (fp);
10679
10680 if (hashes_avail == 0)
10681 {
10682 log_error ("ERROR: hashfile is empty or corrupt");
10683
10684 fclose (fp);
10685
10686 return (-1);
10687 }
10688
10689 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10690
10691 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10692 {
10693 log_error ("ERROR: remove not supported in native hashfile-format mode");
10694
10695 fclose (fp);
10696
10697 return (-1);
10698 }
10699
10700 fclose (fp);
10701 }
10702 }
10703 else
10704 {
10705 hashlist_mode = HL_MODE_ARG;
10706
10707 hashes_avail = 1;
10708 }
10709
10710 if (hash_mode == 3000) hashes_avail *= 2;
10711
10712 data.hashlist_mode = hashlist_mode;
10713 data.hashlist_format = hashlist_format;
10714
10715 logfile_top_uint (hashlist_mode);
10716 logfile_top_uint (hashlist_format);
10717
10718 /**
10719 * load hashes, part II: allocate required memory, set pointers
10720 */
10721
10722 hash_t *hashes_buf = NULL;
10723 void *digests_buf = NULL;
10724 salt_t *salts_buf = NULL;
10725 void *esalts_buf = NULL;
10726
10727 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10728
10729 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10730
10731 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10732 {
10733 u32 hash_pos;
10734
10735 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10736 {
10737 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10738
10739 hashes_buf[hash_pos].hash_info = hash_info;
10740
10741 if (username && (remove || show || left))
10742 {
10743 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10744 }
10745
10746 if (benchmark)
10747 {
10748 hash_info->orighash = (char *) mymalloc (256);
10749 }
10750 }
10751 }
10752
10753 if (isSalted)
10754 {
10755 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10756
10757 if (esalt_size)
10758 {
10759 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10760 }
10761 }
10762 else
10763 {
10764 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10765 }
10766
10767 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10768 {
10769 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10770
10771 if (isSalted)
10772 {
10773 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10774
10775 if (esalt_size)
10776 {
10777 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10778 }
10779 }
10780 else
10781 {
10782 hashes_buf[hash_pos].salt = &salts_buf[0];
10783 }
10784 }
10785
10786 /**
10787 * load hashes, part III: parse hashes or generate them if benchmark
10788 */
10789
10790 uint hashes_cnt = 0;
10791
10792 if (benchmark == 0)
10793 {
10794 if (keyspace == 1)
10795 {
10796 // useless to read hash file for keyspace, cheat a little bit w/ optind
10797 }
10798 else if (hashes_avail == 0)
10799 {
10800 }
10801 else if (hashlist_mode == HL_MODE_ARG)
10802 {
10803 char *input_buf = myargv[optind];
10804
10805 uint input_len = strlen (input_buf);
10806
10807 logfile_top_var_string ("target", input_buf);
10808
10809 char *hash_buf = NULL;
10810 int hash_len = 0;
10811
10812 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10813
10814 if (hash_len)
10815 {
10816 if (opts_type & OPTS_TYPE_HASH_COPY)
10817 {
10818 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10819
10820 hash_info_tmp->orighash = mystrdup (hash_buf);
10821 }
10822
10823 if (isSalted)
10824 {
10825 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10826 }
10827
10828 int parser_status = PARSER_OK;
10829
10830 if (hash_mode == 2500)
10831 {
10832 if (hash_len == 0)
10833 {
10834 log_error ("ERROR: hccap file not specified");
10835
10836 return (-1);
10837 }
10838
10839 hashlist_mode = HL_MODE_FILE;
10840
10841 data.hashlist_mode = hashlist_mode;
10842
10843 FILE *fp = fopen (hash_buf, "rb");
10844
10845 if (fp == NULL)
10846 {
10847 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10848
10849 return (-1);
10850 }
10851
10852 if (hashes_avail < 1)
10853 {
10854 log_error ("ERROR: hccap file is empty or corrupt");
10855
10856 fclose (fp);
10857
10858 return (-1);
10859 }
10860
10861 uint hccap_size = sizeof (hccap_t);
10862
10863 char *in = (char *) mymalloc (hccap_size);
10864
10865 while (!feof (fp))
10866 {
10867 int n = fread (in, hccap_size, 1, fp);
10868
10869 if (n != 1)
10870 {
10871 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10872
10873 break;
10874 }
10875
10876 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10877
10878 if (parser_status != PARSER_OK)
10879 {
10880 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10881
10882 continue;
10883 }
10884
10885 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10886
10887 if ((show == 1) || (left == 1))
10888 {
10889 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10890
10891 char *salt_ptr = (char *) tmp_salt->salt_buf;
10892
10893 int cur_pos = tmp_salt->salt_len;
10894 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10895
10896 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10897
10898 u8 *pke_ptr = (u8 *) wpa->pke;
10899
10900 // do the appending task
10901
10902 snprintf (salt_ptr + cur_pos,
10903 rem_len,
10904 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10905 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10906 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10907
10908
10909 // memset () the remaining part of the salt
10910
10911 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10912 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10913
10914 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10915
10916 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10917 }
10918
10919 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);
10920 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);
10921
10922 hashes_cnt++;
10923 }
10924
10925 fclose (fp);
10926
10927 myfree (in);
10928 }
10929 else if (hash_mode == 3000)
10930 {
10931 if (hash_len == 32)
10932 {
10933 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10934
10935 hash_t *lm_hash_left = NULL;
10936
10937 if (parser_status == PARSER_OK)
10938 {
10939 lm_hash_left = &hashes_buf[hashes_cnt];
10940
10941 hashes_cnt++;
10942 }
10943 else
10944 {
10945 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10946 }
10947
10948 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10949
10950 hash_t *lm_hash_right = NULL;
10951
10952 if (parser_status == PARSER_OK)
10953 {
10954 lm_hash_right = &hashes_buf[hashes_cnt];
10955
10956 hashes_cnt++;
10957 }
10958 else
10959 {
10960 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10961 }
10962
10963 // show / left
10964
10965 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10966 {
10967 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);
10968 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);
10969 }
10970 }
10971 else
10972 {
10973 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10974
10975 if (parser_status == PARSER_OK)
10976 {
10977 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10978 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10979 }
10980
10981 if (parser_status == PARSER_OK)
10982 {
10983 hashes_cnt++;
10984 }
10985 else
10986 {
10987 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10988 }
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 }
11012 else if (hashlist_mode == HL_MODE_FILE)
11013 {
11014 char *hashfile = data.hashfile;
11015
11016 FILE *fp;
11017
11018 if ((fp = fopen (hashfile, "rb")) == NULL)
11019 {
11020 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11021
11022 return (-1);
11023 }
11024
11025 uint line_num = 0;
11026
11027 while (!feof (fp))
11028 {
11029 line_num++;
11030
11031 char line_buf[BUFSIZ] = { 0 };
11032
11033 int line_len = fgetl (fp, line_buf);
11034
11035 if (line_len == 0) continue;
11036
11037 char *hash_buf = NULL;
11038 int hash_len = 0;
11039
11040 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11041
11042 if (username)
11043 {
11044 char *user_buf = NULL;
11045 int user_len = 0;
11046
11047 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11048
11049 if (remove || show)
11050 {
11051 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11052
11053 *user = (user_t *) mymalloc (sizeof (user_t));
11054
11055 user_t *user_ptr = *user;
11056
11057 if (user_buf != NULL)
11058 {
11059 user_ptr->user_name = mystrdup (user_buf);
11060 }
11061 else
11062 {
11063 user_ptr->user_name = mystrdup ("");
11064 }
11065
11066 user_ptr->user_len = user_len;
11067 }
11068 }
11069
11070 if (opts_type & OPTS_TYPE_HASH_COPY)
11071 {
11072 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11073
11074 hash_info_tmp->orighash = mystrdup (hash_buf);
11075 }
11076
11077 if (isSalted)
11078 {
11079 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11080 }
11081
11082 if (hash_mode == 3000)
11083 {
11084 if (hash_len == 32)
11085 {
11086 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11087
11088 if (parser_status < PARSER_GLOBAL_ZERO)
11089 {
11090 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11091
11092 continue;
11093 }
11094
11095 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11096
11097 hashes_cnt++;
11098
11099 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11100
11101 if (parser_status < PARSER_GLOBAL_ZERO)
11102 {
11103 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11104
11105 continue;
11106 }
11107
11108 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11109
11110 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);
11111
11112 hashes_cnt++;
11113
11114 // show / left
11115
11116 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);
11117 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);
11118 }
11119 else
11120 {
11121 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11122
11123 if (parser_status < PARSER_GLOBAL_ZERO)
11124 {
11125 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11126
11127 continue;
11128 }
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 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11133 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134
11135 hashes_cnt++;
11136 }
11137 }
11138 else
11139 {
11140 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11141
11142 if (parser_status < PARSER_GLOBAL_ZERO)
11143 {
11144 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11145
11146 continue;
11147 }
11148
11149 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);
11150
11151 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11152 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11153
11154 hashes_cnt++;
11155 }
11156 }
11157
11158 fclose (fp);
11159
11160 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11161
11162 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11163 }
11164 }
11165 else
11166 {
11167 if (isSalted)
11168 {
11169 hashes_buf[0].salt->salt_len = 8;
11170
11171 // special salt handling
11172
11173 switch (hash_mode)
11174 {
11175 case 1500: hashes_buf[0].salt->salt_len = 2;
11176 break;
11177 case 1731: hashes_buf[0].salt->salt_len = 4;
11178 break;
11179 case 2410: hashes_buf[0].salt->salt_len = 4;
11180 break;
11181 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11182 break;
11183 case 3100: hashes_buf[0].salt->salt_len = 1;
11184 break;
11185 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11186 break;
11187 case 5800: hashes_buf[0].salt->salt_len = 16;
11188 break;
11189 case 6800: hashes_buf[0].salt->salt_len = 32;
11190 break;
11191 case 8400: hashes_buf[0].salt->salt_len = 40;
11192 break;
11193 case 8800: hashes_buf[0].salt->salt_len = 16;
11194 break;
11195 case 8900: hashes_buf[0].salt->salt_len = 16;
11196 hashes_buf[0].salt->scrypt_N = 1024;
11197 hashes_buf[0].salt->scrypt_r = 1;
11198 hashes_buf[0].salt->scrypt_p = 1;
11199 break;
11200 case 9100: hashes_buf[0].salt->salt_len = 16;
11201 break;
11202 case 9300: hashes_buf[0].salt->salt_len = 14;
11203 hashes_buf[0].salt->scrypt_N = 16384;
11204 hashes_buf[0].salt->scrypt_r = 1;
11205 hashes_buf[0].salt->scrypt_p = 1;
11206 break;
11207 case 9400: hashes_buf[0].salt->salt_len = 16;
11208 break;
11209 case 9500: hashes_buf[0].salt->salt_len = 16;
11210 break;
11211 case 9600: hashes_buf[0].salt->salt_len = 16;
11212 break;
11213 case 9700: hashes_buf[0].salt->salt_len = 16;
11214 break;
11215 case 9710: hashes_buf[0].salt->salt_len = 16;
11216 break;
11217 case 9720: hashes_buf[0].salt->salt_len = 16;
11218 break;
11219 case 9800: hashes_buf[0].salt->salt_len = 16;
11220 break;
11221 case 9810: hashes_buf[0].salt->salt_len = 16;
11222 break;
11223 case 9820: hashes_buf[0].salt->salt_len = 16;
11224 break;
11225 case 10300: hashes_buf[0].salt->salt_len = 12;
11226 break;
11227 case 11500: hashes_buf[0].salt->salt_len = 4;
11228 break;
11229 case 11600: hashes_buf[0].salt->salt_len = 4;
11230 break;
11231 case 12400: hashes_buf[0].salt->salt_len = 4;
11232 break;
11233 case 12500: hashes_buf[0].salt->salt_len = 8;
11234 break;
11235 case 12600: hashes_buf[0].salt->salt_len = 64;
11236 break;
11237 }
11238
11239 // special esalt handling
11240
11241 switch (hash_mode)
11242 {
11243 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11244 break;
11245 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11246 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11247 break;
11248 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11249 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11250 break;
11251 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11252 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11253 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11254 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11255 break;
11256 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11257 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11258 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11259 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11260 break;
11261 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11262 break;
11263 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11264 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11265 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11266 break;
11267 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11268 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11269 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11270 break;
11271 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11272 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11273 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11274 break;
11275 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11276 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11277 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11278 break;
11279 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11280 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11281 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11282 break;
11283 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11284 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11285 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11286 break;
11287 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11288 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11289 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11290 break;
11291 }
11292 }
11293
11294 // set hashfile
11295
11296 switch (hash_mode)
11297 {
11298 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11299 break;
11300 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11301 break;
11302 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11303 break;
11304 case 6211:
11305 case 6212:
11306 case 6213:
11307 case 6221:
11308 case 6222:
11309 case 6223:
11310 case 6231:
11311 case 6232:
11312 case 6233:
11313 case 6241:
11314 case 6242:
11315 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11316 break;
11317 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11318 break;
11319 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11320 break;
11321 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11322 break;
11323 }
11324
11325 // set default iterations
11326
11327 switch (hash_mode)
11328 {
11329 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11330 break;
11331 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11332 break;
11333 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11334 break;
11335 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11336 break;
11337 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11338 break;
11339 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11340 break;
11341 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11342 break;
11343 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11344 break;
11345 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11346 break;
11347 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11348 break;
11349 case 6211:
11350 case 6212:
11351 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11352 break;
11353 case 6221:
11354 case 6222:
11355 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11356 break;
11357 case 6231:
11358 case 6232:
11359 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11360 break;
11361 case 6241:
11362 case 6242:
11363 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11364 break;
11365 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11366 break;
11367 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11368 break;
11369 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11370 break;
11371 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11372 break;
11373 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11374 break;
11375 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11376 break;
11377 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11378 break;
11379 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11380 break;
11381 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11382 break;
11383 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11384 break;
11385 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11386 break;
11387 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11388 break;
11389 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11390 break;
11391 case 8900: hashes_buf[0].salt->salt_iter = 1;
11392 break;
11393 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11394 break;
11395 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11396 break;
11397 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11398 break;
11399 case 9300: hashes_buf[0].salt->salt_iter = 1;
11400 break;
11401 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11402 break;
11403 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11404 break;
11405 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11406 break;
11407 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11408 break;
11409 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11410 break;
11411 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11412 break;
11413 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11414 break;
11415 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11416 break;
11417 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11418 break;
11419 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11420 break;
11421 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11422 break;
11423 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11424 break;
11425 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11426 break;
11427 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11428 break;
11429 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11430 break;
11431 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11432 break;
11433 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11434 break;
11435 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11436 break;
11437 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11438 break;
11439 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11440 break;
11441 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11442 break;
11443 }
11444
11445 hashes_cnt = 1;
11446 }
11447
11448 if (show == 1 || left == 1)
11449 {
11450 for (uint i = 0; i < pot_cnt; i++)
11451 {
11452 pot_t *pot_ptr = &pot[i];
11453
11454 hash_t *hashes_buf = &pot_ptr->hash;
11455
11456 local_free (hashes_buf->digest);
11457
11458 if (isSalted)
11459 {
11460 local_free (hashes_buf->salt);
11461 }
11462 }
11463
11464 local_free (pot);
11465
11466 if (data.quiet == 0) log_info_nn ("");
11467
11468 return (0);
11469 }
11470
11471 if (keyspace == 0)
11472 {
11473 if (hashes_cnt == 0)
11474 {
11475 log_error ("ERROR: No hashes loaded");
11476
11477 return (-1);
11478 }
11479 }
11480
11481 /**
11482 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11483 */
11484
11485 if (data.outfile != NULL)
11486 {
11487 if (data.hashfile != NULL)
11488 {
11489 #ifdef _POSIX
11490 struct stat tmpstat_outfile;
11491 struct stat tmpstat_hashfile;
11492 #endif
11493
11494 #ifdef _WIN
11495 struct stat64 tmpstat_outfile;
11496 struct stat64 tmpstat_hashfile;
11497 #endif
11498
11499 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11500
11501 if (tmp_outfile_fp)
11502 {
11503 #ifdef _POSIX
11504 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11505 #endif
11506
11507 #ifdef _WIN
11508 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11509 #endif
11510
11511 fclose (tmp_outfile_fp);
11512 }
11513
11514 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11515
11516 if (tmp_hashfile_fp)
11517 {
11518 #ifdef _POSIX
11519 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11520 #endif
11521
11522 #ifdef _WIN
11523 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11524 #endif
11525
11526 fclose (tmp_hashfile_fp);
11527 }
11528
11529 if (tmp_outfile_fp && tmp_outfile_fp)
11530 {
11531 tmpstat_outfile.st_mode = 0;
11532 tmpstat_outfile.st_nlink = 0;
11533 tmpstat_outfile.st_uid = 0;
11534 tmpstat_outfile.st_gid = 0;
11535 tmpstat_outfile.st_rdev = 0;
11536 tmpstat_outfile.st_atime = 0;
11537
11538 tmpstat_hashfile.st_mode = 0;
11539 tmpstat_hashfile.st_nlink = 0;
11540 tmpstat_hashfile.st_uid = 0;
11541 tmpstat_hashfile.st_gid = 0;
11542 tmpstat_hashfile.st_rdev = 0;
11543 tmpstat_hashfile.st_atime = 0;
11544
11545 #ifdef _POSIX
11546 tmpstat_outfile.st_blksize = 0;
11547 tmpstat_outfile.st_blocks = 0;
11548
11549 tmpstat_hashfile.st_blksize = 0;
11550 tmpstat_hashfile.st_blocks = 0;
11551 #endif
11552
11553 #ifdef _POSIX
11554 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11555 {
11556 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11557
11558 return (-1);
11559 }
11560 #endif
11561
11562 #ifdef _WIN
11563 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11564 {
11565 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11566
11567 return (-1);
11568 }
11569 #endif
11570 }
11571 }
11572 }
11573
11574 /**
11575 * Remove duplicates
11576 */
11577
11578 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11579
11580 if (isSalted)
11581 {
11582 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11583 }
11584 else
11585 {
11586 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11587 }
11588
11589 uint hashes_cnt_orig = hashes_cnt;
11590
11591 hashes_cnt = 1;
11592
11593 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11594 {
11595 if (isSalted)
11596 {
11597 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11598 {
11599 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11600 }
11601 }
11602 else
11603 {
11604 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11605 }
11606
11607 if (hashes_pos > hashes_cnt)
11608 {
11609 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11610 }
11611
11612 hashes_cnt++;
11613 }
11614
11615 /**
11616 * Potfile removes
11617 */
11618
11619 uint potfile_remove_cracks = 0;
11620
11621 if (potfile_disable == 0)
11622 {
11623 hash_t hash_buf;
11624
11625 hash_buf.digest = mymalloc (dgst_size);
11626 hash_buf.salt = NULL;
11627 hash_buf.esalt = NULL;
11628 hash_buf.hash_info = NULL;
11629 hash_buf.cracked = 0;
11630
11631 if (isSalted)
11632 {
11633 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11634 }
11635
11636 if (esalt_size)
11637 {
11638 hash_buf.esalt = mymalloc (esalt_size);
11639 }
11640
11641 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11642
11643 // no solution for these special hash types (for instane because they use hashfile in output etc)
11644 if ((hash_mode != 5200) &&
11645 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11646 (hash_mode != 9000))
11647 {
11648 FILE *fp = fopen (potfile, "rb");
11649
11650 if (fp != NULL)
11651 {
11652 while (!feof (fp))
11653 {
11654 char line_buf[BUFSIZ] = { 0 };
11655
11656 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11657
11658 if (ptr == NULL) break;
11659
11660 int line_len = strlen (line_buf);
11661
11662 if (line_len == 0) continue;
11663
11664 int iter = MAX_CUT_TRIES;
11665
11666 for (int i = line_len - 1; i && iter; i--, line_len--)
11667 {
11668 if (line_buf[i] != ':') continue;
11669
11670 if (isSalted)
11671 {
11672 memset (hash_buf.salt, 0, sizeof (salt_t));
11673 }
11674
11675 hash_t *found = NULL;
11676
11677 if (hash_mode == 6800)
11678 {
11679 if (i < 64) // 64 = 16 * uint in salt_buf[]
11680 {
11681 // manipulate salt_buf
11682 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11683
11684 hash_buf.salt->salt_len = i;
11685
11686 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11687 }
11688 }
11689 else if (hash_mode == 2500)
11690 {
11691 if (i < 64) // 64 = 16 * uint in salt_buf[]
11692 {
11693 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11694 // manipulate salt_buf
11695
11696 // to be safe work with a copy (because of line_len loop, i etc)
11697
11698 char line_buf_cpy[BUFSIZ] = { 0 };
11699
11700 memcpy (line_buf_cpy, line_buf, i);
11701
11702 char *mac2_pos = strrchr (line_buf_cpy, ':');
11703
11704 if (mac2_pos == NULL) continue;
11705
11706 mac2_pos[0] = 0;
11707 mac2_pos++;
11708
11709 if (strlen (mac2_pos) != 12) continue;
11710
11711 char *mac1_pos = strrchr (line_buf_cpy, ':');
11712
11713 if (mac1_pos == NULL) continue;
11714
11715 mac1_pos[0] = 0;
11716 mac1_pos++;
11717
11718 if (strlen (mac1_pos) != 12) continue;
11719
11720 uint essid_length = mac1_pos - line_buf_cpy - 1;
11721
11722 // here we need the ESSID
11723 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11724
11725 hash_buf.salt->salt_len = essid_length;
11726
11727 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11728
11729 if (found)
11730 {
11731 wpa_t *wpa = (wpa_t *) found->esalt;
11732
11733 uint pke[25] = { 0 };
11734
11735 char *pke_ptr = (char *) pke;
11736
11737 for (uint i = 0; i < 25; i++)
11738 {
11739 pke[i] = byte_swap_32 (wpa->pke[i]);
11740 }
11741
11742 u8 mac1[6] = { 0 };
11743 u8 mac2[6] = { 0 };
11744
11745 memcpy (mac1, pke_ptr + 23, 6);
11746 memcpy (mac2, pke_ptr + 29, 6);
11747
11748 // compare hex string(s) vs binary MAC address(es)
11749
11750 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11751 {
11752 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11753 {
11754 found = NULL;
11755 break;
11756 }
11757 }
11758
11759 // early skip ;)
11760 if (!found) continue;
11761
11762 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11763 {
11764 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11765 {
11766 found = NULL;
11767 break;
11768 }
11769 }
11770 }
11771 }
11772 }
11773 else
11774 {
11775 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11776
11777 if (parser_status == PARSER_OK)
11778 {
11779 if (isSalted)
11780 {
11781 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11782 }
11783 else
11784 {
11785 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11786 }
11787 }
11788 }
11789
11790 if (found == NULL) continue;
11791
11792 if (!found->cracked) potfile_remove_cracks++;
11793
11794 found->cracked = 1;
11795
11796 if (found) break;
11797
11798 iter--;
11799 }
11800 }
11801
11802 fclose (fp);
11803 }
11804 }
11805
11806 if (esalt_size)
11807 {
11808 local_free (hash_buf.esalt);
11809 }
11810
11811 if (isSalted)
11812 {
11813 local_free (hash_buf.salt);
11814 }
11815
11816 local_free (hash_buf.digest);
11817 }
11818
11819 /**
11820 * Now generate all the buffers required for later
11821 */
11822
11823 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11824
11825 salt_t *salts_buf_new = NULL;
11826 void *esalts_buf_new = NULL;
11827
11828 if (isSalted)
11829 {
11830 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11831
11832 if (esalt_size)
11833 {
11834 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11835 }
11836 }
11837 else
11838 {
11839 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11840 }
11841
11842 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11843
11844 uint digests_cnt = hashes_cnt;
11845 uint digests_done = 0;
11846
11847 uint size_digests = digests_cnt * dgst_size;
11848 uint size_shown = digests_cnt * sizeof (uint);
11849
11850 uint *digests_shown = (uint *) mymalloc (size_shown);
11851 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11852
11853 uint salts_cnt = 0;
11854 uint salts_done = 0;
11855
11856 hashinfo_t **hash_info = NULL;
11857
11858 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11859 {
11860 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11861
11862 if (username && (remove || show))
11863 {
11864 uint user_pos;
11865
11866 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11867 {
11868 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11869
11870 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11871 }
11872 }
11873 }
11874
11875 uint *salts_shown = (uint *) mymalloc (size_shown);
11876
11877 salt_t *salt_buf;
11878
11879 {
11880 // copied from inner loop
11881
11882 salt_buf = &salts_buf_new[salts_cnt];
11883
11884 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11885
11886 if (esalt_size)
11887 {
11888 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11889 }
11890
11891 salt_buf->digests_cnt = 0;
11892 salt_buf->digests_done = 0;
11893 salt_buf->digests_offset = 0;
11894
11895 salts_cnt++;
11896 }
11897
11898 if (hashes_buf[0].cracked == 1)
11899 {
11900 digests_shown[0] = 1;
11901
11902 digests_done++;
11903
11904 salt_buf->digests_done++;
11905 }
11906
11907 salt_buf->digests_cnt++;
11908
11909 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11910
11911 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11912 {
11913 hash_info[0] = hashes_buf[0].hash_info;
11914 }
11915
11916 // copy from inner loop
11917
11918 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11919 {
11920 if (isSalted)
11921 {
11922 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11923 {
11924 salt_buf = &salts_buf_new[salts_cnt];
11925
11926 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11927
11928 if (esalt_size)
11929 {
11930 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11931 }
11932
11933 salt_buf->digests_cnt = 0;
11934 salt_buf->digests_done = 0;
11935 salt_buf->digests_offset = hashes_pos;
11936
11937 salts_cnt++;
11938 }
11939 }
11940
11941 if (hashes_buf[hashes_pos].cracked == 1)
11942 {
11943 digests_shown[hashes_pos] = 1;
11944
11945 digests_done++;
11946
11947 salt_buf->digests_done++;
11948 }
11949
11950 salt_buf->digests_cnt++;
11951
11952 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11953
11954 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11955 {
11956 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11957 }
11958 }
11959
11960 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11961 {
11962 salt_t *salt_buf = &salts_buf_new[salt_pos];
11963
11964 if (salt_buf->digests_done == salt_buf->digests_cnt)
11965 {
11966 salts_shown[salt_pos] = 1;
11967
11968 salts_done++;
11969 }
11970
11971 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11972 }
11973
11974 local_free (digests_buf);
11975 local_free (salts_buf);
11976 local_free (esalts_buf);
11977
11978 digests_buf = digests_buf_new;
11979 salts_buf = salts_buf_new;
11980 esalts_buf = esalts_buf_new;
11981
11982 local_free (hashes_buf);
11983
11984 /**
11985 * special modification not set from parser
11986 */
11987
11988 switch (hash_mode)
11989 {
11990 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11991 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11992 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11993 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11994 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11995 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11996 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11997 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11998 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11999 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12000 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12001 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12002 }
12003
12004 if (truecrypt_keyfiles)
12005 {
12006 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12007
12008 char *keyfiles = strdup (truecrypt_keyfiles);
12009
12010 char *keyfile = strtok (keyfiles, ",");
12011
12012 do
12013 {
12014 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12015
12016 } while ((keyfile = strtok (NULL, ",")) != NULL);
12017
12018 free (keyfiles);
12019 }
12020
12021 data.digests_cnt = digests_cnt;
12022 data.digests_done = digests_done;
12023 data.digests_buf = digests_buf;
12024 data.digests_shown = digests_shown;
12025 data.digests_shown_tmp = digests_shown_tmp;
12026
12027 data.salts_cnt = salts_cnt;
12028 data.salts_done = salts_done;
12029 data.salts_buf = salts_buf;
12030 data.salts_shown = salts_shown;
12031
12032 data.esalts_buf = esalts_buf;
12033 data.hash_info = hash_info;
12034
12035 /**
12036 * Automatic Optimizers
12037 */
12038
12039 if (salts_cnt == 1)
12040 opti_type |= OPTI_TYPE_SINGLE_SALT;
12041
12042 if (digests_cnt == 1)
12043 opti_type |= OPTI_TYPE_SINGLE_HASH;
12044
12045 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12046 opti_type |= OPTI_TYPE_NOT_ITERATED;
12047
12048 if (attack_mode == ATTACK_MODE_BF)
12049 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12050
12051 data.opti_type = opti_type;
12052
12053 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12054 {
12055 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12056 {
12057 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12058 {
12059 if (opts_type & OPTS_TYPE_ST_ADD80)
12060 {
12061 opts_type &= ~OPTS_TYPE_ST_ADD80;
12062 opts_type |= OPTS_TYPE_PT_ADD80;
12063 }
12064
12065 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12066 {
12067 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12068 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12069 }
12070
12071 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12072 {
12073 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12074 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12075 }
12076 }
12077 }
12078 }
12079
12080 /**
12081 * Some algorithm, like descrypt, can benefit from JIT compilation
12082 */
12083
12084 int force_jit_compilation = -1;
12085
12086 if (hash_mode == 8900)
12087 {
12088 force_jit_compilation = 8900;
12089 }
12090 else if (hash_mode == 9300)
12091 {
12092 force_jit_compilation = 8900;
12093 }
12094 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12095 {
12096 force_jit_compilation = 1500;
12097 }
12098
12099 /**
12100 * generate bitmap tables
12101 */
12102
12103 const uint bitmap_shift1 = 5;
12104 const uint bitmap_shift2 = 13;
12105
12106 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12107
12108 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12109 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12110 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12111 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12112 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12113 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12114 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12115 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12116
12117 uint bitmap_bits;
12118 uint bitmap_nums;
12119 uint bitmap_mask;
12120 uint bitmap_size;
12121
12122 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12123 {
12124 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12125
12126 bitmap_nums = 1 << bitmap_bits;
12127
12128 bitmap_mask = bitmap_nums - 1;
12129
12130 bitmap_size = bitmap_nums * sizeof (uint);
12131
12132 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12133
12134 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;
12135 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;
12136
12137 break;
12138 }
12139
12140 bitmap_nums = 1 << bitmap_bits;
12141
12142 bitmap_mask = bitmap_nums - 1;
12143
12144 bitmap_size = bitmap_nums * sizeof (uint);
12145
12146 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);
12147 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);
12148
12149 /**
12150 * prepare quick rule
12151 */
12152
12153 data.rule_buf_l = rule_buf_l;
12154 data.rule_buf_r = rule_buf_r;
12155
12156 int rule_len_l = (int) strlen (rule_buf_l);
12157 int rule_len_r = (int) strlen (rule_buf_r);
12158
12159 data.rule_len_l = rule_len_l;
12160 data.rule_len_r = rule_len_r;
12161
12162 /**
12163 * load rules
12164 */
12165
12166 uint *all_kernel_rules_cnt = NULL;
12167
12168 kernel_rule_t **all_kernel_rules_buf = NULL;
12169
12170 if (rp_files_cnt)
12171 {
12172 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12173
12174 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12175 }
12176
12177 char rule_buf[BUFSIZ] = { 0 };
12178
12179 int rule_len = 0;
12180
12181 for (uint i = 0; i < rp_files_cnt; i++)
12182 {
12183 uint kernel_rules_avail = 0;
12184
12185 uint kernel_rules_cnt = 0;
12186
12187 kernel_rule_t *kernel_rules_buf = NULL;
12188
12189 char *rp_file = rp_files[i];
12190
12191 char in[BLOCK_SIZE] = { 0 };
12192 char out[BLOCK_SIZE] = { 0 };
12193
12194 FILE *fp = NULL;
12195
12196 uint rule_line = 0;
12197
12198 if ((fp = fopen (rp_file, "rb")) == NULL)
12199 {
12200 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12201
12202 return (-1);
12203 }
12204
12205 while (!feof (fp))
12206 {
12207 memset (rule_buf, 0, BUFSIZ);
12208
12209 rule_len = fgetl (fp, rule_buf);
12210
12211 rule_line++;
12212
12213 if (rule_len == 0) continue;
12214
12215 if (rule_buf[0] == '#') continue;
12216
12217 if (kernel_rules_avail == kernel_rules_cnt)
12218 {
12219 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12220
12221 kernel_rules_avail += INCR_RULES;
12222 }
12223
12224 memset (in, 0, BLOCK_SIZE);
12225 memset (out, 0, BLOCK_SIZE);
12226
12227 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12228
12229 if (result == -1)
12230 {
12231 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12232
12233 continue;
12234 }
12235
12236 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12237 {
12238 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12239
12240 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12241
12242 continue;
12243 }
12244
12245 /* its so slow
12246 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12247 {
12248 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12249
12250 continue;
12251 }
12252 */
12253
12254 kernel_rules_cnt++;
12255 }
12256
12257 fclose (fp);
12258
12259 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12260
12261 all_kernel_rules_buf[i] = kernel_rules_buf;
12262 }
12263
12264 /**
12265 * merge rules or automatic rule generator
12266 */
12267
12268 uint kernel_rules_cnt = 0;
12269
12270 kernel_rule_t *kernel_rules_buf = NULL;
12271
12272 if (attack_mode == ATTACK_MODE_STRAIGHT)
12273 {
12274 if (rp_files_cnt)
12275 {
12276 kernel_rules_cnt = 1;
12277
12278 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12279
12280 repeats[0] = kernel_rules_cnt;
12281
12282 for (uint i = 0; i < rp_files_cnt; i++)
12283 {
12284 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12285
12286 repeats[i + 1] = kernel_rules_cnt;
12287 }
12288
12289 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12290
12291 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12292
12293 for (uint i = 0; i < kernel_rules_cnt; i++)
12294 {
12295 uint out_pos = 0;
12296
12297 kernel_rule_t *out = &kernel_rules_buf[i];
12298
12299 for (uint j = 0; j < rp_files_cnt; j++)
12300 {
12301 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12302 uint in_pos;
12303
12304 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12305
12306 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12307 {
12308 if (out_pos == RULES_MAX - 1)
12309 {
12310 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12311
12312 break;
12313 }
12314
12315 out->cmds[out_pos] = in->cmds[in_pos];
12316 }
12317 }
12318 }
12319
12320 local_free (repeats);
12321 }
12322 else if (rp_gen)
12323 {
12324 uint kernel_rules_avail = 0;
12325
12326 while (kernel_rules_cnt < rp_gen)
12327 {
12328 if (kernel_rules_avail == kernel_rules_cnt)
12329 {
12330 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12331
12332 kernel_rules_avail += INCR_RULES;
12333 }
12334
12335 memset (rule_buf, 0, BLOCK_SIZE);
12336
12337 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12338
12339 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12340
12341 kernel_rules_cnt++;
12342 }
12343 }
12344 }
12345
12346 /**
12347 * generate NOP rules
12348 */
12349
12350 if (kernel_rules_cnt == 0)
12351 {
12352 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12353
12354 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12355
12356 kernel_rules_cnt++;
12357 }
12358
12359 data.kernel_rules_cnt = kernel_rules_cnt;
12360 data.kernel_rules_buf = kernel_rules_buf;
12361
12362 /**
12363 * OpenCL platforms: detect
12364 */
12365
12366 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12367 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12368
12369 cl_uint platforms_cnt = 0;
12370 cl_uint platform_devices_cnt = 0;
12371
12372 if (keyspace == 0)
12373 {
12374 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12375
12376 if (platforms_cnt == 0)
12377 {
12378 log_error ("ERROR: No OpenCL compatible platform found");
12379
12380 return (-1);
12381 }
12382 }
12383
12384 /**
12385 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12386 */
12387
12388 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12389 {
12390 cl_platform_id platform = platforms[platform_id];
12391
12392 char platform_vendor[INFOSZ] = { 0 };
12393
12394 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12395
12396 #ifdef HAVE_HWMON
12397 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12398 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12399 {
12400 // make sure that we do not directly control the fan for NVidia
12401
12402 gpu_temp_retain = 0;
12403
12404 data.gpu_temp_retain = gpu_temp_retain;
12405 }
12406 #endif // HAVE_NVML || HAVE_NVAPI
12407 #endif
12408 }
12409
12410 /**
12411 * OpenCL devices: simply push all devices from all platforms into the same device array
12412 */
12413
12414 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12415
12416 data.devices_param = devices_param;
12417
12418 uint devices_cnt = 0;
12419
12420 uint devices_active = 0;
12421
12422 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12423 {
12424 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12425
12426 cl_platform_id platform = platforms[platform_id];
12427
12428 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12429
12430 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12431 {
12432 size_t param_value_size = 0;
12433
12434 const uint device_id = devices_cnt;
12435
12436 hc_device_param_t *device_param = &data.devices_param[device_id];
12437
12438 device_param->device = platform_devices[platform_devices_id];
12439
12440 device_param->device_id = device_id;
12441
12442 device_param->platform_devices_id = platform_devices_id;
12443
12444 // device_type
12445
12446 cl_device_type device_type;
12447
12448 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12449
12450 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12451
12452 device_param->device_type = device_type;
12453
12454 // vendor_id
12455
12456 cl_uint vendor_id = 0;
12457
12458 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12459
12460 device_param->vendor_id = vendor_id;
12461
12462 // device_name
12463
12464 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12465
12466 char *device_name = (char *) mymalloc (param_value_size);
12467
12468 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12469
12470 device_param->device_name = device_name;
12471
12472 // tuning db
12473
12474 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12475
12476 // device_version
12477
12478 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12479
12480 char *device_version = (char *) mymalloc (param_value_size);
12481
12482 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12483
12484 device_param->device_version = device_version;
12485
12486 // device_opencl_version
12487
12488 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12489
12490 char *device_opencl_version = (char *) mymalloc (param_value_size);
12491
12492 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12493
12494 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12495
12496 myfree (device_opencl_version);
12497
12498 if (strstr (device_version, "pocl"))
12499 {
12500 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12501 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12502
12503 cl_uint vendor_id = VENDOR_ID_GENERIC;
12504
12505 device_param->vendor_id = vendor_id;
12506 }
12507
12508 // vector_width
12509
12510 cl_uint vector_width;
12511
12512 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12513 {
12514 if (tuningdb_entry->vector_width == -1)
12515 {
12516 if (opti_type & OPTI_TYPE_USES_BITS_64)
12517 {
12518 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12519 }
12520 else
12521 {
12522 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12523 }
12524 }
12525 else
12526 {
12527 vector_width = (cl_uint) tuningdb_entry->vector_width;
12528 }
12529 }
12530 else
12531 {
12532 vector_width = opencl_vector_width;
12533 }
12534
12535 if (vector_width > 8) vector_width = 8;
12536
12537 device_param->vector_width = vector_width;
12538
12539 // max_compute_units
12540
12541 cl_uint device_processors;
12542
12543 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12544
12545 device_param->device_processors = device_processors;
12546
12547 // max_mem_alloc_size
12548
12549 cl_ulong device_maxmem_alloc;
12550
12551 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12552
12553 device_param->device_maxmem_alloc = device_maxmem_alloc;
12554
12555 // max_mem_alloc_size
12556
12557 cl_ulong device_global_mem;
12558
12559 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12560
12561 device_param->device_global_mem = device_global_mem;
12562
12563 // max_clock_frequency
12564
12565 cl_uint device_maxclock_frequency;
12566
12567 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12568
12569 device_param->device_maxclock_frequency = device_maxclock_frequency;
12570
12571 // skipped
12572
12573 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12574 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12575
12576 device_param->skipped = (skipped1 || skipped2);
12577
12578 // driver_version
12579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12580
12581 char *driver_version = (char *) mymalloc (param_value_size);
12582
12583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12584
12585 device_param->driver_version = driver_version;
12586
12587 // device_name_chksum
12588
12589 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12590
12591 #if __x86_64__
12592 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);
12593 #else
12594 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);
12595 #endif
12596
12597 uint device_name_digest[4] = { 0 };
12598
12599 md5_64 ((uint *) device_name_chksum, device_name_digest);
12600
12601 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12602
12603 device_param->device_name_chksum = device_name_chksum;
12604
12605 // device_processor_cores
12606
12607 if (device_type & CL_DEVICE_TYPE_CPU)
12608 {
12609 cl_uint device_processor_cores = 1;
12610
12611 device_param->device_processor_cores = device_processor_cores;
12612 }
12613
12614 if (device_type & CL_DEVICE_TYPE_GPU)
12615 {
12616 if (vendor_id == VENDOR_ID_AMD)
12617 {
12618 cl_uint device_processor_cores = 0;
12619
12620 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12621
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12623
12624 device_param->device_processor_cores = device_processor_cores;
12625 }
12626 else if (vendor_id == VENDOR_ID_NV)
12627 {
12628 cl_uint kernel_exec_timeout = 0;
12629
12630 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12631
12632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12633
12634 device_param->kernel_exec_timeout = kernel_exec_timeout;
12635
12636 cl_uint device_processor_cores = 0;
12637
12638 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12639
12640 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12641
12642 device_param->device_processor_cores = device_processor_cores;
12643
12644 cl_uint sm_minor = 0;
12645 cl_uint sm_major = 0;
12646
12647 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12648 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12649
12650 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12652
12653 device_param->sm_minor = sm_minor;
12654 device_param->sm_major = sm_major;
12655 }
12656 else
12657 {
12658 cl_uint device_processor_cores = 1;
12659
12660 device_param->device_processor_cores = device_processor_cores;
12661 }
12662 }
12663
12664 // display results
12665
12666 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12667 {
12668 if (device_param->skipped == 0)
12669 {
12670 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12671 device_id + 1,
12672 device_name,
12673 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12674 (unsigned int) (device_global_mem / 1024 / 1024),
12675 (unsigned int) (device_maxclock_frequency),
12676 (unsigned int) device_processors);
12677 }
12678 else
12679 {
12680 log_info ("Device #%u: %s, skipped",
12681 device_id + 1,
12682 device_name);
12683 }
12684 }
12685
12686 // common driver check
12687
12688 if (device_param->skipped == 0)
12689 {
12690 if (strstr (device_version, "pocl"))
12691 {
12692 if (force == 0)
12693 {
12694 log_info ("");
12695 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12696 log_info ("You are STRONGLY encouraged not to use it");
12697 log_info ("You can use --force to override this but do not post error reports if you do so");
12698 log_info ("");
12699
12700 return (-1);
12701 }
12702 }
12703
12704 if (device_type & CL_DEVICE_TYPE_GPU)
12705 {
12706 if (vendor_id == VENDOR_ID_NV)
12707 {
12708 if (device_param->kernel_exec_timeout != 0)
12709 {
12710 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);
12711 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12712 }
12713 }
12714 else if (vendor_id == VENDOR_ID_AMD)
12715 {
12716 int catalyst_check = (force == 1) ? 0 : 1;
12717
12718 int catalyst_warn = 0;
12719
12720 int catalyst_broken = 0;
12721
12722 if (catalyst_check == 1)
12723 {
12724 catalyst_warn = 1;
12725
12726 // v14.9 and higher
12727 if (atoi (device_param->driver_version) >= 1573)
12728 {
12729 catalyst_warn = 0;
12730 }
12731
12732 catalyst_check = 0;
12733 }
12734
12735 if (catalyst_broken == 1)
12736 {
12737 log_info ("");
12738 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12739 log_info ("It will pass over cracked hashes and does not report them as cracked");
12740 log_info ("You are STRONGLY encouraged not to use it");
12741 log_info ("You can use --force to override this but do not post error reports if you do so");
12742 log_info ("");
12743
12744 return (-1);
12745 }
12746
12747 if (catalyst_warn == 1)
12748 {
12749 log_info ("");
12750 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12751 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12752 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12753 #ifdef _WIN
12754 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12755 #endif
12756 log_info ("You can use --force to override this but do not post error reports if you do so");
12757 log_info ("");
12758
12759 return (-1);
12760 }
12761 }
12762 }
12763
12764 /**
12765 * kernel accel and loops auto adjustment
12766 */
12767
12768 uint _kernel_accel = kernel_accel;
12769 uint _kernel_loops = kernel_loops;
12770
12771 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12772
12773 if (kernel_accel_chgd == 0)
12774 {
12775 _kernel_accel = tuningdb_entry->kernel_accel;
12776 }
12777
12778 if (kernel_loops_chgd == 0)
12779 {
12780 _kernel_loops = tuningdb_entry->kernel_loops;
12781 }
12782
12783 if (workload_profile == 1)
12784 {
12785 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12786 }
12787 else if (workload_profile == 2)
12788 {
12789 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12790 }
12791
12792 /**
12793 * there's a few algorithm that force a fixed kernel_loop count
12794 */
12795
12796 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
12797 {
12798 _kernel_loops = 1024;
12799 }
12800
12801 if (hash_mode == 12500)
12802 {
12803 _kernel_loops = ROUNDS_RAR3 / 16;
12804 }
12805
12806 device_param->kernel_accel = _kernel_accel;
12807 device_param->kernel_loops = _kernel_loops;
12808
12809 devices_active++;
12810 }
12811
12812 // next please
12813
12814 devices_cnt++;
12815 }
12816 }
12817
12818 if (keyspace == 0 && devices_active == 0)
12819 {
12820 log_error ("ERROR: No devices found/left");
12821
12822 return (-1);
12823 }
12824
12825 data.devices_cnt = devices_cnt;
12826
12827 data.devices_active = devices_active;
12828
12829 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12830 {
12831 log_info ("");
12832 }
12833
12834 /**
12835 * HM devices: init
12836 */
12837
12838 #ifdef HAVE_HWMON
12839 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12840 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12841 #endif
12842
12843 #ifdef HAVE_ADL
12844 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12845 #endif
12846
12847 if (gpu_temp_disable == 0)
12848 {
12849 #if defined(WIN) && defined(HAVE_NVAPI)
12850 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12851
12852 if (nvapi_init (nvapi) == 0)
12853 data.hm_nv = nvapi;
12854
12855 if (data.hm_nv)
12856 {
12857 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12858 {
12859 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12860
12861 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12862
12863 int tmp_out = 0;
12864
12865 for (int i = 0; i < tmp_in; i++)
12866 {
12867 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12868 }
12869
12870 for (int i = 0; i < tmp_out; i++)
12871 {
12872 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12873
12874 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12875
12876 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;
12877 }
12878 }
12879 }
12880 #endif // WIN && HAVE_NVAPI
12881
12882 #if defined(LINUX) && defined(HAVE_NVML)
12883 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12884
12885 if (nvml_init (nvml) == 0)
12886 data.hm_nv = nvml;
12887
12888 if (data.hm_nv)
12889 {
12890 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12891 {
12892 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12893
12894 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12895
12896 int tmp_out = 0;
12897
12898 for (int i = 0; i < tmp_in; i++)
12899 {
12900 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12901 }
12902
12903 for (int i = 0; i < tmp_out; i++)
12904 {
12905 unsigned int speed;
12906
12907 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;
12908 }
12909 }
12910 }
12911 #endif // LINUX && HAVE_NVML
12912
12913 data.hm_amd = NULL;
12914
12915 #ifdef HAVE_ADL
12916 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
12917
12918 if (adl_init (adl) == 0)
12919 data.hm_amd = adl;
12920
12921 if (data.hm_amd)
12922 {
12923 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12924 {
12925 // total number of adapters
12926
12927 int hm_adapters_num;
12928
12929 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
12930
12931 // adapter info
12932
12933 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
12934
12935 if (lpAdapterInfo == NULL) return (-1);
12936
12937 // get a list (of ids of) valid/usable adapters
12938
12939 int num_adl_adapters = 0;
12940
12941 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12942
12943 if (num_adl_adapters > 0)
12944 {
12945 hc_thread_mutex_lock (mux_adl);
12946
12947 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12948
12949 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12950
12951 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12952 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12953
12954 hc_thread_mutex_unlock (mux_adl);
12955 }
12956
12957 myfree (valid_adl_device_list);
12958 myfree (lpAdapterInfo);
12959 }
12960 }
12961 #endif // HAVE_ADL
12962
12963 if (data.hm_amd == NULL && data.hm_nv == NULL)
12964 {
12965 gpu_temp_disable = 1;
12966 }
12967 }
12968
12969 /**
12970 * OpenCL devices: allocate buffer for device specific information
12971 */
12972
12973 #ifdef HAVE_HWMON
12974 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
12975
12976 #ifdef HAVE_ADL
12977 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
12978
12979 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
12980 #endif // ADL
12981 #endif
12982
12983 /**
12984 * enable custom signal handler(s)
12985 */
12986
12987 if (benchmark == 0)
12988 {
12989 hc_signal (sigHandler_default);
12990 }
12991 else
12992 {
12993 hc_signal (sigHandler_benchmark);
12994 }
12995
12996 /**
12997 * User-defined GPU temp handling
12998 */
12999
13000 #ifdef HAVE_HWMON
13001 if (gpu_temp_disable == 1)
13002 {
13003 gpu_temp_abort = 0;
13004 gpu_temp_retain = 0;
13005 }
13006
13007 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13008 {
13009 if (gpu_temp_abort < gpu_temp_retain)
13010 {
13011 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13012
13013 return (-1);
13014 }
13015 }
13016
13017 data.gpu_temp_disable = gpu_temp_disable;
13018 data.gpu_temp_abort = gpu_temp_abort;
13019 data.gpu_temp_retain = gpu_temp_retain;
13020 #endif
13021
13022 /**
13023 * inform the user
13024 */
13025
13026 if (data.quiet == 0)
13027 {
13028 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13029
13030 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);
13031
13032 if (attack_mode == ATTACK_MODE_STRAIGHT)
13033 {
13034 log_info ("Rules: %u", kernel_rules_cnt);
13035 }
13036
13037 if (opti_type)
13038 {
13039 log_info ("Applicable Optimizers:");
13040
13041 for (uint i = 0; i < 32; i++)
13042 {
13043 const uint opti_bit = 1u << i;
13044
13045 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13046 }
13047 }
13048
13049 /**
13050 * Watchdog and Temperature balance
13051 */
13052
13053 #ifdef HAVE_HWMON
13054 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13055 {
13056 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13057 }
13058
13059 if (gpu_temp_abort == 0)
13060 {
13061 log_info ("Watchdog: Temperature abort trigger disabled");
13062 }
13063 else
13064 {
13065 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13066 }
13067
13068 if (gpu_temp_retain == 0)
13069 {
13070 log_info ("Watchdog: Temperature retain trigger disabled");
13071 }
13072 else
13073 {
13074 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13075 }
13076 #endif
13077 }
13078
13079 if (data.quiet == 0) log_info ("");
13080
13081 /**
13082 * HM devices: copy
13083 */
13084
13085 if (gpu_temp_disable == 0)
13086 {
13087 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13088 {
13089 hc_device_param_t *device_param = &data.devices_param[device_id];
13090
13091 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13092
13093 if (device_param->skipped) continue;
13094
13095 const uint platform_devices_id = device_param->platform_devices_id;
13096
13097 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13098 if (device_param->vendor_id == VENDOR_ID_NV)
13099 {
13100 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13101 }
13102 #endif
13103
13104 #ifdef HAVE_ADL
13105 if (device_param->vendor_id == VENDOR_ID_AMD)
13106 {
13107 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13108 }
13109 #endif
13110 }
13111 }
13112
13113 /*
13114 * Temporary fix:
13115 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13116 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13117 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13118 * Driver / ADL bug?
13119 */
13120
13121 #ifdef HAVE_ADL
13122 if (powertune_enable == 1)
13123 {
13124 hc_thread_mutex_lock (mux_adl);
13125
13126 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13127 {
13128 hc_device_param_t *device_param = &data.devices_param[device_id];
13129
13130 if (device_param->skipped) continue;
13131
13132 if (data.hm_device[device_id].od_version == 6)
13133 {
13134 // set powertune value only
13135
13136 int powertune_supported = 0;
13137
13138 int ADL_rc = 0;
13139
13140 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13141 {
13142 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13143
13144 return (-1);
13145 }
13146
13147 if (powertune_supported != 0)
13148 {
13149 // powertune set
13150 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13151
13152 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13153 {
13154 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13155
13156 return (-1);
13157 }
13158
13159 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13160 {
13161 log_error ("ERROR: Failed to set new ADL PowerControl values");
13162
13163 return (-1);
13164 }
13165 }
13166 }
13167 }
13168
13169 hc_thread_mutex_unlock (mux_adl);
13170 }
13171 #endif // HAVE_ADK
13172 #endif // HAVE_HWMON
13173
13174 #ifdef OSX
13175 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13176 {
13177 if (force == 0)
13178 {
13179 log_info ("");
13180 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13181 log_info ("You can use --force to override this but do not post error reports if you do so");
13182 log_info ("");
13183
13184 continue;
13185 }
13186 }
13187 #endif
13188
13189 #ifdef DEBUG
13190 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13191 #endif
13192
13193 uint kernel_blocks_all = 0;
13194
13195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13196 {
13197 /**
13198 * host buffer
13199 */
13200
13201 hc_device_param_t *device_param = &data.devices_param[device_id];
13202
13203 if (device_param->skipped) continue;
13204
13205 /**
13206 * device properties
13207 */
13208
13209 char *device_name_chksum = device_param->device_name_chksum;
13210
13211 uint device_processors = device_param->device_processors;
13212
13213 uint device_processor_cores = device_param->device_processor_cores;
13214
13215 uint kernel_accel = device_param->kernel_accel;
13216
13217 /**
13218 * create context for each device
13219 */
13220
13221 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13222
13223 /**
13224 * create command-queue
13225 */
13226
13227 // not supported with NV
13228 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13229
13230 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13231
13232 /**
13233 * create input buffers on device
13234 */
13235
13236 uint kernel_threads = KERNEL_THREADS;
13237
13238 // bcrypt
13239 if (hash_mode == 3200) kernel_threads = 8;
13240 if (hash_mode == 9000) kernel_threads = 8;
13241
13242 uint kernel_power = 1;
13243 uint kernel_blocks = 1;
13244
13245 uint size_pws = 4;
13246 uint size_tmps = 4;
13247 uint size_hooks = 4;
13248
13249 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13250
13251 while (kernel_accel)
13252 {
13253 kernel_power = device_processors * kernel_threads * kernel_accel;
13254 kernel_blocks = kernel_power;
13255
13256 // size_pws
13257
13258 size_pws = kernel_blocks * sizeof (pw_t);
13259
13260 // size_tmps
13261
13262 switch (hash_mode)
13263 {
13264 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13265 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13266 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13267 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13268 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13269 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13270 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13271 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13272 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13273 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13274 case 6211:
13275 case 6212:
13276 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13277 case 6221:
13278 case 6222:
13279 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13280 case 6231:
13281 case 6232:
13282 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13283 case 6241:
13284 case 6242:
13285 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13286 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13287 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13288 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13289 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13290 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13291 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13292 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13293 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13294 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13295 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13296 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13297 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13298 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13299 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13300 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13301 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13302 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13303 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13304 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13305 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13306 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13307 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13308 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13309 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13310 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13311 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13312 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13313 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13314 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13315 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13316 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13317 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13318 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13319 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13320 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13321 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13322 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13323 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13324 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13325 };
13326
13327 // size_hooks
13328
13329 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13330 {
13331 // none yet
13332 }
13333
13334 // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
13335 // if not, decrease amplifier and try again
13336
13337 if (size_pws > device_param->device_maxmem_alloc)
13338 {
13339 kernel_accel--;
13340
13341 continue;
13342 }
13343
13344 if (size_tmps > device_param->device_maxmem_alloc)
13345 {
13346 kernel_accel--;
13347
13348 continue;
13349 }
13350
13351 if (size_hooks > device_param->device_maxmem_alloc)
13352 {
13353 kernel_accel--;
13354
13355 continue;
13356 }
13357
13358 if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
13359 {
13360 kernel_accel--;
13361
13362 continue;
13363 }
13364
13365 break;
13366 }
13367
13368 if (kernel_accel == 0)
13369 {
13370 log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13371
13372 return -1;
13373 }
13374
13375 device_param->kernel_threads = kernel_threads;
13376 device_param->kernel_power_user = kernel_power;
13377 device_param->kernel_blocks_user = kernel_blocks;
13378
13379 kernel_blocks_all += kernel_blocks;
13380
13381 device_param->size_pws = size_pws;
13382 device_param->size_tmps = size_tmps;
13383 device_param->size_hooks = size_hooks;
13384
13385 // we can optimize some stuff here...
13386
13387 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13388 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13389
13390 device_param->size_root_css = size_root_css;
13391 device_param->size_markov_css = size_markov_css;
13392
13393 uint size_results = KERNEL_THREADS * sizeof (uint);
13394
13395 device_param->size_results = size_results;
13396
13397 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13398 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13399
13400 uint size_plains = digests_cnt * sizeof (plain_t);
13401 uint size_salts = salts_cnt * sizeof (salt_t);
13402 uint size_esalts = salts_cnt * esalt_size;
13403
13404 device_param->size_plains = size_plains;
13405 device_param->size_digests = size_digests;
13406 device_param->size_shown = size_shown;
13407 device_param->size_salts = size_salts;
13408
13409 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13410 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13411 uint size_tm = 32 * sizeof (bs_word_t);
13412
13413 // scrypt stuff
13414
13415 u64 size_scryptV = 1;
13416
13417 if ((hash_mode == 8900) || (hash_mode == 9300))
13418 {
13419 uint tmto_start = 0;
13420 uint tmto_stop = 10;
13421
13422 if (scrypt_tmto)
13423 {
13424 tmto_start = scrypt_tmto;
13425 }
13426 else
13427 {
13428 // in case the user did not specify the tmto manually
13429 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13430 // but set the lower end only in case the user has a device with too less memory
13431
13432 if (hash_mode == 8900)
13433 {
13434 if (device_param->vendor_id == VENDOR_ID_AMD)
13435 {
13436 tmto_start = 1;
13437 }
13438 else if (device_param->vendor_id == VENDOR_ID_NV)
13439 {
13440 tmto_start = 3;
13441 }
13442 }
13443 else if (hash_mode == 9300)
13444 {
13445 if (device_param->vendor_id == VENDOR_ID_AMD)
13446 {
13447 tmto_start = 3;
13448 }
13449 else if (device_param->vendor_id == VENDOR_ID_NV)
13450 {
13451 tmto_start = 5;
13452 }
13453 }
13454 }
13455
13456 if (quiet == 0) log_info ("");
13457
13458 uint shader_per_mp = 1;
13459
13460 if (device_param->vendor_id == VENDOR_ID_AMD)
13461 {
13462 shader_per_mp = 8;
13463 }
13464 else if (device_param->vendor_id == VENDOR_ID_NV)
13465 {
13466 shader_per_mp = 32;
13467 }
13468
13469 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13470 {
13471 // TODO: in theory the following calculation needs to be done per salt, not global
13472 // we assume all hashes have the same scrypt settings
13473
13474 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13475
13476 size_scryptV /= 1 << tmto;
13477
13478 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13479
13480 if (size_scryptV > device_param->device_maxmem_alloc)
13481 {
13482 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13483
13484 continue;
13485 }
13486
13487 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13488 {
13489 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13490 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13491 }
13492
13493 break;
13494 }
13495
13496 if (data.salts_buf[0].scrypt_phy == 0)
13497 {
13498 log_error ("ERROR: can't allocate enough device memory");
13499
13500 return -1;
13501 }
13502
13503 if (quiet == 0) log_info ("");
13504 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13505 }
13506
13507 /**
13508 * default building options
13509 */
13510
13511 char build_opts[1024] = { 0 };
13512
13513 // we don't have sm_* on vendors not NV but it doesn't matter
13514
13515 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);
13516
13517 /**
13518 * main kernel
13519 */
13520
13521 {
13522 /**
13523 * kernel source filename
13524 */
13525
13526 char source_file[256] = { 0 };
13527
13528 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13529
13530 struct stat sst;
13531
13532 if (stat (source_file, &sst) == -1)
13533 {
13534 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13535
13536 return -1;
13537 }
13538
13539 /**
13540 * kernel cached filename
13541 */
13542
13543 char cached_file[256] = { 0 };
13544
13545 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13546
13547 int cached = 1;
13548
13549 struct stat cst;
13550
13551 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13552 {
13553 cached = 0;
13554 }
13555
13556 /**
13557 * kernel compile or load
13558 */
13559
13560 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13561
13562 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13563
13564 if (force_jit_compilation == -1)
13565 {
13566 if (cached == 0)
13567 {
13568 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13569
13570 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13571
13572 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13573
13574 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13575
13576 if (rc != 0)
13577 {
13578 device_param->skipped = true;
13579 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13580 continue;
13581 }
13582
13583 size_t binary_size;
13584
13585 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13586
13587 u8 *binary = (u8 *) mymalloc (binary_size);
13588
13589 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13590
13591 writeProgramBin (cached_file, binary, binary_size);
13592
13593 local_free (binary);
13594 }
13595 else
13596 {
13597 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13598
13599 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13600
13601 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13602
13603 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13604 }
13605 }
13606 else
13607 {
13608 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13609
13610 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13611
13612 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13613
13614 char build_opts_update[1024] = { 0 };
13615
13616 if (force_jit_compilation == 1500)
13617 {
13618 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13619 }
13620 else if (force_jit_compilation == 8900)
13621 {
13622 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);
13623 }
13624
13625 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13626
13627 if (rc != 0)
13628 {
13629 device_param->skipped = true;
13630 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13631 }
13632 }
13633
13634 local_free (kernel_lengths);
13635 local_free (kernel_sources[0]);
13636 local_free (kernel_sources);
13637 }
13638
13639 /**
13640 * word generator kernel
13641 */
13642
13643 if (attack_mode != ATTACK_MODE_STRAIGHT)
13644 {
13645 /**
13646 * kernel mp source filename
13647 */
13648
13649 char source_file[256] = { 0 };
13650
13651 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13652
13653 struct stat sst;
13654
13655 if (stat (source_file, &sst) == -1)
13656 {
13657 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13658
13659 return -1;
13660 }
13661
13662 /**
13663 * kernel mp cached filename
13664 */
13665
13666 char cached_file[256] = { 0 };
13667
13668 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13669
13670 int cached = 1;
13671
13672 struct stat cst;
13673
13674 if (stat (cached_file, &cst) == -1)
13675 {
13676 cached = 0;
13677 }
13678
13679 /**
13680 * kernel compile or load
13681 */
13682
13683 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13684
13685 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13686
13687 if (cached == 0)
13688 {
13689 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13690
13691 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13692
13693 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13694
13695 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13696
13697 if (rc != 0)
13698 {
13699 device_param->skipped = true;
13700 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13701 continue;
13702 }
13703
13704 size_t binary_size;
13705
13706 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13707
13708 u8 *binary = (u8 *) mymalloc (binary_size);
13709
13710 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13711
13712 writeProgramBin (cached_file, binary, binary_size);
13713
13714 local_free (binary);
13715 }
13716 else
13717 {
13718 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13719
13720 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13721
13722 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13723
13724 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13725 }
13726
13727 local_free (kernel_lengths);
13728 local_free (kernel_sources[0]);
13729 local_free (kernel_sources);
13730 }
13731
13732 /**
13733 * amplifier kernel
13734 */
13735
13736 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13737 {
13738
13739 }
13740 else
13741 {
13742 /**
13743 * kernel amp source filename
13744 */
13745
13746 char source_file[256] = { 0 };
13747
13748 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13749
13750 struct stat sst;
13751
13752 if (stat (source_file, &sst) == -1)
13753 {
13754 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13755
13756 return -1;
13757 }
13758
13759 /**
13760 * kernel amp cached filename
13761 */
13762
13763 char cached_file[256] = { 0 };
13764
13765 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13766
13767 int cached = 1;
13768
13769 struct stat cst;
13770
13771 if (stat (cached_file, &cst) == -1)
13772 {
13773 cached = 0;
13774 }
13775
13776 /**
13777 * kernel compile or load
13778 */
13779
13780 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13781
13782 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13783
13784 if (cached == 0)
13785 {
13786 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13787
13788 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13789
13790 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13791
13792 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13793
13794 if (rc != 0)
13795 {
13796 device_param->skipped = true;
13797 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13798 continue;
13799 }
13800
13801 size_t binary_size;
13802
13803 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13804
13805 u8 *binary = (u8 *) mymalloc (binary_size);
13806
13807 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13808
13809 writeProgramBin (cached_file, binary, binary_size);
13810
13811 local_free (binary);
13812 }
13813 else
13814 {
13815 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13816
13817 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13818
13819 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13820
13821 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
13822 }
13823
13824 local_free (kernel_lengths);
13825 local_free (kernel_sources[0]);
13826 local_free (kernel_sources);
13827 }
13828
13829 // some algorithm collide too fast, make that impossible
13830
13831 if (benchmark == 1)
13832 {
13833 ((uint *) digests_buf)[0] = -1;
13834 ((uint *) digests_buf)[1] = -1;
13835 ((uint *) digests_buf)[2] = -1;
13836 ((uint *) digests_buf)[3] = -1;
13837 }
13838
13839 /**
13840 * global buffers
13841 */
13842
13843 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13844 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13845 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13846 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13847 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13848 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13849 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13850 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13851 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13852 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13853 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13854 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13855 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13856 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13857 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13858 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13859 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13860 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13861
13862 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);
13863 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);
13864 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);
13865 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);
13866 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);
13867 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);
13868 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);
13869 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);
13870 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13871 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13872 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13873
13874 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13875 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13876 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13877 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13878 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13879 run_kernel_bzero (device_param, device_param->d_result, size_results);
13880
13881 /**
13882 * special buffers
13883 */
13884
13885 if (attack_kern == ATTACK_KERN_STRAIGHT)
13886 {
13887 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13888 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13889
13890 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13891
13892 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13893 }
13894 else if (attack_kern == ATTACK_KERN_COMBI)
13895 {
13896 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13897 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13898 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13899 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13900
13901 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13902 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13903 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13904 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13905 }
13906 else if (attack_kern == ATTACK_KERN_BF)
13907 {
13908 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13909 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13910 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13911 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13912 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13913
13914 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13915 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13916 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13917 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13918 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13919 }
13920
13921 if (size_esalts)
13922 {
13923 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13924
13925 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13926 }
13927
13928 /**
13929 * main host data
13930 */
13931
13932 uint *result = (uint *) mymalloc (size_results);
13933
13934 device_param->result = result;
13935
13936 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13937
13938 device_param->pws_buf = pws_buf;
13939
13940 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13941
13942 for (int i = 0; i < 64; i++)
13943 {
13944 pw_caches[i].pw_buf.pw_len = i;
13945 pw_caches[i].cnt = 0;
13946 }
13947
13948 device_param->pw_caches = pw_caches;
13949
13950 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13951
13952 device_param->combs_buf = combs_buf;
13953
13954 void *hooks_buf = mymalloc (size_hooks);
13955
13956 device_param->hooks_buf = hooks_buf;
13957
13958 device_param->pw_transpose = pw_transpose_to_hi1;
13959 device_param->pw_add = pw_add_to_hc1;
13960
13961 /**
13962 * kernel args
13963 */
13964
13965 device_param->kernel_params_buf32[21] = bitmap_mask;
13966 device_param->kernel_params_buf32[22] = bitmap_shift1;
13967 device_param->kernel_params_buf32[23] = bitmap_shift2;
13968 device_param->kernel_params_buf32[24] = 0; // salt_pos
13969 device_param->kernel_params_buf32[25] = 0; // loop_pos
13970 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13971 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13972 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13973 device_param->kernel_params_buf32[29] = 0; // digests_offset
13974 device_param->kernel_params_buf32[30] = 0; // combs_mode
13975 device_param->kernel_params_buf32[31] = 0; // gid_max
13976
13977 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13978 ? &device_param->d_pws_buf
13979 : &device_param->d_pws_amp_buf;
13980 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13981 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13982 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13983 device_param->kernel_params[ 4] = &device_param->d_tmps;
13984 device_param->kernel_params[ 5] = &device_param->d_hooks;
13985 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13986 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13987 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13988 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13989 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13990 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13991 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13992 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13993 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13994 device_param->kernel_params[15] = &device_param->d_digests_buf;
13995 device_param->kernel_params[16] = &device_param->d_digests_shown;
13996 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13997 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13998 device_param->kernel_params[19] = &device_param->d_result;
13999 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14000 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14001 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14002 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14003 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14004 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14005 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14006 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14007 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14008 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14009 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14010 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14011
14012 device_param->kernel_params_mp_buf64[3] = 0;
14013 device_param->kernel_params_mp_buf32[4] = 0;
14014 device_param->kernel_params_mp_buf32[5] = 0;
14015 device_param->kernel_params_mp_buf32[6] = 0;
14016 device_param->kernel_params_mp_buf32[7] = 0;
14017 device_param->kernel_params_mp_buf32[8] = 0;
14018
14019 device_param->kernel_params_mp[0] = NULL;
14020 device_param->kernel_params_mp[1] = NULL;
14021 device_param->kernel_params_mp[2] = NULL;
14022 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14023 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14024 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14025 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14026 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14027 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14028
14029 device_param->kernel_params_mp_l_buf64[3] = 0;
14030 device_param->kernel_params_mp_l_buf32[4] = 0;
14031 device_param->kernel_params_mp_l_buf32[5] = 0;
14032 device_param->kernel_params_mp_l_buf32[6] = 0;
14033 device_param->kernel_params_mp_l_buf32[7] = 0;
14034 device_param->kernel_params_mp_l_buf32[8] = 0;
14035 device_param->kernel_params_mp_l_buf32[9] = 0;
14036
14037 device_param->kernel_params_mp_l[0] = NULL;
14038 device_param->kernel_params_mp_l[1] = NULL;
14039 device_param->kernel_params_mp_l[2] = NULL;
14040 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14041 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14042 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14043 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14044 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14045 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14046 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14047
14048 device_param->kernel_params_mp_r_buf64[3] = 0;
14049 device_param->kernel_params_mp_r_buf32[4] = 0;
14050 device_param->kernel_params_mp_r_buf32[5] = 0;
14051 device_param->kernel_params_mp_r_buf32[6] = 0;
14052 device_param->kernel_params_mp_r_buf32[7] = 0;
14053 device_param->kernel_params_mp_r_buf32[8] = 0;
14054
14055 device_param->kernel_params_mp_r[0] = NULL;
14056 device_param->kernel_params_mp_r[1] = NULL;
14057 device_param->kernel_params_mp_r[2] = NULL;
14058 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14059 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14060 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14061 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14062 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14063 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14064
14065 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14066 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14067
14068 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14069 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14070 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14071 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14072 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14073 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14074 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14075
14076 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14077
14078 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14079 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14080
14081 /**
14082 * kernel name
14083 */
14084
14085 char kernel_name[64] = { 0 };
14086
14087 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14088 {
14089 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14090 {
14091 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14092
14093 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14094
14095 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14096
14097 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14098
14099 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14100
14101 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14102 }
14103 else
14104 {
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14106
14107 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14108
14109 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14110
14111 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14112
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14114
14115 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14116 }
14117
14118 if (data.attack_mode == ATTACK_MODE_BF)
14119 {
14120 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14121 {
14122 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14123
14124 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14125
14126 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14127
14128 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14129 }
14130 }
14131 }
14132 else
14133 {
14134 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14135
14136 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14137
14138 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14139
14140 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14141
14142 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14143
14144 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14145
14146 if (opts_type & OPTS_TYPE_HOOK12)
14147 {
14148 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14149
14150 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14151 }
14152
14153 if (opts_type & OPTS_TYPE_HOOK23)
14154 {
14155 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14156
14157 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14158 }
14159 }
14160
14161 for (uint i = 0; i <= 20; i++)
14162 {
14163 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14164 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14165 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14166
14167 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14168 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14169 }
14170
14171 for (uint i = 21; i <= 31; i++)
14172 {
14173 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14174 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14175 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14176
14177 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14178 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14179 }
14180
14181 if (attack_mode == ATTACK_MODE_BF)
14182 {
14183 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14184 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14185
14186 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14187 {
14188 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14189
14190 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14191 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14192 }
14193 }
14194 else if (attack_mode == ATTACK_MODE_HYBRID1)
14195 {
14196 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14197 }
14198 else if (attack_mode == ATTACK_MODE_HYBRID2)
14199 {
14200 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14201 }
14202
14203 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14204 {
14205 // nothing to do
14206 }
14207 else
14208 {
14209 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14210 }
14211
14212 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14213 {
14214 // nothing to do
14215 }
14216 else
14217 {
14218 for (uint i = 0; i < 5; i++)
14219 {
14220 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14221 }
14222
14223 for (uint i = 5; i < 7; i++)
14224 {
14225 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14226 }
14227 }
14228
14229 /**
14230 * Store initial fanspeed if gpu_temp_retain is enabled
14231 */
14232
14233 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14234 int gpu_temp_retain_set = 0;
14235
14236 if (gpu_temp_disable == 0)
14237 {
14238 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14239 {
14240 hc_thread_mutex_lock (mux_adl);
14241
14242 if (data.hm_device[device_id].fan_supported == 1)
14243 {
14244 if (gpu_temp_retain_chgd == 0)
14245 {
14246 uint cur_temp = 0;
14247 uint default_temp = 0;
14248
14249 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);
14250
14251 if (ADL_rc == ADL_OK)
14252 {
14253 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14254
14255 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14256
14257 // special case with multi gpu setups: always use minimum retain
14258
14259 if (gpu_temp_retain_set == 0)
14260 {
14261 gpu_temp_retain = gpu_temp_retain_target;
14262 gpu_temp_retain_set = 1;
14263 }
14264 else
14265 {
14266 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14267 }
14268
14269 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14270 }
14271 }
14272
14273 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14274
14275 temp_retain_fanspeed_value[device_id] = fan_speed;
14276
14277 if (fan_speed == -1)
14278 {
14279 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14280
14281 temp_retain_fanspeed_value[device_id] = 0;
14282 }
14283 }
14284
14285 hc_thread_mutex_unlock (mux_adl);
14286 }
14287 }
14288
14289 /**
14290 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14291 */
14292
14293 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14294 {
14295 hc_thread_mutex_lock (mux_adl);
14296
14297 if (data.hm_device[device_id].od_version == 6)
14298 {
14299 int ADL_rc;
14300
14301 // check powertune capabilities first, if not available then skip device
14302
14303 int powertune_supported = 0;
14304
14305 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14306 {
14307 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14308
14309 return (-1);
14310 }
14311
14312 if (powertune_supported != 0)
14313 {
14314 // powercontrol settings
14315
14316 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14317
14318 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14319 {
14320 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14321 }
14322
14323 if (ADL_rc != ADL_OK)
14324 {
14325 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14326
14327 return (-1);
14328 }
14329
14330 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14331 {
14332 log_error ("ERROR: Failed to set new ADL PowerControl values");
14333
14334 return (-1);
14335 }
14336
14337 // clocks
14338
14339 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14340
14341 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14342
14343 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)
14344 {
14345 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14346
14347 return (-1);
14348 }
14349
14350 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14351
14352 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14353
14354 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14355 {
14356 log_error ("ERROR: Failed to get ADL device capabilities");
14357
14358 return (-1);
14359 }
14360
14361 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14362 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14363
14364 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14365 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14366
14367 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14368 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14369
14370 // warning if profile has too low max values
14371
14372 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14373 {
14374 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14375 }
14376
14377 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14378 {
14379 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14380 }
14381
14382 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14383
14384 performance_state->iNumberOfPerformanceLevels = 2;
14385
14386 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14387 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14388 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14389 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14390
14391 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)
14392 {
14393 log_info ("ERROR: Failed to set ADL performance state");
14394
14395 return (-1);
14396 }
14397
14398 local_free (performance_state);
14399 }
14400 }
14401
14402 hc_thread_mutex_unlock (mux_adl);
14403 }
14404 #endif // HAVE_HWMON && HAVE_ADL
14405 }
14406
14407 data.kernel_blocks_all = kernel_blocks_all;
14408
14409 if (data.quiet == 0) log_info ("");
14410
14411 /**
14412 * Inform user which algorithm is checked and at which workload setting
14413 */
14414
14415 if (benchmark == 1)
14416 {
14417 quiet = 0;
14418
14419 data.quiet = quiet;
14420
14421 char *hash_type = strhashtype (data.hash_mode); // not a bug
14422
14423 log_info ("Hashtype: %s", hash_type);
14424 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14425 log_info ("");
14426 }
14427
14428 /**
14429 * keep track of the progress
14430 */
14431
14432 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14433 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14434 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14435
14436 /**
14437 * open filehandles
14438 */
14439
14440 #if _WIN
14441 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14442 {
14443 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14444
14445 return (-1);
14446 }
14447
14448 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14449 {
14450 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14451
14452 return (-1);
14453 }
14454
14455 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14456 {
14457 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14458
14459 return (-1);
14460 }
14461 #endif
14462
14463 /**
14464 * dictionary pad
14465 */
14466
14467 segment_size *= (1024 * 1024);
14468
14469 data.segment_size = segment_size;
14470
14471 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14472
14473 wl_data->buf = (char *) mymalloc (segment_size);
14474 wl_data->avail = segment_size;
14475 wl_data->incr = segment_size;
14476 wl_data->cnt = 0;
14477 wl_data->pos = 0;
14478
14479 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14480
14481 data.wordlist_mode = wordlist_mode;
14482
14483 cs_t *css_buf = NULL;
14484 uint css_cnt = 0;
14485 uint dictcnt = 0;
14486 uint maskcnt = 1;
14487 char **masks = NULL;
14488 char **dictfiles = NULL;
14489
14490 uint mask_from_file = 0;
14491
14492 if (attack_mode == ATTACK_MODE_STRAIGHT)
14493 {
14494 if (wordlist_mode == WL_MODE_FILE)
14495 {
14496 int wls_left = myargc - (optind + 1);
14497
14498 for (int i = 0; i < wls_left; i++)
14499 {
14500 char *l0_filename = myargv[optind + 1 + i];
14501
14502 struct stat l0_stat;
14503
14504 if (stat (l0_filename, &l0_stat) == -1)
14505 {
14506 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14507
14508 return (-1);
14509 }
14510
14511 uint is_dir = S_ISDIR (l0_stat.st_mode);
14512
14513 if (is_dir == 0)
14514 {
14515 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14516
14517 dictcnt++;
14518
14519 dictfiles[dictcnt - 1] = l0_filename;
14520 }
14521 else
14522 {
14523 // do not allow --keyspace w/ a directory
14524
14525 if (keyspace == 1)
14526 {
14527 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14528
14529 return (-1);
14530 }
14531
14532 char **dictionary_files = NULL;
14533
14534 dictionary_files = scan_directory (l0_filename);
14535
14536 if (dictionary_files != NULL)
14537 {
14538 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14539
14540 for (int d = 0; dictionary_files[d] != NULL; d++)
14541 {
14542 char *l1_filename = dictionary_files[d];
14543
14544 struct stat l1_stat;
14545
14546 if (stat (l1_filename, &l1_stat) == -1)
14547 {
14548 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14549
14550 return (-1);
14551 }
14552
14553 if (S_ISREG (l1_stat.st_mode))
14554 {
14555 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14556
14557 dictcnt++;
14558
14559 dictfiles[dictcnt - 1] = strdup (l1_filename);
14560 }
14561 }
14562 }
14563
14564 local_free (dictionary_files);
14565 }
14566 }
14567
14568 if (dictcnt < 1)
14569 {
14570 log_error ("ERROR: No usable dictionary file found.");
14571
14572 return (-1);
14573 }
14574 }
14575 else if (wordlist_mode == WL_MODE_STDIN)
14576 {
14577 dictcnt = 1;
14578 }
14579 }
14580 else if (attack_mode == ATTACK_MODE_COMBI)
14581 {
14582 // display
14583
14584 char *dictfile1 = myargv[optind + 1 + 0];
14585 char *dictfile2 = myargv[optind + 1 + 1];
14586
14587 // find the bigger dictionary and use as base
14588
14589 FILE *fp1 = NULL;
14590 FILE *fp2 = NULL;
14591
14592 struct stat tmp_stat;
14593
14594 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14595 {
14596 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14597
14598 return (-1);
14599 }
14600
14601 if (stat (dictfile1, &tmp_stat) == -1)
14602 {
14603 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14604
14605 fclose (fp1);
14606
14607 return (-1);
14608 }
14609
14610 if (S_ISDIR (tmp_stat.st_mode))
14611 {
14612 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14613
14614 fclose (fp1);
14615
14616 return (-1);
14617 }
14618
14619 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14620 {
14621 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14622
14623 fclose (fp1);
14624
14625 return (-1);
14626 }
14627
14628 if (stat (dictfile2, &tmp_stat) == -1)
14629 {
14630 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14631
14632 fclose (fp1);
14633 fclose (fp2);
14634
14635 return (-1);
14636 }
14637
14638 if (S_ISDIR (tmp_stat.st_mode))
14639 {
14640 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14641
14642 fclose (fp1);
14643 fclose (fp2);
14644
14645 return (-1);
14646 }
14647
14648 data.combs_cnt = 1;
14649
14650 data.quiet = 1;
14651
14652 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14653
14654 data.quiet = quiet;
14655
14656 if (words1_cnt == 0)
14657 {
14658 log_error ("ERROR: %s: empty file", dictfile1);
14659
14660 fclose (fp1);
14661 fclose (fp2);
14662
14663 return (-1);
14664 }
14665
14666 data.combs_cnt = 1;
14667
14668 data.quiet = 1;
14669
14670 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14671
14672 data.quiet = quiet;
14673
14674 if (words2_cnt == 0)
14675 {
14676 log_error ("ERROR: %s: empty file", dictfile2);
14677
14678 fclose (fp1);
14679 fclose (fp2);
14680
14681 return (-1);
14682 }
14683
14684 fclose (fp1);
14685 fclose (fp2);
14686
14687 data.dictfile = dictfile1;
14688 data.dictfile2 = dictfile2;
14689
14690 if (words1_cnt >= words2_cnt)
14691 {
14692 data.combs_cnt = words2_cnt;
14693 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14694
14695 dictfiles = &data.dictfile;
14696
14697 dictcnt = 1;
14698 }
14699 else
14700 {
14701 data.combs_cnt = words1_cnt;
14702 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14703
14704 dictfiles = &data.dictfile2;
14705
14706 dictcnt = 1;
14707
14708 // we also have to switch wordlist related rules!
14709
14710 char *tmpc = data.rule_buf_l;
14711
14712 data.rule_buf_l = data.rule_buf_r;
14713 data.rule_buf_r = tmpc;
14714
14715 int tmpi = data.rule_len_l;
14716
14717 data.rule_len_l = data.rule_len_r;
14718 data.rule_len_r = tmpi;
14719 }
14720 }
14721 else if (attack_mode == ATTACK_MODE_BF)
14722 {
14723 char *mask = NULL;
14724
14725 maskcnt = 0;
14726
14727 if (benchmark == 0)
14728 {
14729 mask = myargv[optind + 1];
14730
14731 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14732
14733 if ((optind + 2) <= myargc)
14734 {
14735 struct stat file_stat;
14736
14737 if (stat (mask, &file_stat) == -1)
14738 {
14739 maskcnt = 1;
14740
14741 masks[maskcnt - 1] = mystrdup (mask);
14742 }
14743 else
14744 {
14745 int wls_left = myargc - (optind + 1);
14746
14747 uint masks_avail = INCR_MASKS;
14748
14749 for (int i = 0; i < wls_left; i++)
14750 {
14751 if (i != 0)
14752 {
14753 mask = myargv[optind + 1 + i];
14754
14755 if (stat (mask, &file_stat) == -1)
14756 {
14757 log_error ("ERROR: %s: %s", mask, strerror (errno));
14758
14759 return (-1);
14760 }
14761 }
14762
14763 uint is_file = S_ISREG (file_stat.st_mode);
14764
14765 if (is_file == 1)
14766 {
14767 FILE *mask_fp;
14768
14769 if ((mask_fp = fopen (mask, "r")) == NULL)
14770 {
14771 log_error ("ERROR: %s: %s", mask, strerror (errno));
14772
14773 return (-1);
14774 }
14775
14776 char line_buf[BUFSIZ] = { 0 };
14777
14778 while (!feof (mask_fp))
14779 {
14780 memset (line_buf, 0, BUFSIZ);
14781
14782 int line_len = fgetl (mask_fp, line_buf);
14783
14784 if (line_len == 0) continue;
14785
14786 if (line_buf[0] == '#') continue;
14787
14788 if (masks_avail == maskcnt)
14789 {
14790 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14791
14792 masks_avail += INCR_MASKS;
14793 }
14794
14795 masks[maskcnt] = mystrdup (line_buf);
14796
14797 maskcnt++;
14798 }
14799
14800 fclose (mask_fp);
14801 }
14802 else
14803 {
14804 log_error ("ERROR: %s: unsupported file-type", mask);
14805
14806 return (-1);
14807 }
14808 }
14809
14810 mask_from_file = 1;
14811 }
14812 }
14813 else
14814 {
14815 custom_charset_1 = (char *) "?l?d?u";
14816 custom_charset_2 = (char *) "?l?d";
14817 custom_charset_3 = (char *) "?l?d*!$@_";
14818
14819 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14820 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14821 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14822
14823 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14824
14825 wordlist_mode = WL_MODE_MASK;
14826
14827 data.wordlist_mode = wordlist_mode;
14828
14829 increment = 1;
14830
14831 maskcnt = 1;
14832 }
14833 }
14834 else
14835 {
14836 /**
14837 * generate full masks and charsets
14838 */
14839
14840 masks = (char **) mymalloc (sizeof (char *));
14841
14842 switch (hash_mode)
14843 {
14844 case 1731: pw_min = 5;
14845 pw_max = 5;
14846 mask = mystrdup ("?b?b?b?b?b");
14847 break;
14848 case 12500: pw_min = 5;
14849 pw_max = 5;
14850 mask = mystrdup ("?b?b?b?b?b");
14851 break;
14852 default: pw_min = 7;
14853 pw_max = 7;
14854 mask = mystrdup ("?b?b?b?b?b?b?b");
14855 break;
14856 }
14857
14858 maskcnt = 1;
14859
14860 masks[maskcnt - 1] = mystrdup (mask);
14861
14862 wordlist_mode = WL_MODE_MASK;
14863
14864 data.wordlist_mode = wordlist_mode;
14865
14866 increment = 1;
14867 }
14868
14869 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14870
14871 if (increment)
14872 {
14873 if (increment_min > pw_min) pw_min = increment_min;
14874
14875 if (increment_max < pw_max) pw_max = increment_max;
14876 }
14877 }
14878 else if (attack_mode == ATTACK_MODE_HYBRID1)
14879 {
14880 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14881
14882 // display
14883
14884 char *mask = myargv[myargc - 1];
14885
14886 maskcnt = 0;
14887
14888 masks = (char **) mymalloc (1 * sizeof (char *));
14889
14890 // mod
14891
14892 struct stat file_stat;
14893
14894 if (stat (mask, &file_stat) == -1)
14895 {
14896 maskcnt = 1;
14897
14898 masks[maskcnt - 1] = mystrdup (mask);
14899 }
14900 else
14901 {
14902 uint is_file = S_ISREG (file_stat.st_mode);
14903
14904 if (is_file == 1)
14905 {
14906 FILE *mask_fp;
14907
14908 if ((mask_fp = fopen (mask, "r")) == NULL)
14909 {
14910 log_error ("ERROR: %s: %s", mask, strerror (errno));
14911
14912 return (-1);
14913 }
14914
14915 char line_buf[BUFSIZ] = { 0 };
14916
14917 uint masks_avail = 1;
14918
14919 while (!feof (mask_fp))
14920 {
14921 memset (line_buf, 0, BUFSIZ);
14922
14923 int line_len = fgetl (mask_fp, line_buf);
14924
14925 if (line_len == 0) continue;
14926
14927 if (line_buf[0] == '#') continue;
14928
14929 if (masks_avail == maskcnt)
14930 {
14931 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14932
14933 masks_avail += INCR_MASKS;
14934 }
14935
14936 masks[maskcnt] = mystrdup (line_buf);
14937
14938 maskcnt++;
14939 }
14940
14941 fclose (mask_fp);
14942
14943 mask_from_file = 1;
14944 }
14945 else
14946 {
14947 maskcnt = 1;
14948
14949 masks[maskcnt - 1] = mystrdup (mask);
14950 }
14951 }
14952
14953 // base
14954
14955 int wls_left = myargc - (optind + 2);
14956
14957 for (int i = 0; i < wls_left; i++)
14958 {
14959 char *filename = myargv[optind + 1 + i];
14960
14961 struct stat file_stat;
14962
14963 if (stat (filename, &file_stat) == -1)
14964 {
14965 log_error ("ERROR: %s: %s", filename, strerror (errno));
14966
14967 return (-1);
14968 }
14969
14970 uint is_dir = S_ISDIR (file_stat.st_mode);
14971
14972 if (is_dir == 0)
14973 {
14974 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14975
14976 dictcnt++;
14977
14978 dictfiles[dictcnt - 1] = filename;
14979 }
14980 else
14981 {
14982 // do not allow --keyspace w/ a directory
14983
14984 if (keyspace == 1)
14985 {
14986 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14987
14988 return (-1);
14989 }
14990
14991 char **dictionary_files = NULL;
14992
14993 dictionary_files = scan_directory (filename);
14994
14995 if (dictionary_files != NULL)
14996 {
14997 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14998
14999 for (int d = 0; dictionary_files[d] != NULL; d++)
15000 {
15001 char *l1_filename = dictionary_files[d];
15002
15003 struct stat l1_stat;
15004
15005 if (stat (l1_filename, &l1_stat) == -1)
15006 {
15007 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15008
15009 return (-1);
15010 }
15011
15012 if (S_ISREG (l1_stat.st_mode))
15013 {
15014 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15015
15016 dictcnt++;
15017
15018 dictfiles[dictcnt - 1] = strdup (l1_filename);
15019 }
15020 }
15021 }
15022
15023 local_free (dictionary_files);
15024 }
15025 }
15026
15027 if (dictcnt < 1)
15028 {
15029 log_error ("ERROR: No usable dictionary file found.");
15030
15031 return (-1);
15032 }
15033
15034 if (increment)
15035 {
15036 maskcnt = 0;
15037
15038 uint mask_min = increment_min; // we can't reject smaller masks here
15039 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15040
15041 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15042 {
15043 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15044
15045 if (cur_mask == NULL) break;
15046
15047 masks[maskcnt] = cur_mask;
15048
15049 maskcnt++;
15050
15051 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15052 }
15053 }
15054 }
15055 else if (attack_mode == ATTACK_MODE_HYBRID2)
15056 {
15057 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15058
15059 // display
15060
15061 char *mask = myargv[optind + 1 + 0];
15062
15063 maskcnt = 0;
15064
15065 masks = (char **) mymalloc (1 * sizeof (char *));
15066
15067 // mod
15068
15069 struct stat file_stat;
15070
15071 if (stat (mask, &file_stat) == -1)
15072 {
15073 maskcnt = 1;
15074
15075 masks[maskcnt - 1] = mystrdup (mask);
15076 }
15077 else
15078 {
15079 uint is_file = S_ISREG (file_stat.st_mode);
15080
15081 if (is_file == 1)
15082 {
15083 FILE *mask_fp;
15084
15085 if ((mask_fp = fopen (mask, "r")) == NULL)
15086 {
15087 log_error ("ERROR: %s: %s", mask, strerror (errno));
15088
15089 return (-1);
15090 }
15091
15092 char line_buf[BUFSIZ] = { 0 };
15093
15094 uint masks_avail = 1;
15095
15096 while (!feof (mask_fp))
15097 {
15098 memset (line_buf, 0, BUFSIZ);
15099
15100 int line_len = fgetl (mask_fp, line_buf);
15101
15102 if (line_len == 0) continue;
15103
15104 if (line_buf[0] == '#') continue;
15105
15106 if (masks_avail == maskcnt)
15107 {
15108 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15109
15110 masks_avail += INCR_MASKS;
15111 }
15112
15113 masks[maskcnt] = mystrdup (line_buf);
15114
15115 maskcnt++;
15116 }
15117
15118 fclose (mask_fp);
15119
15120 mask_from_file = 1;
15121 }
15122 else
15123 {
15124 maskcnt = 1;
15125
15126 masks[maskcnt - 1] = mystrdup (mask);
15127 }
15128 }
15129
15130 // base
15131
15132 int wls_left = myargc - (optind + 2);
15133
15134 for (int i = 0; i < wls_left; i++)
15135 {
15136 char *filename = myargv[optind + 2 + i];
15137
15138 struct stat file_stat;
15139
15140 if (stat (filename, &file_stat) == -1)
15141 {
15142 log_error ("ERROR: %s: %s", filename, strerror (errno));
15143
15144 return (-1);
15145 }
15146
15147 uint is_dir = S_ISDIR (file_stat.st_mode);
15148
15149 if (is_dir == 0)
15150 {
15151 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15152
15153 dictcnt++;
15154
15155 dictfiles[dictcnt - 1] = filename;
15156 }
15157 else
15158 {
15159 // do not allow --keyspace w/ a directory
15160
15161 if (keyspace == 1)
15162 {
15163 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15164
15165 return (-1);
15166 }
15167
15168 char **dictionary_files = NULL;
15169
15170 dictionary_files = scan_directory (filename);
15171
15172 if (dictionary_files != NULL)
15173 {
15174 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15175
15176 for (int d = 0; dictionary_files[d] != NULL; d++)
15177 {
15178 char *l1_filename = dictionary_files[d];
15179
15180 struct stat l1_stat;
15181
15182 if (stat (l1_filename, &l1_stat) == -1)
15183 {
15184 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15185
15186 return (-1);
15187 }
15188
15189 if (S_ISREG (l1_stat.st_mode))
15190 {
15191 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15192
15193 dictcnt++;
15194
15195 dictfiles[dictcnt - 1] = strdup (l1_filename);
15196 }
15197 }
15198 }
15199
15200 local_free (dictionary_files);
15201 }
15202 }
15203
15204 if (dictcnt < 1)
15205 {
15206 log_error ("ERROR: No usable dictionary file found.");
15207
15208 return (-1);
15209 }
15210
15211 if (increment)
15212 {
15213 maskcnt = 0;
15214
15215 uint mask_min = increment_min; // we can't reject smaller masks here
15216 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15217
15218 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15219 {
15220 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15221
15222 if (cur_mask == NULL) break;
15223
15224 masks[maskcnt] = cur_mask;
15225
15226 maskcnt++;
15227
15228 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15229 }
15230 }
15231 }
15232
15233 data.pw_min = pw_min;
15234 data.pw_max = pw_max;
15235
15236 /**
15237 * weak hash check
15238 */
15239
15240 if (weak_hash_threshold >= salts_cnt)
15241 {
15242 hc_device_param_t *device_param = NULL;
15243
15244 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15245 {
15246 device_param = &data.devices_param[device_id];
15247
15248 if (device_param->skipped) continue;
15249
15250 break;
15251 }
15252
15253 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15254
15255 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15256 {
15257 weak_hash_check (device_param, salt_pos);
15258 }
15259 }
15260
15261 // Display hack, guarantee that there is at least one \r before real start
15262
15263 if (data.quiet == 0) log_info_nn ("");
15264
15265 /**
15266 * status and monitor threads
15267 */
15268
15269 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15270
15271 hc_thread_t i_thread = 0;
15272
15273 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15274 {
15275 hc_thread_create (i_thread, thread_keypress, &benchmark);
15276 }
15277
15278 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15279
15280 uint ni_threads_cnt = 0;
15281
15282 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15283
15284 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15285
15286 ni_threads_cnt++;
15287
15288 /**
15289 * Outfile remove
15290 */
15291
15292 if (keyspace == 0)
15293 {
15294 if (outfile_check_timer != 0)
15295 {
15296 if (data.outfile_check_directory != NULL)
15297 {
15298 if ((hash_mode != 5200) &&
15299 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15300 (hash_mode != 9000))
15301 {
15302 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15303
15304 ni_threads_cnt++;
15305 }
15306 else
15307 {
15308 outfile_check_timer = 0;
15309 }
15310 }
15311 else
15312 {
15313 outfile_check_timer = 0;
15314 }
15315 }
15316 }
15317
15318 /**
15319 * Inform the user if we got some hashes remove because of the pot file remove feature
15320 */
15321
15322 if (data.quiet == 0)
15323 {
15324 if (potfile_remove_cracks > 0)
15325 {
15326 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15327 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15328 }
15329 }
15330
15331 data.outfile_check_timer = outfile_check_timer;
15332
15333 /**
15334 * main loop
15335 */
15336
15337 char **induction_dictionaries = NULL;
15338
15339 int induction_dictionaries_cnt = 0;
15340
15341 hcstat_table_t *root_table_buf = NULL;
15342 hcstat_table_t *markov_table_buf = NULL;
15343
15344 uint initial_restore_done = 0;
15345
15346 data.maskcnt = maskcnt;
15347
15348 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15349 {
15350 if (data.devices_status == STATUS_CRACKED) break;
15351
15352 data.devices_status = STATUS_INIT;
15353
15354 if (maskpos > rd->maskpos)
15355 {
15356 rd->dictpos = 0;
15357 }
15358
15359 rd->maskpos = maskpos;
15360 data.maskpos = maskpos;
15361
15362 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15363 {
15364 char *mask = masks[maskpos];
15365
15366 if (mask_from_file == 1)
15367 {
15368 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15369
15370 char *str_ptr;
15371 uint str_pos;
15372
15373 uint mask_offset = 0;
15374
15375 uint separator_cnt;
15376
15377 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15378 {
15379 str_ptr = strstr (mask + mask_offset, ",");
15380
15381 if (str_ptr == NULL) break;
15382
15383 str_pos = str_ptr - mask;
15384
15385 // escaped separator, i.e. "\,"
15386
15387 if (str_pos > 0)
15388 {
15389 if (mask[str_pos - 1] == '\\')
15390 {
15391 separator_cnt --;
15392
15393 mask_offset = str_pos + 1;
15394
15395 continue;
15396 }
15397 }
15398
15399 // reset the offset
15400
15401 mask_offset = 0;
15402
15403 mask[str_pos] = '\0';
15404
15405 switch (separator_cnt)
15406 {
15407 case 0:
15408 mp_reset_usr (mp_usr, 0);
15409
15410 custom_charset_1 = mask;
15411 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15412 break;
15413
15414 case 1:
15415 mp_reset_usr (mp_usr, 1);
15416
15417 custom_charset_2 = mask;
15418 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15419 break;
15420
15421 case 2:
15422 mp_reset_usr (mp_usr, 2);
15423
15424 custom_charset_3 = mask;
15425 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15426 break;
15427
15428 case 3:
15429 mp_reset_usr (mp_usr, 3);
15430
15431 custom_charset_4 = mask;
15432 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15433 break;
15434 }
15435
15436 mask = mask + str_pos + 1;
15437 }
15438 }
15439
15440 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15441 {
15442 if (maskpos > 0)
15443 {
15444 local_free (css_buf);
15445 local_free (data.root_css_buf);
15446 local_free (data.markov_css_buf);
15447
15448 local_free (masks[maskpos - 1]);
15449 }
15450
15451 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15452
15453 data.mask = mask;
15454 data.css_cnt = css_cnt;
15455 data.css_buf = css_buf;
15456
15457 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15458
15459 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15460
15461 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15462 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15463
15464 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15465
15466 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15467
15468 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15469 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15470
15471 data.root_css_buf = root_css_buf;
15472 data.markov_css_buf = markov_css_buf;
15473
15474 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15475
15476 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15477
15478 local_free (root_table_buf);
15479 local_free (markov_table_buf);
15480
15481 // args
15482
15483 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15484 {
15485 hc_device_param_t *device_param = &data.devices_param[device_id];
15486
15487 if (device_param->skipped) continue;
15488
15489 device_param->kernel_params_mp[0] = &device_param->d_combs;
15490 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15491 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15492
15493 device_param->kernel_params_mp_buf64[3] = 0;
15494 device_param->kernel_params_mp_buf32[4] = css_cnt;
15495 device_param->kernel_params_mp_buf32[5] = 0;
15496 device_param->kernel_params_mp_buf32[6] = 0;
15497 device_param->kernel_params_mp_buf32[7] = 0;
15498
15499 if (attack_mode == ATTACK_MODE_HYBRID1)
15500 {
15501 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15502 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15503 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15504 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15505 }
15506 else if (attack_mode == ATTACK_MODE_HYBRID2)
15507 {
15508 device_param->kernel_params_mp_buf32[5] = 0;
15509 device_param->kernel_params_mp_buf32[6] = 0;
15510 device_param->kernel_params_mp_buf32[7] = 0;
15511 }
15512
15513 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]);
15514 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]);
15515 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]);
15516
15517 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);
15518 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);
15519 }
15520 }
15521 else if (attack_mode == ATTACK_MODE_BF)
15522 {
15523 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15524
15525 if (increment)
15526 {
15527 for (uint i = 0; i < dictcnt; i++)
15528 {
15529 local_free (dictfiles[i]);
15530 }
15531
15532 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15533 {
15534 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15535
15536 if (l1_filename == NULL) break;
15537
15538 dictcnt++;
15539
15540 dictfiles[dictcnt - 1] = l1_filename;
15541 }
15542 }
15543 else
15544 {
15545 dictcnt++;
15546
15547 dictfiles[dictcnt - 1] = mask;
15548 }
15549
15550 if (dictcnt == 0)
15551 {
15552 log_error ("ERROR: Mask is too small");
15553
15554 return (-1);
15555 }
15556 }
15557 }
15558
15559 free (induction_dictionaries);
15560
15561 // induction_dictionaries_cnt = 0; // implied
15562
15563 if (attack_mode != ATTACK_MODE_BF)
15564 {
15565 if (keyspace == 0)
15566 {
15567 induction_dictionaries = scan_directory (induction_directory);
15568
15569 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15570 }
15571 }
15572
15573 if (induction_dictionaries_cnt)
15574 {
15575 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15576 }
15577
15578 /**
15579 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15580 */
15581 if (keyspace == 1)
15582 {
15583 if ((maskcnt > 1) || (dictcnt > 1))
15584 {
15585 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15586
15587 return (-1);
15588 }
15589 }
15590
15591 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15592 {
15593 char *subid = logfile_generate_subid ();
15594
15595 data.subid = subid;
15596
15597 logfile_sub_msg ("START");
15598
15599 data.devices_status = STATUS_INIT;
15600
15601 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15602 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15603 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15604
15605 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15606
15607 data.cpt_pos = 0;
15608
15609 data.cpt_start = time (NULL);
15610
15611 data.cpt_total = 0;
15612
15613 if (data.restore == 0)
15614 {
15615 rd->words_cur = skip;
15616
15617 skip = 0;
15618
15619 data.skip = 0;
15620 }
15621
15622 data.ms_paused = 0;
15623
15624 data.words_cur = rd->words_cur;
15625
15626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15627 {
15628 hc_device_param_t *device_param = &data.devices_param[device_id];
15629
15630 if (device_param->skipped) continue;
15631
15632 device_param->speed_pos = 0;
15633
15634 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15635 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15636 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15637
15638 device_param->exec_pos = 0;
15639
15640 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15641
15642 device_param->kernel_power = device_param->kernel_power_user;
15643 device_param->kernel_blocks = device_param->kernel_blocks_user;
15644
15645 device_param->outerloop_pos = 0;
15646 device_param->outerloop_left = 0;
15647 device_param->innerloop_pos = 0;
15648 device_param->innerloop_left = 0;
15649
15650 // some more resets:
15651
15652 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15653
15654 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15655
15656 device_param->pw_cnt = 0;
15657 device_param->pws_cnt = 0;
15658
15659 device_param->words_off = 0;
15660 device_param->words_done = 0;
15661 }
15662
15663 data.kernel_blocks_div = 0;
15664
15665 // figure out some workload
15666
15667 if (attack_mode == ATTACK_MODE_STRAIGHT)
15668 {
15669 if (data.wordlist_mode == WL_MODE_FILE)
15670 {
15671 char *dictfile = NULL;
15672
15673 if (induction_dictionaries_cnt)
15674 {
15675 dictfile = induction_dictionaries[0];
15676 }
15677 else
15678 {
15679 dictfile = dictfiles[dictpos];
15680 }
15681
15682 data.dictfile = dictfile;
15683
15684 logfile_sub_string (dictfile);
15685
15686 for (uint i = 0; i < rp_files_cnt; i++)
15687 {
15688 logfile_sub_var_string ("rulefile", rp_files[i]);
15689 }
15690
15691 FILE *fd2 = fopen (dictfile, "rb");
15692
15693 if (fd2 == NULL)
15694 {
15695 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15696
15697 return (-1);
15698 }
15699
15700 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15701
15702 fclose (fd2);
15703
15704 if (data.words_cnt == 0)
15705 {
15706 if (data.devices_status == STATUS_CRACKED) break;
15707 if (data.devices_status == STATUS_ABORTED) break;
15708
15709 dictpos++;
15710
15711 continue;
15712 }
15713 }
15714 }
15715 else if (attack_mode == ATTACK_MODE_COMBI)
15716 {
15717 char *dictfile = data.dictfile;
15718 char *dictfile2 = data.dictfile2;
15719
15720 logfile_sub_string (dictfile);
15721 logfile_sub_string (dictfile2);
15722
15723 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15724 {
15725 FILE *fd2 = fopen (dictfile, "rb");
15726
15727 if (fd2 == NULL)
15728 {
15729 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15730
15731 return (-1);
15732 }
15733
15734 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15735
15736 fclose (fd2);
15737 }
15738 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15739 {
15740 FILE *fd2 = fopen (dictfile2, "rb");
15741
15742 if (fd2 == NULL)
15743 {
15744 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15745
15746 return (-1);
15747 }
15748
15749 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15750
15751 fclose (fd2);
15752 }
15753
15754 if (data.words_cnt == 0)
15755 {
15756 if (data.devices_status == STATUS_CRACKED) break;
15757 if (data.devices_status == STATUS_ABORTED) break;
15758
15759 dictpos++;
15760
15761 continue;
15762 }
15763 }
15764 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15765 {
15766 char *dictfile = NULL;
15767
15768 if (induction_dictionaries_cnt)
15769 {
15770 dictfile = induction_dictionaries[0];
15771 }
15772 else
15773 {
15774 dictfile = dictfiles[dictpos];
15775 }
15776
15777 data.dictfile = dictfile;
15778
15779 char *mask = data.mask;
15780
15781 logfile_sub_string (dictfile);
15782 logfile_sub_string (mask);
15783
15784 FILE *fd2 = fopen (dictfile, "rb");
15785
15786 if (fd2 == NULL)
15787 {
15788 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15789
15790 return (-1);
15791 }
15792
15793 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15794
15795 fclose (fd2);
15796
15797 if (data.words_cnt == 0)
15798 {
15799 if (data.devices_status == STATUS_CRACKED) break;
15800 if (data.devices_status == STATUS_ABORTED) break;
15801
15802 dictpos++;
15803
15804 continue;
15805 }
15806 }
15807 else if (attack_mode == ATTACK_MODE_BF)
15808 {
15809 local_free (css_buf);
15810 local_free (data.root_css_buf);
15811 local_free (data.markov_css_buf);
15812
15813 char *mask = dictfiles[dictpos];
15814
15815 logfile_sub_string (mask);
15816
15817 // base
15818
15819 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15820
15821 if (opts_type & OPTS_TYPE_PT_UNICODE)
15822 {
15823 uint css_cnt_unicode = css_cnt * 2;
15824
15825 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15826
15827 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15828 {
15829 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15830
15831 css_buf_unicode[j + 1].cs_buf[0] = 0;
15832 css_buf_unicode[j + 1].cs_len = 1;
15833 }
15834
15835 free (css_buf);
15836
15837 css_buf = css_buf_unicode;
15838 css_cnt = css_cnt_unicode;
15839 }
15840
15841 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15842
15843 uint mask_min = pw_min;
15844 uint mask_max = pw_max;
15845
15846 if (opts_type & OPTS_TYPE_PT_UNICODE)
15847 {
15848 mask_min *= 2;
15849 mask_max *= 2;
15850 }
15851
15852 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15853 {
15854 if (css_cnt < mask_min)
15855 {
15856 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15857 }
15858
15859 if (css_cnt > mask_max)
15860 {
15861 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15862 }
15863
15864 // skip to next mask
15865
15866 dictpos++;
15867
15868 rd->dictpos = dictpos;
15869
15870 logfile_sub_msg ("STOP");
15871
15872 continue;
15873 }
15874
15875 uint save_css_cnt = css_cnt;
15876
15877 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15878 {
15879 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15880 {
15881 uint salt_len = (uint) data.salts_buf[0].salt_len;
15882 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15883
15884 uint css_cnt_salt = css_cnt + salt_len;
15885
15886 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15887
15888 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15889
15890 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15891 {
15892 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15893 css_buf_salt[j].cs_len = 1;
15894 }
15895
15896 free (css_buf);
15897
15898 css_buf = css_buf_salt;
15899 css_cnt = css_cnt_salt;
15900 }
15901 }
15902
15903 data.mask = mask;
15904 data.css_cnt = css_cnt;
15905 data.css_buf = css_buf;
15906
15907 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15908
15909 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15910
15911 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15912
15913 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15914 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15915
15916 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15917
15918 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15919
15920 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15921 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15922
15923 data.root_css_buf = root_css_buf;
15924 data.markov_css_buf = markov_css_buf;
15925
15926 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15927
15928 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15929
15930 local_free (root_table_buf);
15931 local_free (markov_table_buf);
15932
15933 // copy + args
15934
15935 uint css_cnt_l = css_cnt;
15936 uint css_cnt_r;
15937
15938 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15939 {
15940 if (save_css_cnt < 6)
15941 {
15942 css_cnt_r = 1;
15943 }
15944 else if (save_css_cnt == 6)
15945 {
15946 css_cnt_r = 2;
15947 }
15948 else
15949 {
15950 if (opts_type & OPTS_TYPE_PT_UNICODE)
15951 {
15952 if (save_css_cnt == 8 || save_css_cnt == 10)
15953 {
15954 css_cnt_r = 2;
15955 }
15956 else
15957 {
15958 css_cnt_r = 4;
15959 }
15960 }
15961 else
15962 {
15963 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15964 {
15965 css_cnt_r = 3;
15966 }
15967 else
15968 {
15969 css_cnt_r = 4;
15970 }
15971 }
15972 }
15973 }
15974 else
15975 {
15976 css_cnt_r = 1;
15977
15978 /* unfinished code?
15979 int sum = css_buf[css_cnt_r - 1].cs_len;
15980
15981 for (uint i = 1; i < 4 && i < css_cnt; i++)
15982 {
15983 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15984
15985 css_cnt_r++;
15986
15987 sum *= css_buf[css_cnt_r - 1].cs_len;
15988 }
15989 */
15990 }
15991
15992 css_cnt_l -= css_cnt_r;
15993
15994 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15995
15996 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15997 {
15998 hc_device_param_t *device_param = &data.devices_param[device_id];
15999
16000 if (device_param->skipped) continue;
16001
16002 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16003 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16004 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16005
16006 device_param->kernel_params_mp_l_buf64[3] = 0;
16007 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16008 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16009 device_param->kernel_params_mp_l_buf32[6] = 0;
16010 device_param->kernel_params_mp_l_buf32[7] = 0;
16011 device_param->kernel_params_mp_l_buf32[8] = 0;
16012
16013 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16014 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16015 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16016 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16017
16018 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16019 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16020 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16021
16022 device_param->kernel_params_mp_r_buf64[3] = 0;
16023 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16024 device_param->kernel_params_mp_r_buf32[5] = 0;
16025 device_param->kernel_params_mp_r_buf32[6] = 0;
16026 device_param->kernel_params_mp_r_buf32[7] = 0;
16027
16028 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]);
16029 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]);
16030 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]);
16031
16032 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]);
16033 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]);
16034 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]);
16035
16036 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);
16037 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);
16038 }
16039 }
16040
16041 u64 words_base = data.words_cnt;
16042
16043 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16044 {
16045 if (data.kernel_rules_cnt)
16046 {
16047 words_base /= data.kernel_rules_cnt;
16048 }
16049 }
16050 else if (data.attack_kern == ATTACK_KERN_COMBI)
16051 {
16052 if (data.combs_cnt)
16053 {
16054 words_base /= data.combs_cnt;
16055 }
16056 }
16057 else if (data.attack_kern == ATTACK_KERN_BF)
16058 {
16059 if (data.bfs_cnt)
16060 {
16061 words_base /= data.bfs_cnt;
16062 }
16063 }
16064
16065 data.words_base = words_base;
16066
16067 if (keyspace == 1)
16068 {
16069 log_info ("%llu", (unsigned long long int) words_base);
16070
16071 return (0);
16072 }
16073
16074 if (data.words_cur > data.words_base)
16075 {
16076 log_error ("ERROR: restore value greater keyspace");
16077
16078 return (-1);
16079 }
16080
16081 if (data.words_cur)
16082 {
16083 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16084 {
16085 for (uint i = 0; i < data.salts_cnt; i++)
16086 {
16087 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16088 }
16089 }
16090 else if (data.attack_kern == ATTACK_KERN_COMBI)
16091 {
16092 for (uint i = 0; i < data.salts_cnt; i++)
16093 {
16094 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16095 }
16096 }
16097 else if (data.attack_kern == ATTACK_KERN_BF)
16098 {
16099 for (uint i = 0; i < data.salts_cnt; i++)
16100 {
16101 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16102 }
16103 }
16104 }
16105
16106 /*
16107 * Inform user about possible slow speeds
16108 */
16109
16110 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16111 {
16112 if (data.words_base < kernel_blocks_all)
16113 {
16114 if (quiet == 0)
16115 {
16116 log_info ("");
16117 log_info ("ATTENTION!");
16118 log_info (" The wordlist or mask you are using is too small.");
16119 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16120 log_info (" The cracking speed will drop.");
16121 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16122 log_info ("");
16123 }
16124 }
16125 }
16126
16127 /*
16128 * Update loopback file
16129 */
16130
16131 if (loopback == 1)
16132 {
16133 time_t now;
16134
16135 time (&now);
16136
16137 uint random_num = get_random_num (0, 9999);
16138
16139 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16140
16141 data.loopback_file = loopback_file;
16142 }
16143
16144 /*
16145 * Update dictionary statistic
16146 */
16147
16148 if (keyspace == 0)
16149 {
16150 dictstat_fp = fopen (dictstat, "wb");
16151
16152 if (dictstat_fp)
16153 {
16154 lock_file (dictstat_fp);
16155
16156 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16157
16158 fclose (dictstat_fp);
16159 }
16160 }
16161
16162 data.devices_status = STATUS_RUNNING;
16163
16164 if (initial_restore_done == 0)
16165 {
16166 if (data.restore_disable == 0) cycle_restore ();
16167
16168 initial_restore_done = 1;
16169 }
16170
16171 hc_timer_set (&data.timer_running);
16172
16173 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16174 {
16175 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16176 {
16177 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16178 if (quiet == 0) fflush (stdout);
16179 }
16180 }
16181 else if (wordlist_mode == WL_MODE_STDIN)
16182 {
16183 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16184 if (data.quiet == 0) log_info ("");
16185 }
16186
16187 time_t runtime_start;
16188
16189 time (&runtime_start);
16190
16191 data.runtime_start = runtime_start;
16192
16193 /**
16194 * create cracker threads
16195 */
16196
16197 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16198
16199 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16200 {
16201 hc_device_param_t *device_param = &devices_param[device_id];
16202
16203 if (wordlist_mode == WL_MODE_STDIN)
16204 {
16205 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16206 }
16207 else
16208 {
16209 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16210 }
16211 }
16212
16213 // wait for crack threads to exit
16214
16215 hc_thread_wait (data.devices_cnt, c_threads);
16216
16217 local_free (c_threads);
16218
16219 data.restore = 0;
16220
16221 // finalize task
16222
16223 logfile_sub_var_uint ("status-after-work", data.devices_status);
16224
16225 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16226
16227 if (data.devices_status == STATUS_CRACKED) break;
16228 if (data.devices_status == STATUS_ABORTED) break;
16229
16230 if (data.devices_status == STATUS_BYPASS)
16231 {
16232 data.devices_status = STATUS_RUNNING;
16233 }
16234
16235 if (induction_dictionaries_cnt)
16236 {
16237 unlink (induction_dictionaries[0]);
16238 }
16239
16240 free (induction_dictionaries);
16241
16242 if (attack_mode != ATTACK_MODE_BF)
16243 {
16244 induction_dictionaries = scan_directory (induction_directory);
16245
16246 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16247 }
16248
16249 if (benchmark == 0)
16250 {
16251 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16252 {
16253 if (quiet == 0) clear_prompt ();
16254
16255 if (quiet == 0) log_info ("");
16256
16257 if (status == 1)
16258 {
16259 status_display ();
16260 }
16261 else
16262 {
16263 if (quiet == 0) status_display ();
16264 }
16265
16266 if (quiet == 0) log_info ("");
16267 }
16268 }
16269
16270 if (attack_mode == ATTACK_MODE_BF)
16271 {
16272 dictpos++;
16273
16274 rd->dictpos = dictpos;
16275 }
16276 else
16277 {
16278 if (induction_dictionaries_cnt)
16279 {
16280 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16281 }
16282 else
16283 {
16284 dictpos++;
16285
16286 rd->dictpos = dictpos;
16287 }
16288 }
16289
16290 time_t runtime_stop;
16291
16292 time (&runtime_stop);
16293
16294 data.runtime_stop = runtime_stop;
16295
16296 logfile_sub_uint (runtime_start);
16297 logfile_sub_uint (runtime_stop);
16298
16299 logfile_sub_msg ("STOP");
16300
16301 global_free (subid);
16302 }
16303
16304 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16305
16306 if (data.devices_status == STATUS_CRACKED) break;
16307 if (data.devices_status == STATUS_ABORTED) break;
16308 if (data.devices_status == STATUS_QUIT) break;
16309
16310 if (data.devices_status == STATUS_BYPASS)
16311 {
16312 data.devices_status = STATUS_RUNNING;
16313 }
16314 }
16315
16316 // 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
16317
16318 if (attack_mode == ATTACK_MODE_STRAIGHT)
16319 {
16320 if (data.wordlist_mode == WL_MODE_FILE)
16321 {
16322 if (data.dictfile == NULL)
16323 {
16324 if (dictfiles != NULL)
16325 {
16326 data.dictfile = dictfiles[0];
16327
16328 hc_timer_set (&data.timer_running);
16329 }
16330 }
16331 }
16332 }
16333 // NOTE: combi is okay because it is already set beforehand
16334 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16335 {
16336 if (data.dictfile == NULL)
16337 {
16338 if (dictfiles != NULL)
16339 {
16340 hc_timer_set (&data.timer_running);
16341
16342 data.dictfile = dictfiles[0];
16343 }
16344 }
16345 }
16346 else if (attack_mode == ATTACK_MODE_BF)
16347 {
16348 if (data.mask == NULL)
16349 {
16350 hc_timer_set (&data.timer_running);
16351
16352 data.mask = masks[0];
16353 }
16354 }
16355
16356 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16357 {
16358 data.devices_status = STATUS_EXHAUSTED;
16359 }
16360
16361 // if cracked / aborted remove last induction dictionary
16362
16363 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16364 {
16365 struct stat induct_stat;
16366
16367 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16368 {
16369 unlink (induction_dictionaries[file_pos]);
16370 }
16371 }
16372
16373 // wait for non-interactive threads
16374
16375 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16376 {
16377 hc_thread_wait (1, &ni_threads[thread_idx]);
16378 }
16379
16380 local_free (ni_threads);
16381
16382 // wait for interactive threads
16383
16384 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16385 {
16386 hc_thread_wait (1, &i_thread);
16387 }
16388
16389 // we dont need restore file anymore
16390 if (data.restore_disable == 0)
16391 {
16392 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16393 {
16394 unlink (eff_restore_file);
16395 unlink (new_restore_file);
16396 }
16397 else
16398 {
16399 cycle_restore ();
16400 }
16401 }
16402
16403 // finally save left hashes
16404
16405 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16406 {
16407 save_hash ();
16408 }
16409
16410 /**
16411 * Clean up
16412 */
16413
16414 if (benchmark == 1)
16415 {
16416 status_benchmark ();
16417
16418 log_info ("");
16419 }
16420 else
16421 {
16422 if (quiet == 0) clear_prompt ();
16423
16424 if (quiet == 0) log_info ("");
16425
16426 if (status == 1)
16427 {
16428 status_display ();
16429 }
16430 else
16431 {
16432 if (quiet == 0) status_display ();
16433 }
16434
16435 if (quiet == 0) log_info ("");
16436 }
16437
16438 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16439 {
16440 hc_device_param_t *device_param = &data.devices_param[device_id];
16441
16442 if (device_param->skipped) continue;
16443
16444 local_free (device_param->result);
16445
16446 local_free (device_param->pw_caches);
16447
16448 local_free (device_param->combs_buf);
16449
16450 local_free (device_param->hooks_buf);
16451
16452 local_free (device_param->device_name);
16453
16454 local_free (device_param->device_name_chksum);
16455
16456 local_free (device_param->device_version);
16457
16458 local_free (device_param->driver_version);
16459
16460 if (device_param->pws_buf) myfree (device_param->pws_buf);
16461 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16462 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16463 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16464 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16465 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16466 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16467 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16468 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16469 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16470 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16471 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16472 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16473 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16474 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16475 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16476 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16477 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16478 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16479 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16480 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16481 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16482 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16483 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16484 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16485 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16486 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16487 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16488 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16489
16490 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16491 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16492 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16493 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16494 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16495 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16496 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16497 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16498 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16499 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16500 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16501
16502 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16503 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16504 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16505
16506 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16507 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16508 }
16509
16510 // reset default fan speed
16511
16512 #ifdef HAVE_HWMON
16513 if (gpu_temp_disable == 0)
16514 {
16515 #ifdef HAVE_ADL
16516 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16517 {
16518 hc_thread_mutex_lock (mux_adl);
16519
16520 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16521 {
16522 hc_device_param_t *device_param = &data.devices_param[device_id];
16523
16524 if (device_param->skipped) continue;
16525
16526 if (data.hm_device[device_id].fan_supported == 1)
16527 {
16528 int fanspeed = temp_retain_fanspeed_value[device_id];
16529
16530 if (fanspeed == -1) continue;
16531
16532 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16533
16534 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16535 }
16536 }
16537
16538 hc_thread_mutex_unlock (mux_adl);
16539 }
16540 #endif // HAVE_ADL
16541 }
16542
16543 #ifdef HAVE_ADL
16544 // reset power tuning
16545
16546 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16547 {
16548 hc_thread_mutex_lock (mux_adl);
16549
16550 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16551 {
16552 hc_device_param_t *device_param = &data.devices_param[device_id];
16553
16554 if (device_param->skipped) continue;
16555
16556 if (data.hm_device[device_id].od_version == 6)
16557 {
16558 // check powertune capabilities first, if not available then skip device
16559
16560 int powertune_supported = 0;
16561
16562 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16563 {
16564 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16565
16566 return (-1);
16567 }
16568
16569 if (powertune_supported != 0)
16570 {
16571 // powercontrol settings
16572
16573 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)
16574 {
16575 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16576
16577 return (-1);
16578 }
16579
16580 // clocks
16581
16582 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16583
16584 performance_state->iNumberOfPerformanceLevels = 2;
16585
16586 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16587 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16588 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16589 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16590
16591 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)
16592 {
16593 log_info ("ERROR: Failed to restore ADL performance state");
16594
16595 return (-1);
16596 }
16597
16598 local_free (performance_state);
16599 }
16600 }
16601 }
16602
16603 hc_thread_mutex_unlock (mux_adl);
16604 }
16605 #endif // HAVE_ADL
16606
16607 if (gpu_temp_disable == 0)
16608 {
16609 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16610 if (data.hm_nv)
16611 {
16612 #if defined(LINUX) && defined(HAVE_NVML)
16613
16614 hm_NVML_nvmlShutdown (data.hm_nv);
16615
16616 nvml_close (data.hm_nv);
16617
16618 #elif defined(WIN) && (HAVE_NVAPI)
16619
16620 hm_NvAPI_Unload (data.hm_nv);
16621
16622 nvapi_close (data.hm_nv);
16623
16624 #endif
16625
16626 data.hm_nv = NULL;
16627 }
16628 #endif
16629
16630 #ifdef HAVE_ADL
16631 if (data.hm_amd)
16632 {
16633 hm_ADL_Main_Control_Destroy (data.hm_amd);
16634
16635 adl_close (data.hm_amd);
16636 data.hm_amd = NULL;
16637 }
16638 #endif
16639 }
16640 #endif // HAVE_HWMON
16641
16642 // free memory
16643
16644 local_free (masks);
16645
16646 local_free (dictstat_base);
16647
16648 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16649 {
16650 pot_t *pot_ptr = &pot[pot_pos];
16651
16652 hash_t *hash = &pot_ptr->hash;
16653
16654 local_free (hash->digest);
16655
16656 if (isSalted)
16657 {
16658 local_free (hash->salt);
16659 }
16660 }
16661
16662 local_free (pot);
16663
16664 local_free (all_kernel_rules_cnt);
16665 local_free (all_kernel_rules_buf);
16666
16667 local_free (wl_data->buf);
16668 local_free (wl_data);
16669
16670 local_free (bitmap_s1_a);
16671 local_free (bitmap_s1_b);
16672 local_free (bitmap_s1_c);
16673 local_free (bitmap_s1_d);
16674 local_free (bitmap_s2_a);
16675 local_free (bitmap_s2_b);
16676 local_free (bitmap_s2_c);
16677 local_free (bitmap_s2_d);
16678
16679 #ifdef HAVE_HWMON
16680 local_free (temp_retain_fanspeed_value);
16681 #ifdef HAVE_ADL
16682 local_free (od_clock_mem_status);
16683 local_free (od_power_control_status);
16684 #endif // ADL
16685 #endif
16686
16687 global_free (devices_param);
16688
16689 global_free (kernel_rules_buf);
16690
16691 global_free (root_css_buf);
16692 global_free (markov_css_buf);
16693
16694 global_free (digests_buf);
16695 global_free (digests_shown);
16696 global_free (digests_shown_tmp);
16697
16698 global_free (salts_buf);
16699 global_free (salts_shown);
16700
16701 global_free (esalts_buf);
16702
16703 global_free (words_progress_done);
16704 global_free (words_progress_rejected);
16705 global_free (words_progress_restored);
16706
16707 if (pot_fp) fclose (pot_fp);
16708
16709 if (data.devices_status == STATUS_QUIT) break;
16710 }
16711
16712 // destroy others mutex
16713
16714 hc_thread_mutex_delete (mux_dispatcher);
16715 hc_thread_mutex_delete (mux_counter);
16716 hc_thread_mutex_delete (mux_display);
16717 hc_thread_mutex_delete (mux_adl);
16718
16719 // free memory
16720
16721 local_free (eff_restore_file);
16722 local_free (new_restore_file);
16723
16724 local_free (rd);
16725
16726 // tuning db
16727
16728 tuning_db_destroy (tuning_db);
16729
16730 // loopback
16731
16732 local_free (loopback_file);
16733
16734 if (loopback == 1) unlink (loopback_file);
16735
16736 // induction directory
16737
16738 if (induction_dir == NULL)
16739 {
16740 if (attack_mode != ATTACK_MODE_BF)
16741 {
16742 if (rmdir (induction_directory) == -1)
16743 {
16744 if (errno == ENOENT)
16745 {
16746 // good, we can ignore
16747 }
16748 else if (errno == ENOTEMPTY)
16749 {
16750 // good, we can ignore
16751 }
16752 else
16753 {
16754 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16755
16756 return (-1);
16757 }
16758 }
16759
16760 local_free (induction_directory);
16761 }
16762 }
16763
16764 // outfile-check directory
16765
16766 if (outfile_check_dir == NULL)
16767 {
16768 if (rmdir (outfile_check_directory) == -1)
16769 {
16770 if (errno == ENOENT)
16771 {
16772 // good, we can ignore
16773 }
16774 else if (errno == ENOTEMPTY)
16775 {
16776 // good, we can ignore
16777 }
16778 else
16779 {
16780 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16781
16782 return (-1);
16783 }
16784 }
16785
16786 local_free (outfile_check_directory);
16787 }
16788
16789 time_t proc_stop;
16790
16791 time (&proc_stop);
16792
16793 logfile_top_uint (proc_start);
16794 logfile_top_uint (proc_stop);
16795
16796 logfile_top_msg ("STOP");
16797
16798 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16799 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16800
16801 if (data.ocl) ocl_close (data.ocl);
16802
16803 if (data.devices_status == STATUS_ABORTED) return 2;
16804 if (data.devices_status == STATUS_QUIT) return 2;
16805 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16806 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16807 if (data.devices_status == STATUS_CRACKED) return 0;
16808
16809 return -1;
16810 }
Hashcat additions to support pwdhash