projects / hashcat.git / blob
? search:


bbee8d9c68a0cf1dca86354b457d52c2b43d35de
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
389 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
390 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
391 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
392 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
393 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
394 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
395 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
396 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
397 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
398 "",
399 "* Distributed:",
400 "",
401 " -s, --skip=NUM Skip number of words",
402 " -l, --limit=NUM Limit number of words",
403 " --keyspace Show keyspace base:mod values and quit",
404 "",
405 "* Rules:",
406 "",
407 " -j, --rule-left=RULE Single rule applied to each word from left dict",
408 " -k, --rule-right=RULE Single rule applied to each word from right dict",
409 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
410 " -g, --generate-rules=NUM Generate NUM random rules",
411 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
412 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
413 " --generate-rules-seed=NUM Force RNG seed to NUM",
414 "",
415 "* Custom charsets:",
416 "",
417 " -1, --custom-charset1=CS User-defined charsets",
418 " -2, --custom-charset2=CS Example:",
419 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
420 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
421 "",
422 "* Increment:",
423 "",
424 " -i, --increment Enable increment mode",
425 " --increment-min=NUM Start incrementing at NUM",
426 " --increment-max=NUM Stop incrementing at NUM",
427 "",
428 "==========",
429 "References",
430 "==========",
431 "",
432 "* Workload Profile:",
433 "",
434 " 1 = Reduced performance profile (low latency desktop)",
435 " 2 = Default performance profile",
436 " 3 = Tuned performance profile (high latency desktop)",
437 "",
438 "* Benchmark Settings:",
439 "",
440 " 0 = Manual Tuning",
441 " 1 = Performance Tuning, default",
442 "",
443 "* Outfile Formats:",
444 "",
445 " 1 = hash[:salt]",
446 " 2 = plain",
447 " 3 = hash[:salt]:plain",
448 " 4 = hex_plain",
449 " 5 = hash[:salt]:hex_plain",
450 " 6 = plain:hex_plain",
451 " 7 = hash[:salt]:plain:hex_plain",
452 " 8 = crackpos",
453 " 9 = hash[:salt]:crackpos",
454 " 10 = plain:crackpos",
455 " 11 = hash[:salt]:plain:crackpos",
456 " 12 = hex_plain:crackpos",
457 " 13 = hash[:salt]:hex_plain:crackpos",
458 " 14 = plain:hex_plain:crackpos",
459 " 15 = hash[:salt]:plain:hex_plain:crackpos",
460 "",
461 "* Debug mode output formats (for hybrid mode only, by using rules):",
462 "",
463 " 1 = save finding rule",
464 " 2 = save original word",
465 " 3 = save original word and finding rule",
466 " 4 = save original word, finding rule and modified plain",
467 "",
468 "* Built-in charsets:",
469 "",
470 " ?l = abcdefghijklmnopqrstuvwxyz",
471 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
472 " ?d = 0123456789",
473 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
474 " ?a = ?l?u?d?s",
475 " ?b = 0x00 - 0xff",
476 "",
477 "* Attack modes:",
478 "",
479 " 0 = Straight",
480 " 1 = Combination",
481 " 3 = Brute-force",
482 " 6 = Hybrid dict + mask",
483 " 7 = Hybrid mask + dict",
484 "",
485 "* Hash types:",
486 "",
487 "[[ Roll-your-own: Raw Hashes ]]",
488 "",
489 " 900 = MD4",
490 " 0 = MD5",
491 " 5100 = Half MD5",
492 " 100 = SHA1",
493 " 10800 = SHA-384",
494 " 1400 = SHA-256",
495 " 1700 = SHA-512",
496 " 5000 = SHA-3(Keccak)",
497 " 10100 = SipHash",
498 " 6000 = RipeMD160",
499 " 6100 = Whirlpool",
500 " 6900 = GOST R 34.11-94",
501 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
502 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
503 "",
504 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
505 "",
506 " 10 = md5($pass.$salt)",
507 " 20 = md5($salt.$pass)",
508 " 30 = md5(unicode($pass).$salt)",
509 " 40 = md5($salt.unicode($pass))",
510 " 3800 = md5($salt.$pass.$salt)",
511 " 3710 = md5($salt.md5($pass))",
512 " 2600 = md5(md5($pass)",
513 " 4300 = md5(strtoupper(md5($pass)))",
514 " 4400 = md5(sha1($pass))",
515 " 110 = sha1($pass.$salt)",
516 " 120 = sha1($salt.$pass)",
517 " 130 = sha1(unicode($pass).$salt)",
518 " 140 = sha1($salt.unicode($pass))",
519 " 4500 = sha1(sha1($pass)",
520 " 4700 = sha1(md5($pass))",
521 " 4900 = sha1($salt.$pass.$salt)",
522 " 1410 = sha256($pass.$salt)",
523 " 1420 = sha256($salt.$pass)",
524 " 1430 = sha256(unicode($pass).$salt)",
525 " 1440 = sha256($salt.unicode($pass))",
526 " 1710 = sha512($pass.$salt)",
527 " 1720 = sha512($salt.$pass)",
528 " 1730 = sha512(unicode($pass).$salt)",
529 " 1740 = sha512($salt.unicode($pass))",
530 "",
531 "[[ Roll-your-own: Authenticated Hashes ]]",
532 "",
533 " 50 = HMAC-MD5 (key = $pass)",
534 " 60 = HMAC-MD5 (key = $salt)",
535 " 150 = HMAC-SHA1 (key = $pass)",
536 " 160 = HMAC-SHA1 (key = $salt)",
537 " 1450 = HMAC-SHA256 (key = $pass)",
538 " 1460 = HMAC-SHA256 (key = $salt)",
539 " 1750 = HMAC-SHA512 (key = $pass)",
540 " 1760 = HMAC-SHA512 (key = $salt)",
541 "",
542 "[[ Generic KDF ]]",
543 "",
544 " 400 = phpass",
545 " 8900 = scrypt",
546 " 11900 = PBKDF2-HMAC-MD5",
547 " 12000 = PBKDF2-HMAC-SHA1",
548 " 10900 = PBKDF2-HMAC-SHA256",
549 " 12100 = PBKDF2-HMAC-SHA512",
550 "",
551 "[[ Network protocols, Challenge-Response ]]",
552 "",
553 " 23 = Skype",
554 " 2500 = WPA/WPA2",
555 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
556 " 5300 = IKE-PSK MD5",
557 " 5400 = IKE-PSK SHA1",
558 " 5500 = NetNTLMv1",
559 " 5500 = NetNTLMv1 + ESS",
560 " 5600 = NetNTLMv2",
561 " 7300 = IPMI2 RAKP HMAC-SHA1",
562 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
563 " 8300 = DNSSEC (NSEC3)",
564 " 10200 = Cram MD5",
565 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
566 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
567 " 11400 = SIP digest authentication (MD5)",
568 "",
569 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
570 "",
571 " 121 = SMF (Simple Machines Forum)",
572 " 400 = phpBB3",
573 " 2611 = vBulletin < v3.8.5",
574 " 2711 = vBulletin > v3.8.5",
575 " 2811 = MyBB",
576 " 2811 = IPB (Invison Power Board)",
577 " 8400 = WBB3 (Woltlab Burning Board)",
578 " 11 = Joomla < 2.5.18",
579 " 400 = Joomla > 2.5.18",
580 " 400 = Wordpress",
581 " 2612 = PHPS",
582 " 7900 = Drupal7",
583 " 21 = osCommerce",
584 " 21 = xt:Commerce",
585 " 11000 = PrestaShop",
586 " 124 = Django (SHA-1)",
587 " 10000 = Django (PBKDF2-SHA256)",
588 " 3711 = Mediawiki B type",
589 " 7600 = Redmine",
590 "",
591 "[[ Database Server ]]",
592 "",
593 " 12 = PostgreSQL",
594 " 131 = MSSQL(2000)",
595 " 132 = MSSQL(2005)",
596 " 1731 = MSSQL(2012)",
597 " 1731 = MSSQL(2014)",
598 " 200 = MySQL323",
599 " 300 = MySQL4.1/MySQL5",
600 " 3100 = Oracle H: Type (Oracle 7+)",
601 " 112 = Oracle S: Type (Oracle 11+)",
602 " 12300 = Oracle T: Type (Oracle 12+)",
603 " 8000 = Sybase ASE",
604 "",
605 "[[ HTTP, SMTP, LDAP Server ]]",
606 "",
607 " 141 = EPiServer 6.x < v4",
608 " 1441 = EPiServer 6.x > v4",
609 " 1600 = Apache $apr1$",
610 " 12600 = ColdFusion 10+",
611 " 1421 = hMailServer",
612 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
613 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
614 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
615 "",
616 "[[ Checksums ]]",
617 "",
618 " 11500 = CRC32",
619 "",
620 "[[ Operating-Systems ]]",
621 "",
622 " 3000 = LM",
623 " 1000 = NTLM",
624 " 1100 = Domain Cached Credentials (DCC), MS Cache",
625 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
626 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
627 " 1500 = descrypt, DES(Unix), Traditional DES",
628 " 12400 = BSDiCrypt, Extended DES",
629 " 500 = md5crypt $1$, MD5(Unix)",
630 " 3200 = bcrypt $2*$, Blowfish(Unix)",
631 " 7400 = sha256crypt $5$, SHA256(Unix)",
632 " 1800 = sha512crypt $6$, SHA512(Unix)",
633 " 122 = OSX v10.4",
634 " 122 = OSX v10.5",
635 " 122 = OSX v10.6",
636 " 1722 = OSX v10.7",
637 " 7100 = OSX v10.8",
638 " 7100 = OSX v10.9",
639 " 7100 = OSX v10.10",
640 " 6300 = AIX {smd5}",
641 " 6700 = AIX {ssha1}",
642 " 6400 = AIX {ssha256}",
643 " 6500 = AIX {ssha512}",
644 " 2400 = Cisco-PIX",
645 " 2410 = Cisco-ASA",
646 " 500 = Cisco-IOS $1$",
647 " 5700 = Cisco-IOS $4$",
648 " 9200 = Cisco-IOS $8$",
649 " 9300 = Cisco-IOS $9$",
650 " 22 = Juniper Netscreen/SSG (ScreenOS)",
651 " 501 = Juniper IVE",
652 " 5800 = Android PIN",
653 " 8100 = Citrix Netscaler",
654 " 8500 = RACF",
655 " 7200 = GRUB 2",
656 " 9900 = Radmin2",
657 "",
658 "[[ Enterprise Application Software (EAS) ]]",
659 "",
660 " 7700 = SAP CODVN B (BCODE)",
661 " 7800 = SAP CODVN F/G (PASSCODE)",
662 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
663 " 8600 = Lotus Notes/Domino 5",
664 " 8700 = Lotus Notes/Domino 6",
665 " 9100 = Lotus Notes/Domino 8",
666 " 133 = PeopleSoft",
667 "",
668 "[[ Archives ]]",
669 "",
670 " 11600 = 7-Zip",
671 " 12500 = RAR3-hp",
672 " 13000 = RAR5",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12900 = Android FDE (Samsung DEK)",
686 " 12200 = eCryptfs",
687 "",
688 "[[ Documents ]]",
689 "",
690 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
691 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
692 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
693 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
694 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
695 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
696 " 9400 = MS Office 2007",
697 " 9500 = MS Office 2010",
698 " 9600 = MS Office 2013",
699 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
700 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
701 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
702 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
703 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
704 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
705 "",
706 "[[ Password Managers ]]",
707 "",
708 " 9000 = Password Safe v2",
709 " 5200 = Password Safe v3",
710 " 6800 = Lastpass",
711 " 6600 = 1Password, agilekeychain",
712 " 8200 = 1Password, cloudkeychain",
713 " 11300 = Bitcoin/Litecoin wallet.dat",
714 " 12700 = Blockchain, My Wallet",
715 "",
716 NULL
717 };
718
719 /**
720 * oclHashcat specific functions
721 */
722
723 void status_display_automat ()
724 {
725 FILE *out = stdout;
726
727 fprintf (out, "STATUS\t%u\t", data.devices_status);
728
729 /**
730 * speed new
731 */
732
733 fprintf (out, "SPEED\t");
734
735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
736 {
737 hc_device_param_t *device_param = &data.devices_param[device_id];
738
739 uint64_t speed_cnt = 0;
740 float speed_ms = 0;
741
742 for (int i = 0; i < SPEED_CACHE; i++)
743 {
744 float rec_ms;
745
746 hc_timer_get (device_param->speed_rec[i], rec_ms);
747
748 if (rec_ms > SPEED_MAXAGE) continue;
749
750 speed_cnt += device_param->speed_cnt[i];
751 speed_ms += device_param->speed_ms[i];
752 }
753
754 speed_cnt /= SPEED_CACHE;
755 speed_ms /= SPEED_CACHE;
756
757 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
758 }
759
760 /**
761 * words_cur
762 */
763
764 uint64_t words_cur = get_lowest_words_done ();
765
766 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
767
768 /**
769 * counter
770 */
771
772 uint salts_left = data.salts_cnt - data.salts_done;
773
774 if (salts_left == 0) salts_left = 1;
775
776 uint64_t progress_total = data.words_cnt * salts_left;
777
778 uint64_t all_done = 0;
779 uint64_t all_rejected = 0;
780 uint64_t all_restored = 0;
781
782 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
783 {
784 if (salts_left > 1)
785 {
786 // otherwise the final cracked status shows 0/XXX progress
787
788 if (data.salts_shown[salt_pos] == 1) continue;
789 }
790
791 all_done += data.words_progress_done[salt_pos];
792 all_rejected += data.words_progress_rejected[salt_pos];
793 all_restored += data.words_progress_restored[salt_pos];
794 }
795
796 uint64_t progress_cur = all_restored + all_done + all_rejected;
797 uint64_t progress_end = progress_total;
798
799 uint64_t progress_skip = 0;
800
801 if (data.skip)
802 {
803 progress_skip = MIN (data.skip, data.words_base) * salts_left;
804
805 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
806 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
807 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
808 }
809
810 if (data.limit)
811 {
812 progress_end = MIN (data.limit, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
817 }
818
819 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
820 uint64_t progress_end_relative_skip = progress_end - progress_skip;
821
822 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
823
824 /**
825 * cracks
826 */
827
828 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
829 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
830
831 /**
832 * temperature
833 */
834
835 if (data.gpu_temp_disable == 0)
836 {
837 fprintf (out, "TEMP\t");
838
839 hc_thread_mutex_lock (mux_adl);
840
841 for (uint i = 0; i < data.devices_cnt; i++)
842 {
843 int temp = hm_get_temperature_with_device_id (i);
844
845 fprintf (out, "%d\t", temp);
846 }
847
848 hc_thread_mutex_unlock (mux_adl);
849 }
850
851 #ifdef _WIN
852 fputc ('\r', out);
853 fputc ('\n', out);
854 #endif
855
856 #ifdef _POSIX
857 fputc ('\n', out);
858 #endif
859
860 fflush (out);
861 }
862
863 void status_display ()
864 {
865 if (data.devices_status == STATUS_INIT) return;
866 if (data.devices_status == STATUS_STARTING) return;
867 if (data.devices_status == STATUS_BYPASS) return;
868
869 if (data.status_automat == 1)
870 {
871 status_display_automat ();
872
873 return;
874 }
875
876 char tmp_buf[1000];
877
878 uint tmp_len = 0;
879
880 log_info ("Session.Name...: %s", data.session);
881
882 char *status_type = strstatus (data.devices_status);
883
884 uint hash_mode = data.hash_mode;
885
886 char *hash_type = strhashtype (hash_mode); // not a bug
887
888 log_info ("Status.........: %s", status_type);
889
890 /**
891 * show rules
892 */
893
894 if (data.rp_files_cnt)
895 {
896 uint i;
897
898 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
899 {
900 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
901 }
902
903 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
904
905 log_info ("Rules.Type.....: %s", tmp_buf);
906
907 tmp_len = 0;
908 }
909
910 if (data.rp_gen)
911 {
912 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
913
914 if (data.rp_gen_seed)
915 {
916 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
917 }
918 }
919
920 /**
921 * show input
922 */
923
924 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
925 {
926 if (data.wordlist_mode == WL_MODE_FILE)
927 {
928 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
929 }
930 else if (data.wordlist_mode == WL_MODE_STDIN)
931 {
932 log_info ("Input.Mode.....: Pipe");
933 }
934 }
935 else if (data.attack_mode == ATTACK_MODE_COMBI)
936 {
937 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
938 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
939 }
940 else if (data.attack_mode == ATTACK_MODE_BF)
941 {
942 char *mask = data.mask;
943
944 if (mask != NULL)
945 {
946 uint mask_len = data.css_cnt;
947
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
949
950 if (mask_len > 0)
951 {
952 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
953 {
954 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
955 {
956 mask_len -= data.salts_buf[0].salt_len;
957 }
958 }
959
960 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
961
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
963 }
964
965 if (data.maskcnt > 1)
966 {
967 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
970 }
971
972 log_info ("Input.Mode.....: %s", tmp_buf);
973 }
974
975 tmp_len = 0;
976 }
977 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
978 {
979 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
980 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 }
982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
983 {
984 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
985 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
986 }
987
988 if (data.digests_cnt == 1)
989 {
990 if (data.hash_mode == 2500)
991 {
992 wpa_t *wpa = (wpa_t *) data.esalts_buf;
993
994 uint pke[25];
995
996 char *pke_ptr = (char *) pke;
997
998 for (uint i = 0; i < 25; i++)
999 {
1000 pke[i] = byte_swap_32 (wpa->pke[i]);
1001 }
1002
1003 char mac1[6];
1004 char mac2[6];
1005
1006 memcpy (mac1, pke_ptr + 23, 6);
1007 memcpy (mac2, pke_ptr + 29, 6);
1008
1009 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1010 (char *) data.salts_buf[0].salt_buf,
1011 mac1[0] & 0xff,
1012 mac1[1] & 0xff,
1013 mac1[2] & 0xff,
1014 mac1[3] & 0xff,
1015 mac1[4] & 0xff,
1016 mac1[5] & 0xff,
1017 mac2[0] & 0xff,
1018 mac2[1] & 0xff,
1019 mac2[2] & 0xff,
1020 mac2[3] & 0xff,
1021 mac2[4] & 0xff,
1022 mac2[5] & 0xff);
1023 }
1024 else if (data.hash_mode == 5200)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if (data.hash_mode == 9000)
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1033 {
1034 log_info ("Hash.Target....: File (%s)", data.hashfile);
1035 }
1036 else
1037 {
1038 char out_buf[4096];
1039
1040 ascii_digest (out_buf, 0, 0);
1041
1042 // limit length
1043 if (strlen (out_buf) > 40)
1044 {
1045 out_buf[41] = '.';
1046 out_buf[42] = '.';
1047 out_buf[43] = '.';
1048 out_buf[44] = 0;
1049 }
1050
1051 log_info ("Hash.Target....: %s", out_buf);
1052 }
1053 }
1054 else
1055 {
1056 if (data.hash_mode == 3000)
1057 {
1058 char out_buf1[4096];
1059 char out_buf2[4096];
1060
1061 ascii_digest (out_buf1, 0, 0);
1062 ascii_digest (out_buf2, 0, 1);
1063
1064 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1065 }
1066 else
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 }
1071
1072 log_info ("Hash.Type......: %s", hash_type);
1073
1074 /**
1075 * speed new
1076 */
1077
1078 uint64_t speed_cnt[DEVICES_MAX];
1079 float speed_ms[DEVICES_MAX];
1080
1081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1082 {
1083 hc_device_param_t *device_param = &data.devices_param[device_id];
1084
1085 // we need to clear values (set to 0) because in case the device does
1086 // not get new candidates it idles around but speed display would
1087 // show it as working.
1088 // if we instantly set it to 0 after reading it happens that the
1089 // speed can be shown as zero if the users refreshs to fast.
1090 // therefore, we add a timestamp when a stat was recorded and if its
1091 // to old we will not use it
1092
1093 speed_cnt[device_id] = 0;
1094 speed_ms[device_id] = 0;
1095
1096 for (int i = 0; i < SPEED_CACHE; i++)
1097 {
1098 float rec_ms;
1099
1100 hc_timer_get (device_param->speed_rec[i], rec_ms);
1101
1102 if (rec_ms > SPEED_MAXAGE) continue;
1103
1104 speed_cnt[device_id] += device_param->speed_cnt[i];
1105 speed_ms[device_id] += device_param->speed_ms[i];
1106 }
1107
1108 speed_cnt[device_id] /= SPEED_CACHE;
1109 speed_ms[device_id] /= SPEED_CACHE;
1110 }
1111
1112 float hashes_all_ms = 0;
1113
1114 float hashes_dev_ms[DEVICES_MAX];
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hashes_dev_ms[device_id] = 0;
1119
1120 if (speed_ms[device_id])
1121 {
1122 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1123
1124 hashes_all_ms += hashes_dev_ms[device_id];
1125 }
1126 }
1127
1128 /**
1129 * timers
1130 */
1131
1132 float ms_running = 0;
1133
1134 hc_timer_get (data.timer_running, ms_running);
1135
1136 float ms_paused = data.ms_paused;
1137
1138 if (data.devices_status == STATUS_PAUSED)
1139 {
1140 float ms_paused_tmp = 0;
1141
1142 hc_timer_get (data.timer_paused, ms_paused_tmp);
1143
1144 ms_paused += ms_paused_tmp;
1145 }
1146
1147 #ifdef WIN
1148
1149 __time64_t sec_run = ms_running / 1000;
1150
1151 #else
1152
1153 time_t sec_run = ms_running / 1000;
1154
1155 #endif
1156
1157 if (sec_run)
1158 {
1159 char display_run[32];
1160
1161 struct tm tm_run;
1162
1163 struct tm *tmp;
1164
1165 #ifdef WIN
1166
1167 tmp = _gmtime64 (&sec_run);
1168
1169 #else
1170
1171 tmp = gmtime (&sec_run);
1172
1173 #endif
1174
1175 if (tmp != NULL)
1176 {
1177 memcpy (&tm_run, tmp, sizeof (struct tm));
1178
1179 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1180
1181 char *start = ctime (&data.proc_start);
1182
1183 size_t start_len = strlen (start);
1184
1185 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1186 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1187
1188 log_info ("Time.Started...: %s (%s)", start, display_run);
1189 }
1190 }
1191 else
1192 {
1193 log_info ("Time.Started...: 0 secs");
1194 }
1195
1196 /**
1197 * counters
1198 */
1199
1200 uint salts_left = data.salts_cnt - data.salts_done;
1201
1202 if (salts_left == 0) salts_left = 1;
1203
1204 uint64_t progress_total = data.words_cnt * salts_left;
1205
1206 uint64_t all_done = 0;
1207 uint64_t all_rejected = 0;
1208 uint64_t all_restored = 0;
1209
1210 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1211 {
1212 if (salts_left > 1)
1213 {
1214 // otherwise the final cracked status shows 0/XXX progress
1215
1216 if (data.salts_shown[salt_pos] == 1) continue;
1217 }
1218
1219 all_done += data.words_progress_done[salt_pos];
1220 all_rejected += data.words_progress_rejected[salt_pos];
1221 all_restored += data.words_progress_restored[salt_pos];
1222 }
1223
1224 uint64_t progress_cur = all_restored + all_done + all_rejected;
1225 uint64_t progress_end = progress_total;
1226
1227 uint64_t progress_skip = 0;
1228
1229 if (data.skip)
1230 {
1231 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1232
1233 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1235 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1236 }
1237
1238 if (data.limit)
1239 {
1240 progress_end = MIN (data.limit, data.words_base) * salts_left;
1241
1242 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1244 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1245 }
1246
1247 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1248 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1249
1250 float speed_ms_real = ms_running - ms_paused;
1251 uint64_t speed_plains_real = all_done;
1252
1253 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1254 {
1255 if (data.devices_status != STATUS_CRACKED)
1256 {
1257 uint64_t words_per_ms = 0;
1258
1259 if (speed_plains_real && speed_ms_real)
1260 {
1261 words_per_ms = speed_plains_real / speed_ms_real;
1262 }
1263
1264 #ifdef WIN
1265 __time64_t sec_etc = 0;
1266 #else
1267 time_t sec_etc = 0;
1268 #endif
1269
1270 if (words_per_ms)
1271 {
1272 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1273
1274 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1275
1276 sec_etc = ms_left / 1000;
1277 }
1278
1279 if (sec_etc == 0)
1280 {
1281 log_info ("Time.Estimated.: 0 secs");
1282 }
1283 else if ((uint64_t) sec_etc > ETC_MAX)
1284 {
1285 log_info ("Time.Estimated.: > 10 Years");
1286 }
1287 else
1288 {
1289 char display_etc[32];
1290
1291 struct tm tm_etc;
1292
1293 struct tm *tmp;
1294
1295 #ifdef WIN
1296
1297 tmp = _gmtime64 (&sec_etc);
1298
1299 #else
1300
1301 tmp = gmtime (&sec_etc);
1302
1303 #endif
1304
1305 if (tmp != NULL)
1306 {
1307 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1308
1309 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1310
1311 time_t now;
1312
1313 time (&now);
1314
1315 now += sec_etc;
1316
1317 char *etc = ctime (&now);
1318
1319 size_t etc_len = strlen (etc);
1320
1321 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1322 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1323
1324 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1325 }
1326 }
1327 }
1328 }
1329
1330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1331 {
1332 char display_dev_cur[16];
1333
1334 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1335
1336 strncpy (display_dev_cur, "0.00", 4);
1337
1338 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1339
1340 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1341 }
1342
1343 char display_all_cur[16];
1344
1345 memset (display_all_cur, 0, sizeof (display_all_cur));
1346
1347 strncpy (display_all_cur, "0.00", 4);
1348
1349 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1350
1351 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1352
1353 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1354 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1355
1356 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);
1357
1358 // crack-per-time
1359
1360 if (data.digests_cnt > 100)
1361 {
1362 time_t now = time (NULL);
1363
1364 int cpt_cur_min = 0;
1365 int cpt_cur_hour = 0;
1366 int cpt_cur_day = 0;
1367
1368 for (int i = 0; i < CPT_BUF; i++)
1369 {
1370 const uint cracked = data.cpt_buf[i].cracked;
1371 const time_t timestamp = data.cpt_buf[i].timestamp;
1372
1373 if ((timestamp + 60) > now)
1374 {
1375 cpt_cur_min += cracked;
1376 }
1377
1378 if ((timestamp + 3600) > now)
1379 {
1380 cpt_cur_hour += cracked;
1381 }
1382
1383 if ((timestamp + 86400) > now)
1384 {
1385 cpt_cur_day += cracked;
1386 }
1387 }
1388
1389 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1390 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1391 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1392
1393 if ((data.cpt_start + 86400) < now)
1394 {
1395 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1396 cpt_cur_min,
1397 cpt_cur_hour,
1398 cpt_cur_day,
1399 cpt_avg_min,
1400 cpt_avg_hour,
1401 cpt_avg_day);
1402 }
1403 else if ((data.cpt_start + 3600) < now)
1404 {
1405 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1406 cpt_cur_min,
1407 cpt_cur_hour,
1408 cpt_avg_min,
1409 cpt_avg_hour,
1410 cpt_avg_day);
1411 }
1412 else if ((data.cpt_start + 60) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_avg_min,
1417 cpt_avg_hour,
1418 cpt_avg_day);
1419 }
1420 else
1421 {
1422 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 }
1428
1429 // Restore point
1430
1431 uint64_t restore_point = get_lowest_words_done ();
1432
1433 uint64_t restore_total = data.words_base;
1434
1435 float percent_restore = 0;
1436
1437 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1438
1439 if (progress_end_relative_skip)
1440 {
1441 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1442 {
1443 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1444 float percent_rejected = 0.0;
1445
1446 if (progress_cur)
1447 {
1448 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1449 }
1450
1451 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);
1452 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1453
1454 if (data.restore_disable == 0)
1455 {
1456 if (percent_finished != 1)
1457 {
1458 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1459 }
1460 }
1461 }
1462 }
1463 else
1464 {
1465 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1466 {
1467 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469
1470 if (data.restore_disable == 0)
1471 {
1472 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1473 }
1474 }
1475 else
1476 {
1477 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1478 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1479
1480 // --restore not allowed if stdin is used -- really? why?
1481
1482 //if (data.restore_disable == 0)
1483 //{
1484 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1485 //}
1486 }
1487 }
1488
1489 if (data.gpu_temp_disable == 0)
1490 {
1491 hc_thread_mutex_lock (mux_adl);
1492
1493 for (uint i = 0; i < data.devices_cnt; i++)
1494 {
1495 #define HM_STR_BUF_SIZE 255
1496
1497 if (data.hm_device[i].fan_supported == 1)
1498 {
1499 char temperature[HM_STR_BUF_SIZE];
1500 char utilization[HM_STR_BUF_SIZE];
1501 char fanspeed[HM_STR_BUF_SIZE];
1502
1503 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "%", hm_get_temperature_with_device_id (i));
1504 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "c", hm_get_utilization_with_device_id (i));
1505
1506 if (data.vendor_id == VENDOR_ID_AMD)
1507 {
1508 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (i));
1509 }
1510
1511 if (data.vendor_id == VENDOR_ID_NV)
1512 {
1513 #ifdef LINUX
1514 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (i));
1515 #else
1516 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (i));
1517 #endif
1518 }
1519
1520 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", i + 1, utilization, temperature, fanspeed);
1521 }
1522 else
1523 {
1524 char temperature[HM_STR_BUF_SIZE];
1525 char utilization[HM_STR_BUF_SIZE];
1526
1527 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "%", hm_get_temperature_with_device_id (i));
1528 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "c", hm_get_utilization_with_device_id (i));
1529
1530 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", i + 1, utilization, temperature);
1531 }
1532 }
1533
1534 hc_thread_mutex_unlock (mux_adl);
1535 }
1536 }
1537
1538 static void status_benchmark ()
1539 {
1540 if (data.devices_status == STATUS_INIT) return;
1541 if (data.devices_status == STATUS_STARTING) return;
1542
1543 if (data.words_cnt == 0) return;
1544
1545 uint64_t speed_cnt[DEVICES_MAX];
1546 float speed_ms[DEVICES_MAX];
1547
1548 uint device_id;
1549
1550 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1551 {
1552 hc_device_param_t *device_param = &data.devices_param[device_id];
1553
1554 speed_cnt[device_id] = 0;
1555 speed_ms[device_id] = 0;
1556
1557 for (int i = 0; i < SPEED_CACHE; i++)
1558 {
1559 speed_cnt[device_id] += device_param->speed_cnt[i];
1560 speed_ms[device_id] += device_param->speed_ms[i];
1561 }
1562
1563 speed_cnt[device_id] /= SPEED_CACHE;
1564 speed_ms[device_id] /= SPEED_CACHE;
1565 }
1566
1567 float hashes_all_ms = 0;
1568
1569 float hashes_dev_ms[DEVICES_MAX];
1570
1571 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1572 {
1573 hashes_dev_ms[device_id] = 0;
1574
1575 if (speed_ms[device_id])
1576 {
1577 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1578
1579 hashes_all_ms += hashes_dev_ms[device_id];
1580 }
1581 }
1582
1583 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1584 {
1585 char display_dev_cur[16];
1586
1587 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1588
1589 strncpy (display_dev_cur, "0.00", 4);
1590
1591 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1592
1593 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1594 }
1595
1596 char display_all_cur[16];
1597
1598 memset (display_all_cur, 0, sizeof (display_all_cur));
1599
1600 strncpy (display_all_cur, "0.00", 4);
1601
1602 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1603
1604 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1605 }
1606
1607 /**
1608 * oclHashcat -only- functions
1609 */
1610
1611 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1612 {
1613 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1614 {
1615 if (attack_kern == ATTACK_KERN_STRAIGHT)
1616 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1617 else if (attack_kern == ATTACK_KERN_COMBI)
1618 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1619 else if (attack_kern == ATTACK_KERN_BF)
1620 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1621 }
1622 else
1623 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1624 }
1625
1626 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, int vendor_id, char *cached_file)
1627 {
1628 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1629 {
1630 if (attack_kern == ATTACK_KERN_STRAIGHT)
1631 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1632 else if (attack_kern == ATTACK_KERN_COMBI)
1633 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1634 else if (attack_kern == ATTACK_KERN_BF)
1635 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1636 }
1637 else
1638 {
1639 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1640 }
1641 }
1642
1643 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1644 {
1645 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1646 {
1647 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1648 }
1649 else
1650 {
1651 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1652 }
1653 }
1654
1655 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1656 {
1657 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1658 {
1659 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1660 }
1661 else
1662 {
1663 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1664 }
1665 }
1666
1667 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1668 {
1669 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1670 }
1671
1672 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1673 {
1674 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1675 }
1676
1677 static uint convert_from_hex (char *line_buf, const uint line_len)
1678 {
1679 if (line_len & 1) return (line_len); // not in hex
1680
1681 if (data.hex_wordlist == 1)
1682 {
1683 uint i;
1684 uint j;
1685
1686 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1687 {
1688 line_buf[i] = hex_to_char (&line_buf[j]);
1689 }
1690
1691 memset (line_buf + i, 0, line_len - i);
1692
1693 return (i);
1694 }
1695 else if (line_len >= 6) // $HEX[] = 6
1696 {
1697 if (line_buf[0] != '$') return (line_len);
1698 if (line_buf[1] != 'H') return (line_len);
1699 if (line_buf[2] != 'E') return (line_len);
1700 if (line_buf[3] != 'X') return (line_len);
1701 if (line_buf[4] != '[') return (line_len);
1702 if (line_buf[line_len - 1] != ']') return (line_len);
1703
1704 uint i;
1705 uint j;
1706
1707 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1708 {
1709 line_buf[i] = hex_to_char (&line_buf[j]);
1710 }
1711
1712 memset (line_buf + i, 0, line_len - i);
1713
1714 return (i);
1715 }
1716
1717 return (line_len);
1718 }
1719
1720 static uint count_lines (FILE *fd)
1721 {
1722 uint cnt = 0;
1723
1724 char *buf = (char *) mymalloc (BUFSIZ);
1725
1726 size_t nread_tmp = 0;
1727
1728 char *ptr = buf;
1729
1730 while (!feof (fd))
1731 {
1732 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1733 nread_tmp = nread;
1734
1735 if (nread < 1) continue;
1736
1737 ptr = buf;
1738
1739 do
1740 {
1741 if (*ptr++ == '\n') cnt++;
1742
1743 } while (nread--);
1744 }
1745
1746 // special case (if last line did not contain a newline char ... at the very end of the file)
1747
1748 if (nread_tmp > 3)
1749 {
1750 ptr -= 2;
1751
1752 if (*ptr != '\n')
1753 {
1754 ptr--;
1755
1756 if (*ptr != '\n') // needed ? different on windows systems?
1757 {
1758 cnt++;
1759 }
1760 }
1761 }
1762
1763 myfree (buf);
1764
1765 return cnt;
1766 }
1767
1768 static void clear_prompt ()
1769 {
1770 fputc ('\r', stdout);
1771
1772 for (size_t i = 0; i < strlen (PROMPT); i++)
1773 {
1774 fputc (' ', stdout);
1775 }
1776
1777 fputc ('\r', stdout);
1778
1779 fflush (stdout);
1780 }
1781
1782 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1783 {
1784 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1785 }
1786
1787 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1788 {
1789 char *outfile = data.outfile;
1790 uint quiet = data.quiet;
1791 FILE *pot_fp = data.pot_fp;
1792 uint loopback = data.loopback;
1793 uint debug_mode = data.debug_mode;
1794 char *debug_file = data.debug_file;
1795
1796 char debug_rule_buf[BLOCK_SIZE];
1797 int debug_rule_len = 0; // -1 error
1798 uint debug_plain_len = 0;
1799
1800 unsigned char debug_plain_ptr[BLOCK_SIZE];
1801
1802 // hash
1803
1804 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1805
1806 ascii_digest (out_buf, salt_pos, digest_pos);
1807
1808 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1809
1810 // plain
1811
1812 plain_t plain;
1813
1814 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1815
1816 uint gidvid = plain.gidvid;
1817 uint il_pos = plain.il_pos;
1818
1819 uint64_t crackpos = device_param->words_off;
1820
1821 uint plain_buf[16];
1822
1823 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1824 unsigned int plain_len = 0;
1825
1826 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1827 {
1828 uint64_t gidd = gidvid;
1829 uint64_t gidm = 0;
1830
1831 pw_t pw;
1832
1833 gidd_to_pw_t (device_param, gidd, &pw);
1834
1835 for (int i = 0, j = gidm; i < 16; i++, j++)
1836 {
1837 plain_buf[i] = pw.hi1[0][j];
1838 }
1839
1840 plain_len = pw.pw_len;
1841
1842 const uint off = device_param->innerloop_pos + il_pos;
1843
1844 if (debug_mode > 0)
1845 {
1846 debug_rule_len = 0;
1847
1848 // save rule
1849 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1850 {
1851 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1852
1853 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1854 }
1855
1856 // save plain
1857 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1858 {
1859 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1860
1861 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1862
1863 debug_plain_len = plain_len;
1864 }
1865 }
1866
1867 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1868
1869 crackpos += gidvid;
1870 crackpos *= data.kernel_rules_cnt;
1871 crackpos += device_param->innerloop_pos + il_pos;
1872
1873 if (plain_len > data.pw_max) plain_len = data.pw_max;
1874 }
1875 else if (data.attack_mode == ATTACK_MODE_COMBI)
1876 {
1877 uint64_t gidd = gidvid;
1878 uint64_t gidm = 0;
1879
1880 pw_t pw;
1881
1882 gidd_to_pw_t (device_param, gidd, &pw);
1883
1884 for (int i = 0, j = gidm; i < 16; i++, j++)
1885 {
1886 plain_buf[i] = pw.hi1[0][j];
1887 }
1888
1889 plain_len = pw.pw_len;
1890
1891 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1892 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1893
1894 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1895 {
1896 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1897 }
1898 else
1899 {
1900 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1901
1902 memcpy (plain_ptr, comb_buf, comb_len);
1903 }
1904
1905 plain_len += comb_len;
1906
1907 crackpos += gidvid;
1908 crackpos *= data.combs_cnt;
1909 crackpos += device_param->innerloop_pos + il_pos;
1910
1911 if (data.pw_max != PW_DICTMAX1)
1912 {
1913 if (plain_len > data.pw_max) plain_len = data.pw_max;
1914 }
1915 }
1916 else if (data.attack_mode == ATTACK_MODE_BF)
1917 {
1918 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1919 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1920
1921 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1922 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1923
1924 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1925 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1926
1927 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1928 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1929
1930 plain_len = data.css_cnt;
1931
1932 crackpos += gidvid;
1933 crackpos *= data.bfs_cnt;
1934 crackpos += device_param->innerloop_pos + il_pos;
1935 }
1936 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1937 {
1938 uint64_t gidd = gidvid;
1939 uint64_t gidm = 0;
1940
1941 pw_t pw;
1942
1943 gidd_to_pw_t (device_param, gidd, &pw);
1944
1945 for (int i = 0, j = gidm; i < 16; i++, j++)
1946 {
1947 plain_buf[i] = pw.hi1[0][j];
1948 }
1949
1950 plain_len = pw.pw_len;
1951
1952 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1953
1954 uint start = 0;
1955 uint stop = device_param->kernel_params_mp_buf32[4];
1956
1957 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1958
1959 plain_len += start + stop;
1960
1961 crackpos += gidvid;
1962 crackpos *= data.combs_cnt;
1963 crackpos += device_param->innerloop_pos + il_pos;
1964
1965 if (data.pw_max != PW_DICTMAX1)
1966 {
1967 if (plain_len > data.pw_max) plain_len = data.pw_max;
1968 }
1969 }
1970 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1971 {
1972 uint64_t gidd = gidvid;
1973 uint64_t gidm = 0;
1974
1975 pw_t pw;
1976
1977 gidd_to_pw_t (device_param, gidd, &pw);
1978
1979 for (int i = 0, j = gidm; i < 16; i++, j++)
1980 {
1981 plain_buf[i] = pw.hi1[0][j];
1982 }
1983
1984 plain_len = pw.pw_len;
1985
1986 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1987
1988 uint start = 0;
1989 uint stop = device_param->kernel_params_mp_buf32[4];
1990
1991 memmove (plain_ptr + stop, plain_ptr, plain_len);
1992
1993 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1994
1995 plain_len += start + stop;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.combs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000
2001 if (data.pw_max != PW_DICTMAX1)
2002 {
2003 if (plain_len > data.pw_max) plain_len = data.pw_max;
2004 }
2005 }
2006
2007 if (data.attack_mode == ATTACK_MODE_BF)
2008 {
2009 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2010 {
2011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2012 {
2013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2014 {
2015 plain_len = plain_len - data.salts_buf[0].salt_len;
2016 }
2017 }
2018
2019 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2020 {
2021 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2022 {
2023 plain_ptr[j] = plain_ptr[i];
2024 }
2025
2026 plain_len = plain_len / 2;
2027 }
2028 }
2029 }
2030
2031 // if enabled, update also the potfile
2032
2033 if (pot_fp)
2034 {
2035 fprintf (pot_fp, "%s:", out_buf);
2036
2037 format_plain (pot_fp, plain_ptr, plain_len, 1);
2038
2039 fputc ('\n', pot_fp);
2040
2041 fflush (pot_fp);
2042 }
2043
2044 // outfile
2045
2046 FILE *out_fp = NULL;
2047
2048 if (outfile != NULL)
2049 {
2050 if ((out_fp = fopen (outfile, "ab")) == NULL)
2051 {
2052 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2053
2054 out_fp = stdout;
2055 }
2056 }
2057 else
2058 {
2059 out_fp = stdout;
2060
2061 if (quiet == 0) clear_prompt ();
2062 }
2063
2064 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2065
2066 if (outfile != NULL)
2067 {
2068 if (out_fp != stdout)
2069 {
2070 fclose (out_fp);
2071 }
2072 }
2073 else
2074 {
2075 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2076 {
2077 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2078 {
2079 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2080 if (quiet == 0) fflush (stdout);
2081 }
2082 }
2083 }
2084
2085 // loopback
2086
2087 if (loopback)
2088 {
2089 char *loopback_file = data.loopback_file;
2090
2091 FILE *fb_fp = NULL;
2092
2093 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2094 {
2095 format_plain (fb_fp, plain_ptr, plain_len, 1);
2096
2097 fputc ('\n', fb_fp);
2098
2099 fclose (fb_fp);
2100 }
2101 }
2102
2103 // (rule) debug mode
2104
2105 // the next check implies that:
2106 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2107 // - debug_mode > 0
2108
2109 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2110 {
2111 if (debug_rule_len < 0) debug_rule_len = 0;
2112
2113 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2114
2115 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2116
2117 if ((quiet == 0) && (debug_file == NULL))
2118 {
2119 fprintf (stdout, "%s", PROMPT);
2120 fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2126 {
2127 salt_t *salt_buf = &data.salts_buf[salt_pos];
2128
2129 int found = 0;
2130
2131 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2132
2133 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2134
2135 if (found == 1)
2136 {
2137 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2138
2139 log_info_nn ("");
2140
2141 hc_clEnqueueReadBuffer (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);
2142
2143 uint cpt_cracked = 0;
2144
2145 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2146 {
2147 uint idx = salt_buf->digests_offset + digest_pos;
2148
2149 if (data.digests_shown_tmp[idx] == 0) continue;
2150
2151 if (data.digests_shown[idx] == 1) continue;
2152
2153 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2154 {
2155 data.digests_shown[idx] = 1;
2156
2157 data.digests_done++;
2158
2159 cpt_cracked++;
2160
2161 salt_buf->digests_done++;
2162
2163 if (salt_buf->digests_done == salt_buf->digests_cnt)
2164 {
2165 data.salts_shown[salt_pos] = 1;
2166
2167 data.salts_done++;
2168 }
2169 }
2170
2171 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2172
2173 check_hash (device_param, salt_pos, digest_pos);
2174 }
2175
2176 if (cpt_cracked > 0)
2177 {
2178 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2179 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2180
2181 data.cpt_pos++;
2182
2183 data.cpt_total += cpt_cracked;
2184
2185 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2186 }
2187
2188 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2189 {
2190 // we need to reset cracked state on the device
2191 // otherwise host thinks again and again the hash was cracked
2192 // and returns invalid password each time
2193
2194 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2195
2196 hc_clEnqueueWriteBuffer (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);
2197 }
2198
2199 memset (device_param->result, 0, device_param->size_results);
2200
2201 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2202 }
2203 }
2204
2205 static void save_hash ()
2206 {
2207 char *hashfile = data.hashfile;
2208
2209 char new_hashfile[256];
2210 char old_hashfile[256];
2211
2212 memset (new_hashfile, 0, sizeof (new_hashfile));
2213 memset (old_hashfile, 0, sizeof (old_hashfile));
2214
2215 snprintf (new_hashfile, 255, "%s.new", hashfile);
2216 snprintf (old_hashfile, 255, "%s.old", hashfile);
2217
2218 unlink (new_hashfile);
2219
2220 char separator = data.separator;
2221
2222 FILE *fp = fopen (new_hashfile, "wb");
2223
2224 if (fp == NULL)
2225 {
2226 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2227
2228 exit (-1);
2229 }
2230
2231 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2232 {
2233 if (data.salts_shown[salt_pos] == 1) continue;
2234
2235 salt_t *salt_buf = &data.salts_buf[salt_pos];
2236
2237 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2238 {
2239 uint idx = salt_buf->digests_offset + digest_pos;
2240
2241 if (data.digests_shown[idx] == 1) continue;
2242
2243 if (data.hash_mode != 2500)
2244 {
2245 char out_buf[4096];
2246
2247 memset (out_buf, 0, sizeof (out_buf));
2248
2249 if (data.username == 1)
2250 {
2251 user_t *user = data.hash_info[idx]->user;
2252
2253 uint i;
2254
2255 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2256
2257 fputc (separator, fp);
2258 }
2259
2260 ascii_digest (out_buf, salt_pos, digest_pos);
2261
2262 fputs (out_buf, fp);
2263
2264 log_out (fp, "");
2265 }
2266 else
2267 {
2268 hccap_t hccap;
2269
2270 to_hccap_t (&hccap, salt_pos, digest_pos);
2271
2272 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2273 }
2274 }
2275 }
2276
2277 fflush (fp);
2278
2279 fclose (fp);
2280
2281 unlink (old_hashfile);
2282
2283 if (rename (hashfile, old_hashfile) != 0)
2284 {
2285 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2286
2287 exit (-1);
2288 }
2289
2290 unlink (hashfile);
2291
2292 if (rename (new_hashfile, hashfile) != 0)
2293 {
2294 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2295
2296 exit (-1);
2297 }
2298
2299 unlink (old_hashfile);
2300 }
2301
2302 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2303 {
2304 // function called only in case kernel_blocks_all > words_left)
2305
2306 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2307
2308 kernel_blocks_div += kernel_blocks_div / 100;
2309
2310 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2311
2312 while (kernel_blocks_new < total_left)
2313 {
2314 kernel_blocks_div += kernel_blocks_div / 100;
2315
2316 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2317 }
2318
2319 if (data.quiet == 0)
2320 {
2321 clear_prompt ();
2322
2323 log_info ("");
2324
2325 log_info ("INFO: approaching final keyspace, workload adjusted");
2326
2327 log_info ("");
2328
2329 fprintf (stdout, "%s", PROMPT);
2330
2331 fflush (stdout);
2332 }
2333
2334 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2335
2336 return kernel_blocks_div;
2337 }
2338
2339 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2340 {
2341 uint num_elements = num;
2342
2343 device_param->kernel_params_buf32[30] = data.combs_mode;
2344 device_param->kernel_params_buf32[31] = num;
2345
2346 uint kernel_threads = device_param->kernel_threads;
2347
2348 while (num_elements % kernel_threads) num_elements++;
2349
2350 cl_kernel kernel = NULL;
2351
2352 switch (kern_run)
2353 {
2354 case KERN_RUN_1: kernel = device_param->kernel1; break;
2355 case KERN_RUN_12: kernel = device_param->kernel12; break;
2356 case KERN_RUN_2: kernel = device_param->kernel2; break;
2357 case KERN_RUN_23: kernel = device_param->kernel23; break;
2358 case KERN_RUN_3: kernel = device_param->kernel3; break;
2359 case KERN_RUN_WEAK: kernel = device_param->kernel_weak; break;
2360 }
2361
2362 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2363 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2364 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2365 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2366 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2367 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2368 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2369 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2370 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2371 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2372 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2373
2374 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2375 {
2376 const size_t global_work_size[3] = { num_elements, 32, 1 };
2377 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2378
2379 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2380 }
2381 else
2382 {
2383 const size_t global_work_size[3] = { num_elements, 1, 1 };
2384 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2385
2386 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2387 }
2388
2389 hc_clFlush (device_param->command_queue);
2390
2391 hc_clFinish (device_param->command_queue);
2392 }
2393
2394 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2395 {
2396 uint num_elements = num;
2397
2398 switch (kern_run)
2399 {
2400 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2401 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2402 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2403 }
2404
2405 // causes problems with special threads like in bcrypt
2406 // const uint kernel_threads = device_param->kernel_threads;
2407
2408 const uint kernel_threads = KERNEL_THREADS;
2409
2410 while (num_elements % kernel_threads) num_elements++;
2411
2412 cl_kernel kernel = NULL;
2413
2414 switch (kern_run)
2415 {
2416 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2417 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2418 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2419 }
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2424 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2425 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2426 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2427 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2428 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2429 break;
2430 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2431 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2432 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2433 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2434 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2435 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2436 break;
2437 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2438 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2439 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2440 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2441 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2442 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2443 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2444 break;
2445 }
2446
2447 const size_t global_work_size[3] = { num_elements, 1, 1 };
2448 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2449
2450 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2451
2452 hc_clFlush (device_param->command_queue);
2453
2454 hc_clFinish (device_param->command_queue);
2455 }
2456
2457 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2458 {
2459 uint num_elements = num;
2460
2461 uint kernel_threads = device_param->kernel_threads;
2462
2463 while (num_elements % kernel_threads) num_elements++;
2464
2465 cl_kernel kernel = device_param->kernel_tb;
2466
2467 const size_t global_work_size[3] = { num_elements, 1, 1 };
2468 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2469
2470 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2471
2472 hc_clFlush (device_param->command_queue);
2473
2474 hc_clFinish (device_param->command_queue);
2475 }
2476
2477 static void run_kernel_tm (hc_device_param_t *device_param)
2478 {
2479 const uint num_elements = 1024; // fixed
2480
2481 const uint kernel_threads = 32;
2482
2483 cl_kernel kernel = device_param->kernel_tm;
2484
2485 const size_t global_work_size[3] = { num_elements, 1, 1 };
2486 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2487
2488 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2489
2490 hc_clFlush (device_param->command_queue);
2491
2492 hc_clFinish (device_param->command_queue);
2493 }
2494
2495 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2496 {
2497 uint num_elements = num;
2498
2499 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2500 device_param->kernel_params_amp_buf32[6] = num_elements;
2501
2502 // causes problems with special threads like in bcrypt
2503 // const uint kernel_threads = device_param->kernel_threads;
2504
2505 const uint kernel_threads = KERNEL_THREADS;
2506
2507 while (num_elements % kernel_threads) num_elements++;
2508
2509 cl_kernel kernel = device_param->kernel_amp;
2510
2511 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2512 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2513
2514 const size_t global_work_size[3] = { num_elements, 1, 1 };
2515 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2516
2517 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2518
2519 hc_clFlush (device_param->command_queue);
2520
2521 hc_clFinish (device_param->command_queue);
2522 }
2523
2524 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2525 {
2526 if (data.vendor_id == VENDOR_ID_AMD)
2527 {
2528 const cl_uchar zero = 0;
2529
2530 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2531 }
2532
2533 if (data.vendor_id == VENDOR_ID_NV)
2534 {
2535 // NOTE: clEnqueueFillBuffer () always fails with -59
2536 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2537 // How's that possible, OpenCL 1.2 support is advertised??
2538 // We need to workaround...
2539
2540 #define FILLSZ 0x100000
2541
2542 char *tmp = (char *) mymalloc (FILLSZ);
2543
2544 memset (tmp, 0, FILLSZ);
2545
2546 for (uint i = 0; i < size; i += FILLSZ)
2547 {
2548 const int left = size - i;
2549
2550 const int fillsz = MIN (FILLSZ, left);
2551
2552 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2553 }
2554
2555 myfree (tmp);
2556 }
2557
2558 if (data.vendor_id == VENDOR_ID_GENERIC)
2559 {
2560 const cl_uchar zero = 0;
2561
2562 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2563 }
2564 }
2565
2566 static int run_rule_engine (const int rule_len, const char *rule_buf)
2567 {
2568 if (rule_len == 0)
2569 {
2570 return 0;
2571 }
2572 else if (rule_len == 1)
2573 {
2574 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2575 }
2576
2577 return 1;
2578 }
2579
2580 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2581 {
2582 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2583 {
2584 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2585 }
2586 else if (data.attack_kern == ATTACK_KERN_COMBI)
2587 {
2588 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2589 }
2590 else if (data.attack_kern == ATTACK_KERN_BF)
2591 {
2592 const uint64_t off = device_param->words_off;
2593
2594 device_param->kernel_params_mp_l_buf64[3] = off;
2595
2596 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2597 }
2598 }
2599
2600 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2601 {
2602 const uint kernel_loops = data.kernel_loops;
2603
2604 // init speed timer
2605
2606 uint speed_pos = device_param->speed_pos;
2607
2608 #ifdef _POSIX
2609 if (device_param->timer_speed.tv_sec == 0)
2610 {
2611 hc_timer_set (&device_param->timer_speed);
2612 }
2613 #endif
2614
2615 #ifdef _WIN
2616 if (device_param->timer_speed.QuadPart == 0)
2617 {
2618 hc_timer_set (&device_param->timer_speed);
2619 }
2620 #endif
2621
2622 // find higest password length, this is for optimization stuff
2623
2624 uint highest_pw_len = 0;
2625
2626 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2627 {
2628 }
2629 else if (data.attack_kern == ATTACK_KERN_COMBI)
2630 {
2631 }
2632 else if (data.attack_kern == ATTACK_KERN_BF)
2633 {
2634 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2635 + device_param->kernel_params_mp_l_buf32[5];
2636 }
2637
2638 // bitslice optimization stuff
2639
2640 if (data.attack_mode == ATTACK_MODE_BF)
2641 {
2642 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2643 {
2644 run_kernel_tb (device_param, pws_cnt);
2645 }
2646 }
2647
2648 // iteration type
2649
2650 uint innerloop_step = 0;
2651 uint innerloop_cnt = 0;
2652
2653 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2654 else innerloop_step = 1;
2655
2656 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2657 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2658 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2659
2660 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2661
2662 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2663 {
2664 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2665
2666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2667
2668 if (data.devices_status == STATUS_CRACKED) break;
2669 if (data.devices_status == STATUS_ABORTED) break;
2670 if (data.devices_status == STATUS_QUIT) break;
2671 if (data.devices_status == STATUS_BYPASS) break;
2672
2673 if (data.salts_shown[salt_pos] == 1) continue;
2674
2675 salt_t *salt_buf = &data.salts_buf[salt_pos];
2676
2677 device_param->kernel_params_buf32[24] = salt_pos;
2678 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2679 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2680
2681 FILE *combs_fp = device_param->combs_fp;
2682
2683 if (data.attack_mode == ATTACK_MODE_COMBI)
2684 {
2685 rewind (combs_fp);
2686 }
2687
2688 // innerloops
2689
2690 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2691 {
2692 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2693
2694 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2695
2696 if (data.devices_status == STATUS_CRACKED) break;
2697 if (data.devices_status == STATUS_ABORTED) break;
2698 if (data.devices_status == STATUS_QUIT) break;
2699 if (data.devices_status == STATUS_BYPASS) break;
2700
2701 uint innerloop_left = innerloop_cnt - innerloop_pos;
2702
2703 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2704
2705 device_param->innerloop_pos = innerloop_pos;
2706 device_param->innerloop_left = innerloop_left;
2707
2708 device_param->kernel_params_buf32[27] = innerloop_left;
2709
2710 if (innerloop_left == 0) continue;
2711
2712 // initialize amplifiers
2713
2714 if (data.attack_mode == ATTACK_MODE_COMBI)
2715 {
2716 char line_buf[BUFSIZ];
2717
2718 uint i = 0;
2719
2720 while (i < innerloop_left)
2721 {
2722 if (feof (combs_fp)) break;
2723
2724 int line_len = fgetl (combs_fp, line_buf);
2725
2726 if (line_len >= PW_MAX1) continue;
2727
2728 line_len = convert_from_hex (line_buf, line_len);
2729
2730 char *line_buf_new = line_buf;
2731
2732 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2733 {
2734 char rule_buf_out[BLOCK_SIZE];
2735
2736 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2737
2738 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2739
2740 if (rule_len_out < 0)
2741 {
2742 data.words_progress_rejected[salt_pos] += pw_cnt;
2743
2744 continue;
2745 }
2746
2747 line_len = rule_len_out;
2748
2749 line_buf_new = rule_buf_out;
2750 }
2751
2752 line_len = MIN (line_len, PW_DICTMAX);
2753
2754 char *ptr = (char *) device_param->combs_buf[i].i;
2755
2756 memcpy (ptr, line_buf_new, line_len);
2757
2758 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2759
2760 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2761 {
2762 uppercase (ptr, line_len);
2763 }
2764
2765 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2766 {
2767 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2768 {
2769 ptr[line_len] = 0x80;
2770 }
2771
2772 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2773 {
2774 ptr[line_len] = 0x01;
2775 }
2776 }
2777
2778 device_param->combs_buf[i].pw_len = line_len;
2779
2780 i++;
2781 }
2782
2783 for (uint j = i; j < innerloop_left; j++)
2784 {
2785 device_param->combs_buf[j].i[0] = 0;
2786 device_param->combs_buf[j].i[1] = 0;
2787 device_param->combs_buf[j].i[2] = 0;
2788 device_param->combs_buf[j].i[3] = 0;
2789 device_param->combs_buf[j].i[4] = 0;
2790 device_param->combs_buf[j].i[5] = 0;
2791 device_param->combs_buf[j].i[6] = 0;
2792 device_param->combs_buf[j].i[7] = 0;
2793
2794 device_param->combs_buf[j].pw_len = 0;
2795 }
2796
2797 innerloop_left = i;
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_BF)
2800 {
2801 uint64_t off = innerloop_pos;
2802
2803 device_param->kernel_params_mp_r_buf64[3] = off;
2804
2805 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2806 }
2807 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2808 {
2809 uint64_t off = innerloop_pos;
2810
2811 device_param->kernel_params_mp_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2814 }
2815 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2816 {
2817 uint64_t off = innerloop_pos;
2818
2819 device_param->kernel_params_mp_buf64[3] = off;
2820
2821 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2822 }
2823
2824 // copy amplifiers
2825
2826 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2827 {
2828 hc_clEnqueueCopyBuffer (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);
2829 }
2830 else if (data.attack_mode == ATTACK_MODE_COMBI)
2831 {
2832 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2833 }
2834 else if (data.attack_mode == ATTACK_MODE_BF)
2835 {
2836 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2837 }
2838 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2839 {
2840 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2841 }
2842 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2843 {
2844 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2845 }
2846
2847 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2848 {
2849 if (data.attack_mode == ATTACK_MODE_BF)
2850 {
2851 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2852 {
2853 const uint size_tm = 32 * sizeof (bs_word_t);
2854
2855 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2856
2857 run_kernel_tm (device_param);
2858
2859 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2860 }
2861 }
2862
2863 if (highest_pw_len < 16)
2864 {
2865 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2866 }
2867 else if (highest_pw_len < 32)
2868 {
2869 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2870 }
2871 else
2872 {
2873 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2874 }
2875 }
2876 else
2877 {
2878 run_kernel_amp (device_param, pws_cnt);
2879
2880 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2881
2882 if (data.opts_type & OPTS_TYPE_HOOK12)
2883 {
2884 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2885 }
2886
2887 uint iter = salt_buf->salt_iter;
2888
2889 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2890 {
2891 uint loop_left = iter - loop_pos;
2892
2893 loop_left = MIN (loop_left, kernel_loops);
2894
2895 device_param->kernel_params_buf32[25] = loop_pos;
2896 device_param->kernel_params_buf32[26] = loop_left;
2897
2898 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2899
2900 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2901
2902 if (data.devices_status == STATUS_CRACKED) break;
2903 if (data.devices_status == STATUS_ABORTED) break;
2904 if (data.devices_status == STATUS_QUIT) break;
2905 }
2906
2907 if (data.opts_type & OPTS_TYPE_HOOK23)
2908 {
2909 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2910
2911 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2912
2913 // do something with data
2914
2915 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2916 }
2917
2918 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2919 }
2920
2921 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2922
2923 if (data.devices_status == STATUS_CRACKED) break;
2924 if (data.devices_status == STATUS_ABORTED) break;
2925 if (data.devices_status == STATUS_QUIT) break;
2926
2927 /**
2928 * result
2929 */
2930
2931 hc_thread_mutex_lock (mux_display);
2932
2933 check_cracked (device_param, salt_pos);
2934
2935 hc_thread_mutex_unlock (mux_display);
2936
2937 /**
2938 * progress
2939 */
2940
2941 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2942
2943 hc_thread_mutex_lock (mux_counter);
2944
2945 data.words_progress_done[salt_pos] += perf_sum_all;
2946
2947 hc_thread_mutex_unlock (mux_counter);
2948
2949 /**
2950 * speed
2951 */
2952
2953 float speed_ms;
2954
2955 hc_timer_get (device_param->timer_speed, speed_ms);
2956
2957 hc_timer_set (&device_param->timer_speed);
2958
2959 hc_thread_mutex_lock (mux_display);
2960
2961 device_param->speed_cnt[speed_pos] = perf_sum_all;
2962
2963 device_param->speed_ms[speed_pos] = speed_ms;
2964
2965 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2966
2967 hc_thread_mutex_unlock (mux_display);
2968
2969 speed_pos++;
2970
2971 if (speed_pos == SPEED_CACHE)
2972 {
2973 speed_pos = 0;
2974 }
2975 }
2976 }
2977
2978 device_param->speed_pos = speed_pos;
2979 }
2980
2981 static void load_segment (wl_data_t *wl_data, FILE *fd)
2982 {
2983 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2984
2985 wl_data->pos = 0;
2986
2987 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2988
2989 wl_data->buf[wl_data->cnt] = 0;
2990
2991 if (wl_data->cnt == 0) return;
2992
2993 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2994
2995 while (!feof (fd))
2996 {
2997 if (wl_data->cnt == wl_data->avail)
2998 {
2999 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3000
3001 wl_data->avail += wl_data->incr;
3002 }
3003
3004 const int c = fgetc (fd);
3005
3006 if (c == EOF) break;
3007
3008 wl_data->buf[wl_data->cnt] = (char) c;
3009
3010 wl_data->cnt++;
3011
3012 if (c == '\n') break;
3013 }
3014
3015 // ensure stream ends with a newline
3016
3017 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3018 {
3019 wl_data->cnt++;
3020
3021 wl_data->buf[wl_data->cnt - 1] = '\n';
3022 }
3023
3024 return;
3025 }
3026
3027 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3028 {
3029 char *ptr = buf;
3030
3031 for (uint32_t i = 0; i < sz; i++, ptr++)
3032 {
3033 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3034
3035 if (i == 7)
3036 {
3037 *off = i;
3038 *len = i;
3039
3040 return;
3041 }
3042
3043 if (*ptr != '\n') continue;
3044
3045 *off = i + 1;
3046
3047 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3048
3049 *len = i;
3050
3051 return;
3052 }
3053
3054 *off = sz;
3055 *len = sz;
3056 }
3057
3058 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3059 {
3060 char *ptr = buf;
3061
3062 for (uint32_t i = 0; i < sz; i++, ptr++)
3063 {
3064 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3065
3066 if (*ptr != '\n') continue;
3067
3068 *off = i + 1;
3069
3070 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3071
3072 *len = i;
3073
3074 return;
3075 }
3076
3077 *off = sz;
3078 *len = sz;
3079 }
3080
3081 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3082 {
3083 char *ptr = buf;
3084
3085 for (uint32_t i = 0; i < sz; i++, ptr++)
3086 {
3087 if (*ptr != '\n') continue;
3088
3089 *off = i + 1;
3090
3091 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3092
3093 *len = i;
3094
3095 return;
3096 }
3097
3098 *off = sz;
3099 *len = sz;
3100 }
3101
3102 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3103 {
3104 while (wl_data->pos < wl_data->cnt)
3105 {
3106 uint off;
3107 uint len;
3108
3109 char *ptr = wl_data->buf + wl_data->pos;
3110
3111 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3112
3113 wl_data->pos += off;
3114
3115 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3116 {
3117 char rule_buf_out[BLOCK_SIZE];
3118
3119 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3120
3121 int rule_len_out = -1;
3122
3123 if (len < BLOCK_SIZE)
3124 {
3125 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3126 }
3127
3128 if (rule_len_out < 0)
3129 {
3130 continue;
3131 }
3132
3133 if (rule_len_out > PW_MAX)
3134 {
3135 continue;
3136 }
3137 }
3138 else
3139 {
3140 if (len > PW_MAX)
3141 {
3142 continue;
3143 }
3144 }
3145
3146 *out_buf = ptr;
3147 *out_len = len;
3148
3149 return;
3150 }
3151
3152 if (feof (fd))
3153 {
3154 fprintf (stderr, "bug!!\n");
3155
3156 return;
3157 }
3158
3159 load_segment (wl_data, fd);
3160
3161 get_next_word (wl_data, fd, out_buf, out_len);
3162 }
3163
3164 #ifdef _POSIX
3165 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3166 #endif
3167
3168 #ifdef _WIN
3169 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3170 #endif
3171 {
3172 hc_signal (NULL);
3173
3174 dictstat_t d;
3175
3176 d.cnt = 0;
3177
3178 #ifdef _POSIX
3179 fstat (fileno (fd), &d.stat);
3180 #endif
3181
3182 #ifdef _WIN
3183 _fstat64 (fileno (fd), &d.stat);
3184 #endif
3185
3186 d.stat.st_mode = 0;
3187 d.stat.st_nlink = 0;
3188 d.stat.st_uid = 0;
3189 d.stat.st_gid = 0;
3190 d.stat.st_rdev = 0;
3191 d.stat.st_atime = 0;
3192
3193 #ifdef _POSIX
3194 d.stat.st_blksize = 0;
3195 d.stat.st_blocks = 0;
3196 #endif
3197
3198 if (d.stat.st_size == 0) return 0;
3199
3200 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3201
3202 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3203 {
3204 if (d_cache)
3205 {
3206 uint64_t cnt = d_cache->cnt;
3207
3208 uint64_t keyspace = cnt;
3209
3210 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3211 {
3212 keyspace *= data.kernel_rules_cnt;
3213 }
3214 else if (data.attack_kern == ATTACK_KERN_COMBI)
3215 {
3216 keyspace *= data.combs_cnt;
3217 }
3218
3219 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);
3220 if (data.quiet == 0) log_info ("");
3221
3222 hc_signal (sigHandler_default);
3223
3224 return (keyspace);
3225 }
3226 }
3227
3228 time_t now = 0;
3229 time_t prev = 0;
3230
3231 uint64_t comp = 0;
3232 uint64_t cnt = 0;
3233 uint64_t cnt2 = 0;
3234
3235 while (!feof (fd))
3236 {
3237 load_segment (wl_data, fd);
3238
3239 comp += wl_data->cnt;
3240
3241 uint32_t i = 0;
3242
3243 while (i < wl_data->cnt)
3244 {
3245 uint32_t len;
3246 uint32_t off;
3247
3248 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3249
3250 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3251 {
3252 char rule_buf_out[BLOCK_SIZE];
3253
3254 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3255
3256 int rule_len_out = -1;
3257
3258 if (len < BLOCK_SIZE)
3259 {
3260 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3261 }
3262
3263 if (rule_len_out < 0)
3264 {
3265 len = PW_MAX1;
3266 }
3267 else
3268 {
3269 len = rule_len_out;
3270 }
3271 }
3272
3273 if (len < PW_MAX1)
3274 {
3275 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3276 {
3277 cnt += data.kernel_rules_cnt;
3278 }
3279 else if (data.attack_kern == ATTACK_KERN_COMBI)
3280 {
3281 cnt += data.combs_cnt;
3282 }
3283
3284 d.cnt++;
3285 }
3286
3287 i += off;
3288
3289 cnt2++;
3290 }
3291
3292 time (&now);
3293
3294 if ((now - prev) == 0) continue;
3295
3296 float percent = (float) comp / (float) d.stat.st_size;
3297
3298 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);
3299
3300 time (&prev);
3301 }
3302
3303 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);
3304 if (data.quiet == 0) log_info ("");
3305
3306 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3307
3308 hc_signal (sigHandler_default);
3309
3310 return (cnt);
3311 }
3312
3313 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3314 {
3315 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3316 }
3317
3318 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3319 {
3320 if (data.devices_status == STATUS_BYPASS) return 0;
3321
3322 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3323
3324 uint cache_cnt = pw_cache->cnt;
3325
3326 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3327
3328 memcpy (pw_hc1, pw_buf, pw_len);
3329
3330 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3331
3332 uint pws_cnt = device_param->pws_cnt;
3333
3334 cache_cnt++;
3335
3336 pw_t *pw = device_param->pws_buf + pws_cnt;
3337
3338 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3339
3340 pw->pw_len = pw_len;
3341
3342 pws_cnt++;
3343
3344 device_param->pws_cnt = pws_cnt;
3345 device_param->pw_cnt = pws_cnt * 1;
3346
3347 cache_cnt = 0;
3348
3349 pw_cache->cnt = cache_cnt;
3350
3351 return pws_cnt;
3352 }
3353
3354 static void *thread_monitor (void *p)
3355 {
3356 uint runtime_check = 0;
3357 uint remove_check = 0;
3358 uint status_check = 0;
3359 uint hwmon_check = 0;
3360 uint restore_check = 0;
3361
3362 uint restore_left = data.restore_timer;
3363 uint remove_left = data.remove_timer;
3364 uint status_left = data.status_timer;
3365
3366 // these variables are mainly used for fan control (AMD only)
3367
3368 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3369
3370 // temperature controller "loopback" values
3371
3372 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3373 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3374
3375 int temp_threshold = 1; // degrees celcius
3376
3377 int fan_speed_min = 15; // in percentage
3378 int fan_speed_max = 100;
3379
3380 time_t last_temp_check_time;
3381
3382 uint sleep_time = 1;
3383
3384 if (data.runtime)
3385 {
3386 runtime_check = 1;
3387 }
3388
3389 if (data.restore_timer)
3390 {
3391 restore_check = 1;
3392 }
3393
3394 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3395 {
3396 remove_check = 1;
3397 }
3398
3399 if (data.status == 1)
3400 {
3401 status_check = 1;
3402 }
3403
3404 if (data.gpu_temp_disable == 0)
3405 {
3406 time (&last_temp_check_time);
3407
3408 hwmon_check = 1;
3409 }
3410
3411 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3412 {
3413 return (p);
3414 }
3415
3416 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3417 {
3418 hc_sleep (sleep_time);
3419
3420 if (data.devices_status != STATUS_RUNNING) continue;
3421
3422 if (hwmon_check == 1)
3423 {
3424 hc_thread_mutex_lock (mux_adl);
3425
3426 time_t temp_check_time;
3427
3428 time (&temp_check_time);
3429
3430 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3431
3432 if (Ta == 0) Ta = 1;
3433
3434 for (uint i = 0; i < data.devices_cnt; i++)
3435 {
3436 if ((data.devices_param[i].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3437
3438 const int temperature = hm_get_temperature_with_device_id (i);
3439
3440 if (temperature > (int) data.gpu_temp_abort)
3441 {
3442 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3443
3444 if (data.devices_status != STATUS_QUIT) myabort ();
3445
3446 break;
3447 }
3448
3449 const int gpu_temp_retain = data.gpu_temp_retain;
3450
3451 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3452 {
3453 if (data.hm_device[i].fan_supported == 1)
3454 {
3455 int temp_cur = temperature;
3456
3457 int temp_diff_new = gpu_temp_retain - temp_cur;
3458
3459 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3460
3461 // calculate Ta value (time difference in seconds between the last check and this check)
3462
3463 last_temp_check_time = temp_check_time;
3464
3465 float Kp = 1.8;
3466 float Ki = 0.005;
3467 float Kd = 6;
3468
3469 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3470
3471 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3472
3473 if (abs (fan_diff_required) >= temp_threshold)
3474 {
3475 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3476
3477 int fan_speed_level = fan_speed_cur;
3478
3479 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3480
3481 int fan_speed_new = fan_speed_level - fan_diff_required;
3482
3483 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3484 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3485
3486 if (fan_speed_new != fan_speed_cur)
3487 {
3488 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3489 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3490
3491 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3492 {
3493 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3494
3495 fan_speed_chgd[i] = 1;
3496 }
3497
3498 temp_diff_old[i] = temp_diff_new;
3499 }
3500 }
3501 }
3502 }
3503 }
3504
3505 hc_thread_mutex_unlock (mux_adl);
3506 }
3507
3508 if (restore_check == 1)
3509 {
3510 restore_left--;
3511
3512 if (restore_left == 0)
3513 {
3514 if (data.restore_disable == 0) cycle_restore ();
3515
3516 restore_left = data.restore_timer;
3517 }
3518 }
3519
3520 if ((runtime_check == 1) && (data.runtime_start > 0))
3521 {
3522 time_t runtime_cur;
3523
3524 time (&runtime_cur);
3525
3526 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3527
3528 if (runtime_left <= 0)
3529 {
3530 if (data.benchmark == 0)
3531 {
3532 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3533 }
3534
3535 if (data.devices_status != STATUS_QUIT) myabort ();
3536 }
3537 }
3538
3539 if (remove_check == 1)
3540 {
3541 remove_left--;
3542
3543 if (remove_left == 0)
3544 {
3545 if (data.digests_saved != data.digests_done)
3546 {
3547 data.digests_saved = data.digests_done;
3548
3549 save_hash ();
3550 }
3551
3552 remove_left = data.remove_timer;
3553 }
3554 }
3555
3556 if (status_check == 1)
3557 {
3558 status_left--;
3559
3560 if (status_left == 0)
3561 {
3562 hc_thread_mutex_lock (mux_display);
3563
3564 if (data.quiet == 0) clear_prompt ();
3565
3566 if (data.quiet == 0) log_info ("");
3567
3568 status_display ();
3569
3570 if (data.quiet == 0) log_info ("");
3571
3572 hc_thread_mutex_unlock (mux_display);
3573
3574 status_left = data.status_timer;
3575 }
3576 }
3577 }
3578
3579 myfree (fan_speed_chgd);
3580
3581 myfree (temp_diff_old);
3582 myfree (temp_diff_sum);
3583
3584 p = NULL;
3585
3586 return (p);
3587 }
3588
3589 static void *thread_outfile_remove (void *p)
3590 {
3591 // some hash-dependent constants
3592 char *outfile_dir = data.outfile_check_directory;
3593 uint dgst_size = data.dgst_size;
3594 uint isSalted = data.isSalted;
3595 uint esalt_size = data.esalt_size;
3596 uint hash_mode = data.hash_mode;
3597
3598 uint outfile_check_timer = data.outfile_check_timer;
3599
3600 char separator = data.separator;
3601
3602 // some hash-dependent functions
3603 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3604 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3605
3606 // buffers
3607 hash_t hash_buf;
3608
3609 memset (&hash_buf, 0, sizeof (hash_buf));
3610
3611 hash_buf.digest = mymalloc (dgst_size);
3612
3613 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3614
3615 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3616
3617 uint digest_buf[64];
3618
3619 outfile_data_t *out_info = NULL;
3620
3621 char **out_files = NULL;
3622
3623 time_t folder_mtime = 0;
3624
3625 int out_cnt = 0;
3626
3627 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3628
3629 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3630 {
3631 hc_sleep (1);
3632
3633 if (data.devices_status != STATUS_RUNNING) continue;
3634
3635 check_left--;
3636
3637 if (check_left == 0)
3638 {
3639 struct stat outfile_check_stat;
3640
3641 if (stat (outfile_dir, &outfile_check_stat) == 0)
3642 {
3643 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3644
3645 if (is_dir == 1)
3646 {
3647 if (outfile_check_stat.st_mtime > folder_mtime)
3648 {
3649 char **out_files_new = scan_directory (outfile_dir);
3650
3651 int out_cnt_new = count_dictionaries (out_files_new);
3652
3653 outfile_data_t *out_info_new = NULL;
3654
3655 if (out_cnt_new > 0)
3656 {
3657 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3658
3659 for (int i = 0; i < out_cnt_new; i++)
3660 {
3661 out_info_new[i].file_name = out_files_new[i];
3662
3663 // check if there are files that we have seen/checked before (and not changed)
3664
3665 for (int j = 0; j < out_cnt; j++)
3666 {
3667 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3668 {
3669 struct stat outfile_stat;
3670
3671 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3672 {
3673 if (outfile_stat.st_ctime == out_info[j].ctime)
3674 {
3675 out_info_new[i].ctime = out_info[j].ctime;
3676 out_info_new[i].seek = out_info[j].seek;
3677 }
3678 }
3679 }
3680 }
3681 }
3682 }
3683
3684 local_free (out_info);
3685 local_free (out_files);
3686
3687 out_files = out_files_new;
3688 out_cnt = out_cnt_new;
3689 out_info = out_info_new;
3690
3691 folder_mtime = outfile_check_stat.st_mtime;
3692 }
3693
3694 for (int j = 0; j < out_cnt; j++)
3695 {
3696 FILE *fp = fopen (out_info[j].file_name, "rb");
3697
3698 if (fp != NULL)
3699 {
3700 //hc_thread_mutex_lock (mux_display);
3701
3702 #ifdef _POSIX
3703 struct stat outfile_stat;
3704
3705 fstat (fileno (fp), &outfile_stat);
3706 #endif
3707
3708 #ifdef _WIN
3709 struct stat64 outfile_stat;
3710
3711 _fstat64 (fileno (fp), &outfile_stat);
3712 #endif
3713
3714 if (outfile_stat.st_ctime > out_info[j].ctime)
3715 {
3716 out_info[j].ctime = outfile_stat.st_ctime;
3717 out_info[j].seek = 0;
3718 }
3719
3720 fseek (fp, out_info[j].seek, SEEK_SET);
3721
3722 while (!feof (fp))
3723 {
3724 char line_buf[BUFSIZ];
3725
3726 memset (line_buf, 0, BUFSIZ);
3727
3728 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3729
3730 if (ptr == NULL) break;
3731
3732 int line_len = strlen (line_buf);
3733
3734 if (line_len <= 0) continue;
3735
3736 int iter = MAX_CUT_TRIES;
3737
3738 for (uint i = line_len - 1; i && iter; i--, line_len--)
3739 {
3740 if (line_buf[i] != separator) continue;
3741
3742 int parser_status = PARSER_OK;
3743
3744 if ((hash_mode != 2500) && (hash_mode != 6800))
3745 {
3746 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3747 }
3748
3749 uint found = 0;
3750
3751 if (parser_status == PARSER_OK)
3752 {
3753 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3754 {
3755 if (data.salts_shown[salt_pos] == 1) continue;
3756
3757 salt_t *salt_buf = &data.salts_buf[salt_pos];
3758
3759 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3760 {
3761 uint idx = salt_buf->digests_offset + digest_pos;
3762
3763 if (data.digests_shown[idx] == 1) continue;
3764
3765 uint cracked = 0;
3766
3767 if (hash_mode == 6800)
3768 {
3769 if (i == salt_buf->salt_len)
3770 {
3771 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3772 }
3773 }
3774 else if (hash_mode == 2500)
3775 {
3776 // BSSID : MAC1 : MAC2 (:plain)
3777 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3778 {
3779 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3780
3781 if (!cracked) continue;
3782
3783 // now compare MAC1 and MAC2 too, since we have this additional info
3784 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3785 char *mac2_pos = mac1_pos + 12 + 1;
3786
3787 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3788 wpa_t *wpa = &wpas[salt_pos];
3789
3790 uint pke[25];
3791
3792 char *pke_ptr = (char *) pke;
3793
3794 for (uint i = 0; i < 25; i++)
3795 {
3796 pke[i] = byte_swap_32 (wpa->pke[i]);
3797 }
3798
3799 unsigned char mac1[6];
3800 unsigned char mac2[6];
3801
3802 memcpy (mac1, pke_ptr + 23, 6);
3803 memcpy (mac2, pke_ptr + 29, 6);
3804
3805 // compare hex string(s) vs binary MAC address(es)
3806
3807 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3808 {
3809 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3810 {
3811 cracked = 0;
3812 break;
3813 }
3814 }
3815
3816 // early skip ;)
3817 if (!cracked) continue;
3818
3819 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3820 {
3821 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3822 {
3823 cracked = 0;
3824 break;
3825 }
3826 }
3827 }
3828 }
3829 else
3830 {
3831 char *digests_buf_ptr = (char *) data.digests_buf;
3832
3833 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3834
3835 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3836 }
3837
3838 if (cracked == 1)
3839 {
3840 found = 1;
3841
3842 data.digests_shown[idx] = 1;
3843
3844 data.digests_done++;
3845
3846 salt_buf->digests_done++;
3847
3848 if (salt_buf->digests_done == salt_buf->digests_cnt)
3849 {
3850 data.salts_shown[salt_pos] = 1;
3851
3852 data.salts_done++;
3853
3854 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3855 }
3856 }
3857 }
3858
3859 if (data.devices_status == STATUS_CRACKED) break;
3860 }
3861 }
3862
3863 if (found) break;
3864
3865 if (data.devices_status == STATUS_CRACKED) break;
3866
3867 iter--;
3868 }
3869
3870 if (data.devices_status == STATUS_CRACKED) break;
3871 }
3872
3873 out_info[j].seek = ftell (fp);
3874
3875 //hc_thread_mutex_unlock (mux_display);
3876
3877 fclose (fp);
3878 }
3879 }
3880 }
3881 }
3882
3883 check_left = outfile_check_timer;
3884 }
3885 }
3886
3887 if (esalt_size) local_free (hash_buf.esalt);
3888
3889 if (isSalted) local_free (hash_buf.salt);
3890
3891 local_free (hash_buf.digest);
3892
3893 local_free (out_info);
3894
3895 local_free (out_files);
3896
3897 p = NULL;
3898
3899 return (p);
3900 }
3901
3902 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3903 {
3904 hc_thread_mutex_lock (mux_dispatcher);
3905
3906 const uint64_t words_cur = data.words_cur;
3907 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3908
3909 device_param->words_off = words_cur;
3910
3911 const uint64_t words_left = words_base - words_cur;
3912
3913 if (data.kernel_blocks_all > words_left)
3914 {
3915 if (data.kernel_blocks_div == 0)
3916 {
3917 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3918 }
3919 }
3920
3921 if (data.kernel_blocks_div)
3922 {
3923 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3924 {
3925 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3926 const uint32_t kernel_power_new = kernel_blocks_new;
3927
3928 if (kernel_blocks_new < device_param->kernel_blocks)
3929 {
3930 device_param->kernel_blocks = kernel_blocks_new;
3931 device_param->kernel_power = kernel_power_new;
3932 }
3933 }
3934 }
3935
3936 const uint kernel_blocks = device_param->kernel_blocks;
3937
3938 uint work = MIN (words_left, kernel_blocks);
3939
3940 work = MIN (work, max);
3941
3942 data.words_cur += work;
3943
3944 hc_thread_mutex_unlock (mux_dispatcher);
3945
3946 return work;
3947 }
3948
3949 static void *thread_calc_stdin (void *p)
3950 {
3951 hc_device_param_t *device_param = (hc_device_param_t *) p;
3952
3953 const uint attack_kern = data.attack_kern;
3954
3955 const uint kernel_blocks = device_param->kernel_blocks;
3956
3957 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3958 {
3959 hc_thread_mutex_lock (mux_dispatcher);
3960
3961 if (feof (stdin) != 0)
3962 {
3963 hc_thread_mutex_unlock (mux_dispatcher);
3964
3965 break;
3966 }
3967
3968 uint words_cur = 0;
3969
3970 while (words_cur < kernel_blocks)
3971 {
3972 char buf[BUFSIZ];
3973
3974 char *line_buf = fgets (buf, sizeof (buf), stdin);
3975
3976 if (line_buf == NULL) break;
3977
3978 uint line_len = in_superchop (line_buf);
3979
3980 line_len = convert_from_hex (line_buf, line_len);
3981
3982 // post-process rule engine
3983
3984 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3985 {
3986 char rule_buf_out[BLOCK_SIZE];
3987
3988 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3989
3990 int rule_len_out = -1;
3991
3992 if (line_len < BLOCK_SIZE)
3993 {
3994 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3995 }
3996
3997 if (rule_len_out < 0) continue;
3998
3999 line_buf = rule_buf_out;
4000 line_len = rule_len_out;
4001 }
4002
4003 if (line_len > PW_MAX)
4004 {
4005 continue;
4006 }
4007
4008 if (attack_kern == ATTACK_KERN_STRAIGHT)
4009 {
4010 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4011 {
4012 hc_thread_mutex_lock (mux_counter);
4013
4014 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4015 {
4016 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4017 }
4018
4019 hc_thread_mutex_unlock (mux_counter);
4020
4021 continue;
4022 }
4023 }
4024 else if (attack_kern == ATTACK_KERN_COMBI)
4025 {
4026 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4027 // since we still need to combine the plains
4028
4029 if (line_len > data.pw_max)
4030 {
4031 hc_thread_mutex_lock (mux_counter);
4032
4033 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4034 {
4035 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4036 }
4037
4038 hc_thread_mutex_unlock (mux_counter);
4039
4040 continue;
4041 }
4042 }
4043
4044 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4045
4046 words_cur++;
4047
4048 if (data.devices_status == STATUS_CRACKED) break;
4049 if (data.devices_status == STATUS_ABORTED) break;
4050 if (data.devices_status == STATUS_QUIT) break;
4051 if (data.devices_status == STATUS_BYPASS) break;
4052 }
4053
4054 hc_thread_mutex_unlock (mux_dispatcher);
4055
4056 if (data.devices_status == STATUS_CRACKED) break;
4057 if (data.devices_status == STATUS_ABORTED) break;
4058 if (data.devices_status == STATUS_QUIT) break;
4059 if (data.devices_status == STATUS_BYPASS) break;
4060
4061 // we need 2 flushing because we have two independant caches and it can occur
4062 // that one buffer is already at threshold plus for that length also exists
4063 // more data in the 2nd buffer so it would overflow
4064
4065 // flush session 1
4066
4067 {
4068 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4069 {
4070 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4071
4072 const uint pw_cache_cnt = pw_cache->cnt;
4073
4074 if (pw_cache_cnt == 0) continue;
4075
4076 pw_cache->cnt = 0;
4077
4078 uint pws_cnt = device_param->pws_cnt;
4079
4080 pw_t *pw = device_param->pws_buf + pws_cnt;
4081
4082 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4083
4084 pw->pw_len = pw_len;
4085
4086 uint pw_cnt = device_param->pw_cnt;
4087
4088 pw_cnt += pw_cache_cnt;
4089
4090 device_param->pw_cnt = pw_cnt;
4091
4092 pws_cnt++;
4093
4094 device_param->pws_cnt = pws_cnt;
4095
4096 if (pws_cnt == device_param->kernel_power_user) break;
4097 }
4098
4099 const uint pw_cnt = device_param->pw_cnt;
4100 const uint pws_cnt = device_param->pws_cnt;
4101
4102 if (pws_cnt)
4103 {
4104 run_copy (device_param, pws_cnt);
4105
4106 run_cracker (device_param, pw_cnt, pws_cnt);
4107
4108 device_param->pw_cnt = 0;
4109 device_param->pws_cnt = 0;
4110 }
4111 }
4112
4113 // flush session 2
4114
4115 {
4116 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4117 {
4118 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4119
4120 const uint pw_cache_cnt = pw_cache->cnt;
4121
4122 if (pw_cache_cnt == 0) continue;
4123
4124 pw_cache->cnt = 0;
4125
4126 uint pws_cnt = device_param->pws_cnt;
4127
4128 pw_t *pw = device_param->pws_buf + pws_cnt;
4129
4130 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4131
4132 pw->pw_len = pw_len;
4133
4134 uint pw_cnt = device_param->pw_cnt;
4135
4136 pw_cnt += pw_cache_cnt;
4137
4138 device_param->pw_cnt = pw_cnt;
4139
4140 pws_cnt++;
4141
4142 device_param->pws_cnt = pws_cnt;
4143 }
4144
4145 const uint pw_cnt = device_param->pw_cnt;
4146 const uint pws_cnt = device_param->pws_cnt;
4147
4148 if (pws_cnt)
4149 {
4150 run_copy (device_param, pws_cnt);
4151
4152 run_cracker (device_param, pw_cnt, pws_cnt);
4153
4154 device_param->pw_cnt = 0;
4155 device_param->pws_cnt = 0;
4156 }
4157 }
4158 }
4159
4160 return NULL;
4161 }
4162
4163 static void *thread_calc (void *p)
4164 {
4165 hc_device_param_t *device_param = (hc_device_param_t *) p;
4166
4167 const uint attack_mode = data.attack_mode;
4168 const uint attack_kern = data.attack_kern;
4169
4170 if (attack_mode == ATTACK_MODE_BF)
4171 {
4172 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4173 {
4174 const uint work = get_work (device_param, -1);
4175
4176 if (work == 0) break;
4177
4178 const uint64_t words_off = device_param->words_off;
4179 const uint64_t words_fin = words_off + work;
4180
4181 const uint pw_cnt = work;
4182 const uint pws_cnt = work;
4183
4184 device_param->pw_cnt = pw_cnt;
4185 device_param->pws_cnt = pws_cnt;
4186
4187 if (pws_cnt)
4188 {
4189 run_copy (device_param, pws_cnt);
4190
4191 run_cracker (device_param, pw_cnt, pws_cnt);
4192
4193 device_param->pw_cnt = 0;
4194 device_param->pws_cnt = 0;
4195 }
4196
4197 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4198
4199 if (data.devices_status == STATUS_CRACKED) break;
4200 if (data.devices_status == STATUS_ABORTED) break;
4201 if (data.devices_status == STATUS_QUIT) break;
4202 if (data.devices_status == STATUS_BYPASS) break;
4203
4204 device_param->words_done = words_fin;
4205 }
4206 }
4207 else
4208 {
4209 const uint segment_size = data.segment_size;
4210
4211 char *dictfile = data.dictfile;
4212
4213 if (attack_mode == ATTACK_MODE_COMBI)
4214 {
4215 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4216 {
4217 dictfile = data.dictfile2;
4218 }
4219 }
4220
4221 FILE *fd = fopen (dictfile, "rb");
4222
4223 if (fd == NULL)
4224 {
4225 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4226
4227 return NULL;
4228 }
4229
4230 if (attack_mode == ATTACK_MODE_COMBI)
4231 {
4232 const uint combs_mode = data.combs_mode;
4233
4234 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4235 {
4236 const char *dictfilec = data.dictfile2;
4237
4238 FILE *combs_fp = fopen (dictfilec, "rb");
4239
4240 if (combs_fp == NULL)
4241 {
4242 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4243
4244 fclose (fd);
4245
4246 return NULL;
4247 }
4248
4249 device_param->combs_fp = combs_fp;
4250 }
4251 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4252 {
4253 const char *dictfilec = data.dictfile;
4254
4255 FILE *combs_fp = fopen (dictfilec, "rb");
4256
4257 if (combs_fp == NULL)
4258 {
4259 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4260
4261 fclose (fd);
4262
4263 return NULL;
4264 }
4265
4266 device_param->combs_fp = combs_fp;
4267 }
4268 }
4269
4270 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4271
4272 wl_data->buf = (char *) mymalloc (segment_size);
4273 wl_data->avail = segment_size;
4274 wl_data->incr = segment_size;
4275 wl_data->cnt = 0;
4276 wl_data->pos = 0;
4277
4278 uint64_t words_cur = 0;
4279
4280 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4281 {
4282 uint64_t words_off = 0;
4283 uint64_t words_fin = 0;
4284
4285 uint64_t max = -1;
4286
4287 while (max)
4288 {
4289 const uint work = get_work (device_param, max);
4290
4291 if (work == 0) break;
4292
4293 words_off = device_param->words_off;
4294 words_fin = words_off + work;
4295
4296 char *line_buf;
4297 uint line_len;
4298
4299 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4300
4301 max = 0;
4302
4303 for ( ; words_cur < words_fin; words_cur++)
4304 {
4305 get_next_word (wl_data, fd, &line_buf, &line_len);
4306
4307 line_len = convert_from_hex (line_buf, line_len);
4308
4309 // post-process rule engine
4310
4311 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4312 {
4313 char rule_buf_out[BLOCK_SIZE];
4314
4315 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4316
4317 int rule_len_out = -1;
4318
4319 if (line_len < BLOCK_SIZE)
4320 {
4321 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4322 }
4323
4324 if (rule_len_out < 0) continue;
4325
4326 line_buf = rule_buf_out;
4327 line_len = rule_len_out;
4328 }
4329
4330 if (attack_kern == ATTACK_KERN_STRAIGHT)
4331 {
4332 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4333 {
4334 max++;
4335
4336 hc_thread_mutex_lock (mux_counter);
4337
4338 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4339 {
4340 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4341 }
4342
4343 hc_thread_mutex_unlock (mux_counter);
4344
4345 continue;
4346 }
4347 }
4348 else if (attack_kern == ATTACK_KERN_COMBI)
4349 {
4350 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4351 // since we still need to combine the plains
4352
4353 if (line_len > data.pw_max)
4354 {
4355 max++;
4356
4357 hc_thread_mutex_lock (mux_counter);
4358
4359 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4360 {
4361 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4362 }
4363
4364 hc_thread_mutex_unlock (mux_counter);
4365
4366 continue;
4367 }
4368 }
4369
4370 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4371
4372 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375 if (data.devices_status == STATUS_ABORTED) break;
4376 if (data.devices_status == STATUS_QUIT) break;
4377 if (data.devices_status == STATUS_BYPASS) break;
4378 }
4379
4380 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4381
4382 if (data.devices_status == STATUS_CRACKED) break;
4383 if (data.devices_status == STATUS_ABORTED) break;
4384 if (data.devices_status == STATUS_QUIT) break;
4385 if (data.devices_status == STATUS_BYPASS) break;
4386 }
4387
4388 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4389
4390 if (data.devices_status == STATUS_CRACKED) break;
4391 if (data.devices_status == STATUS_ABORTED) break;
4392 if (data.devices_status == STATUS_QUIT) break;
4393 if (data.devices_status == STATUS_BYPASS) break;
4394
4395 // we need 2 flushing because we have two independant caches and it can occur
4396 // that one buffer is already at threshold plus for that length also exists
4397 // more data in the 2nd buffer so it would overflow
4398
4399 //
4400 // flush session 1
4401 //
4402
4403 {
4404 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4405 {
4406 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4407
4408 const uint pw_cache_cnt = pw_cache->cnt;
4409
4410 if (pw_cache_cnt == 0) continue;
4411
4412 pw_cache->cnt = 0;
4413
4414 uint pws_cnt = device_param->pws_cnt;
4415
4416 pw_t *pw = device_param->pws_buf + pws_cnt;
4417
4418 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4419
4420 pw->pw_len = pw_len;
4421
4422 uint pw_cnt = device_param->pw_cnt;
4423
4424 pw_cnt += pw_cache_cnt;
4425
4426 device_param->pw_cnt = pw_cnt;
4427
4428 pws_cnt++;
4429
4430 device_param->pws_cnt = pws_cnt;
4431
4432 if (pws_cnt == device_param->kernel_power_user) break;
4433 }
4434
4435 const uint pw_cnt = device_param->pw_cnt;
4436 const uint pws_cnt = device_param->pws_cnt;
4437
4438 if (pws_cnt)
4439 {
4440 run_copy (device_param, pws_cnt);
4441
4442 run_cracker (device_param, pw_cnt, pws_cnt);
4443
4444 device_param->pw_cnt = 0;
4445 device_param->pws_cnt = 0;
4446 }
4447
4448 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4449
4450 if (data.devices_status == STATUS_CRACKED) break;
4451 if (data.devices_status == STATUS_ABORTED) break;
4452 if (data.devices_status == STATUS_QUIT) break;
4453 if (data.devices_status == STATUS_BYPASS) break;
4454 }
4455
4456 //
4457 // flush session 2
4458 //
4459
4460 {
4461 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4462 {
4463 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4464
4465 const uint pw_cache_cnt = pw_cache->cnt;
4466
4467 if (pw_cache_cnt == 0) continue;
4468
4469 pw_cache->cnt = 0;
4470
4471 uint pws_cnt = device_param->pws_cnt;
4472
4473 pw_t *pw = device_param->pws_buf + pws_cnt;
4474
4475 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4476
4477 pw->pw_len = pw_len;
4478
4479 uint pw_cnt = device_param->pw_cnt;
4480
4481 pw_cnt += pw_cache_cnt;
4482
4483 device_param->pw_cnt = pw_cnt;
4484
4485 pws_cnt++;
4486
4487 device_param->pws_cnt = pws_cnt;
4488 }
4489
4490 const uint pw_cnt = device_param->pw_cnt;
4491 const uint pws_cnt = device_param->pws_cnt;
4492
4493 if (pws_cnt)
4494 {
4495 run_copy (device_param, pws_cnt);
4496
4497 run_cracker (device_param, pw_cnt, pws_cnt);
4498
4499 device_param->pw_cnt = 0;
4500 device_param->pws_cnt = 0;
4501 }
4502
4503 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4504
4505 if (data.devices_status == STATUS_CRACKED) break;
4506 if (data.devices_status == STATUS_ABORTED) break;
4507 if (data.devices_status == STATUS_QUIT) break;
4508 if (data.devices_status == STATUS_BYPASS) break;
4509 }
4510
4511 if (words_fin == 0) break;
4512
4513 device_param->words_done = words_fin;
4514 }
4515
4516 if (attack_mode == ATTACK_MODE_COMBI)
4517 {
4518 fclose (device_param->combs_fp);
4519 }
4520
4521 free (wl_data->buf);
4522 free (wl_data);
4523
4524 fclose (fd);
4525 }
4526
4527 return NULL;
4528 }
4529
4530 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4531 {
4532 salt_t *salt_buf = &data.salts_buf[salt_pos];
4533
4534 device_param->kernel_params_buf32[24] = salt_pos;
4535 device_param->kernel_params_buf32[27] = 1;
4536 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4537 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4538 device_param->kernel_params_buf32[30] = 0;
4539 device_param->kernel_params_buf32[31] = 1;
4540
4541 char *dictfile_old = data.dictfile;
4542 char *dictfile2_old = data.dictfile2;
4543 char *mask_old = data.mask;
4544 int attack_mode_old = data.attack_mode;
4545
4546 const char *weak_hash_check = "weak-hash-check";
4547
4548 data.dictfile = (char *) weak_hash_check;
4549 data.dictfile2 = (char *) weak_hash_check;
4550 data.mask = (char *) weak_hash_check;
4551 data.attack_mode = ATTACK_MODE_STRAIGHT;
4552
4553 /**
4554 * run the kernel
4555 */
4556
4557 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4558 {
4559 run_kernel (KERN_RUN_WEAK, device_param, 1);
4560 }
4561 else
4562 {
4563 run_kernel (KERN_RUN_1, device_param, 1);
4564
4565 const uint iter = salt_buf->salt_iter;
4566
4567 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4568 {
4569 uint loop_left = iter - loop_pos;
4570
4571 loop_left = MIN (loop_left, kernel_loops);
4572
4573 device_param->kernel_params_buf32[25] = loop_pos;
4574 device_param->kernel_params_buf32[26] = loop_left;
4575
4576 run_kernel (KERN_RUN_2, device_param, 1);
4577 }
4578
4579 run_kernel (KERN_RUN_3, device_param, 1);
4580 }
4581
4582 /**
4583 * result
4584 */
4585
4586 check_cracked (device_param, salt_pos);
4587
4588 /**
4589 * cleanup
4590 */
4591
4592 device_param->kernel_params_buf32[24] = 0;
4593 device_param->kernel_params_buf32[25] = 0;
4594 device_param->kernel_params_buf32[26] = 0;
4595 device_param->kernel_params_buf32[27] = 0;
4596 device_param->kernel_params_buf32[28] = 0;
4597 device_param->kernel_params_buf32[29] = 0;
4598 device_param->kernel_params_buf32[30] = 0;
4599 device_param->kernel_params_buf32[31] = 0;
4600
4601 data.dictfile = dictfile_old;
4602 data.dictfile2 = dictfile2_old;
4603 data.mask = mask_old;
4604 data.attack_mode = attack_mode_old;
4605 }
4606
4607 // hlfmt hashcat
4608
4609 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4610 {
4611 if (data.username == 0)
4612 {
4613 *hashbuf_pos = line_buf;
4614 *hashbuf_len = line_len;
4615 }
4616 else
4617 {
4618 char *pos = line_buf;
4619 int len = line_len;
4620
4621 for (int i = 0; i < line_len; i++, pos++, len--)
4622 {
4623 if (line_buf[i] == data.separator)
4624 {
4625 pos++;
4626
4627 len--;
4628
4629 break;
4630 }
4631 }
4632
4633 *hashbuf_pos = pos;
4634 *hashbuf_len = len;
4635 }
4636 }
4637
4638 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4639 {
4640 char *pos = NULL;
4641 int len = 0;
4642
4643 int sep_cnt = 0;
4644
4645 for (int i = 0; i < line_len; i++)
4646 {
4647 if (line_buf[i] == data.separator)
4648 {
4649 sep_cnt++;
4650
4651 continue;
4652 }
4653
4654 if (sep_cnt == 0)
4655 {
4656 if (pos == NULL) pos = line_buf + i;
4657
4658 len++;
4659 }
4660 }
4661
4662 *userbuf_pos = pos;
4663 *userbuf_len = len;
4664 }
4665
4666 // hlfmt pwdump
4667
4668 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4669 {
4670 int sep_cnt = 0;
4671
4672 int sep2_len = 0;
4673 int sep3_len = 0;
4674
4675 for (int i = 0; i < line_len; i++)
4676 {
4677 if (line_buf[i] == ':')
4678 {
4679 sep_cnt++;
4680
4681 continue;
4682 }
4683
4684 if (sep_cnt == 2) sep2_len++;
4685 if (sep_cnt == 3) sep3_len++;
4686 }
4687
4688 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4689
4690 return 0;
4691 }
4692
4693 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4694 {
4695 char *pos = NULL;
4696 int len = 0;
4697
4698 int sep_cnt = 0;
4699
4700 for (int i = 0; i < line_len; i++)
4701 {
4702 if (line_buf[i] == ':')
4703 {
4704 sep_cnt++;
4705
4706 continue;
4707 }
4708
4709 if (data.hash_mode == 1000)
4710 {
4711 if (sep_cnt == 3)
4712 {
4713 if (pos == NULL) pos = line_buf + i;
4714
4715 len++;
4716 }
4717 }
4718 else if (data.hash_mode == 3000)
4719 {
4720 if (sep_cnt == 2)
4721 {
4722 if (pos == NULL) pos = line_buf + i;
4723
4724 len++;
4725 }
4726 }
4727 }
4728
4729 *hashbuf_pos = pos;
4730 *hashbuf_len = len;
4731 }
4732
4733 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4734 {
4735 char *pos = NULL;
4736 int len = 0;
4737
4738 int sep_cnt = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (sep_cnt == 0)
4750 {
4751 if (pos == NULL) pos = line_buf + i;
4752
4753 len++;
4754 }
4755 }
4756
4757 *userbuf_pos = pos;
4758 *userbuf_len = len;
4759 }
4760
4761 // hlfmt passwd
4762
4763 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4764 {
4765 int sep_cnt = 0;
4766
4767 char sep5_first = 0;
4768 char sep6_first = 0;
4769
4770 for (int i = 0; i < line_len; i++)
4771 {
4772 if (line_buf[i] == ':')
4773 {
4774 sep_cnt++;
4775
4776 continue;
4777 }
4778
4779 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4780 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4781 }
4782
4783 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4784
4785 return 0;
4786 }
4787
4788 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4789 {
4790 char *pos = NULL;
4791 int len = 0;
4792
4793 int sep_cnt = 0;
4794
4795 for (int i = 0; i < line_len; i++)
4796 {
4797 if (line_buf[i] == ':')
4798 {
4799 sep_cnt++;
4800
4801 continue;
4802 }
4803
4804 if (sep_cnt == 1)
4805 {
4806 if (pos == NULL) pos = line_buf + i;
4807
4808 len++;
4809 }
4810 }
4811
4812 *hashbuf_pos = pos;
4813 *hashbuf_len = len;
4814 }
4815
4816 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4817 {
4818 char *pos = NULL;
4819 int len = 0;
4820
4821 int sep_cnt = 0;
4822
4823 for (int i = 0; i < line_len; i++)
4824 {
4825 if (line_buf[i] == ':')
4826 {
4827 sep_cnt++;
4828
4829 continue;
4830 }
4831
4832 if (sep_cnt == 0)
4833 {
4834 if (pos == NULL) pos = line_buf + i;
4835
4836 len++;
4837 }
4838 }
4839
4840 *userbuf_pos = pos;
4841 *userbuf_len = len;
4842 }
4843
4844 // hlfmt shadow
4845
4846 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4847 {
4848 int sep_cnt = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':') sep_cnt++;
4853 }
4854
4855 if (sep_cnt == 8) return 1;
4856
4857 return 0;
4858 }
4859
4860 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4863 }
4864
4865 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4866 {
4867 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4868 }
4869
4870 // hlfmt main
4871
4872 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4873 {
4874 switch (hashfile_format)
4875 {
4876 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4877 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4878 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4879 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4880 }
4881 }
4882
4883 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4884 {
4885 switch (hashfile_format)
4886 {
4887 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4888 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4889 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4890 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4891 }
4892 }
4893
4894 static uint hlfmt_detect (FILE *fp, uint max_check)
4895 {
4896 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4897
4898 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4899 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4900
4901 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4902
4903 uint num_check = 0;
4904
4905 while (!feof (fp))
4906 {
4907 char line_buf[BUFSIZ];
4908
4909 int line_len = fgetl (fp, line_buf);
4910
4911 if (line_len == 0) continue;
4912
4913 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4914 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4915 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4916
4917 if (num_check == max_check) break;
4918
4919 num_check++;
4920 }
4921
4922 uint hashlist_format = HLFMT_HASHCAT;
4923
4924 for (int i = 1; i < HLFMTS_CNT; i++)
4925 {
4926 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4927
4928 hashlist_format = i;
4929 }
4930
4931 free (formats_cnt);
4932
4933 return hashlist_format;
4934 }
4935
4936 /**
4937 * some further helper function
4938 */
4939
4940 // wrapper around mymalloc for ADL
4941
4942 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4943 {
4944 return mymalloc (iSize);
4945 }
4946
4947 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 uint64_t collisions_max)
4948 {
4949 uint64_t collisions = 0;
4950
4951 const uint dgst_pos0 = data.dgst_pos0;
4952 const uint dgst_pos1 = data.dgst_pos1;
4953 const uint dgst_pos2 = data.dgst_pos2;
4954 const uint dgst_pos3 = data.dgst_pos3;
4955
4956 memset (bitmap_a, 0, bitmap_size);
4957 memset (bitmap_b, 0, bitmap_size);
4958 memset (bitmap_c, 0, bitmap_size);
4959 memset (bitmap_d, 0, bitmap_size);
4960
4961 for (uint i = 0; i < digests_cnt; i++)
4962 {
4963 uint *digest_ptr = (uint *) digests_buf_ptr;
4964
4965 digests_buf_ptr += dgst_size;
4966
4967 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4968 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4969 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4970 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4971
4972 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4973 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4974 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4975 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4976
4977 if (bitmap_a[idx0] & val0) collisions++;
4978 if (bitmap_b[idx1] & val1) collisions++;
4979 if (bitmap_c[idx2] & val2) collisions++;
4980 if (bitmap_d[idx3] & val3) collisions++;
4981
4982 bitmap_a[idx0] |= val0;
4983 bitmap_b[idx1] |= val1;
4984 bitmap_c[idx2] |= val2;
4985 bitmap_d[idx3] |= val3;
4986
4987 if (collisions >= collisions_max) return 0x7fffffff;
4988 }
4989
4990 return collisions;
4991 }
4992
4993 /**
4994 * main
4995 */
4996
4997 int main (int argc, char **argv)
4998 {
4999 /**
5000 * To help users a bit
5001 */
5002
5003 char *compute = getenv ("COMPUTE");
5004
5005 if (compute)
5006 {
5007 char display[100];
5008
5009 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5010
5011 putenv (display);
5012 }
5013 else
5014 {
5015 if (getenv ("DISPLAY") == NULL)
5016 putenv ((char *) "DISPLAY=:0");
5017 }
5018
5019 /*
5020 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5021 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5022
5023 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5024 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5025 */
5026
5027 /**
5028 * Real init
5029 */
5030
5031 memset (&data, 0, sizeof (hc_global_data_t));
5032
5033 time_t proc_start;
5034
5035 time (&proc_start);
5036
5037 data.proc_start = proc_start;
5038
5039 int myargc = argc;
5040 char **myargv = argv;
5041
5042 hc_thread_mutex_init (mux_dispatcher);
5043 hc_thread_mutex_init (mux_counter);
5044 hc_thread_mutex_init (mux_display);
5045 hc_thread_mutex_init (mux_adl);
5046
5047 /**
5048 * commandline parameters
5049 */
5050
5051 uint usage = USAGE;
5052 uint version = VERSION;
5053 uint quiet = QUIET;
5054 uint benchmark = BENCHMARK;
5055 uint benchmark_mode = BENCHMARK_MODE;
5056 uint show = SHOW;
5057 uint left = LEFT;
5058 uint username = USERNAME;
5059 uint remove = REMOVE;
5060 uint remove_timer = REMOVE_TIMER;
5061 uint64_t skip = SKIP;
5062 uint64_t limit = LIMIT;
5063 uint keyspace = KEYSPACE;
5064 uint potfile_disable = POTFILE_DISABLE;
5065 uint debug_mode = DEBUG_MODE;
5066 char *debug_file = NULL;
5067 char *induction_dir = NULL;
5068 char *outfile_check_dir = NULL;
5069 uint force = FORCE;
5070 uint runtime = RUNTIME;
5071 uint hash_mode = HASH_MODE;
5072 uint attack_mode = ATTACK_MODE;
5073 uint markov_disable = MARKOV_DISABLE;
5074 uint markov_classic = MARKOV_CLASSIC;
5075 uint markov_threshold = MARKOV_THRESHOLD;
5076 char *markov_hcstat = NULL;
5077 char *outfile = NULL;
5078 uint outfile_format = OUTFILE_FORMAT;
5079 uint outfile_autohex = OUTFILE_AUTOHEX;
5080 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5081 uint restore = RESTORE;
5082 uint restore_timer = RESTORE_TIMER;
5083 uint restore_disable = RESTORE_DISABLE;
5084 uint status = STATUS;
5085 uint status_timer = STATUS_TIMER;
5086 uint status_automat = STATUS_AUTOMAT;
5087 uint loopback = LOOPBACK;
5088 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5089 char *session = NULL;
5090 uint hex_charset = HEX_CHARSET;
5091 uint hex_salt = HEX_SALT;
5092 uint hex_wordlist = HEX_WORDLIST;
5093 uint rp_gen = RP_GEN;
5094 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5095 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5096 uint rp_gen_seed = RP_GEN_SEED;
5097 char *rule_buf_l = (char *) RULE_BUF_L;
5098 char *rule_buf_r = (char *) RULE_BUF_R;
5099 uint increment = INCREMENT;
5100 uint increment_min = INCREMENT_MIN;
5101 uint increment_max = INCREMENT_MAX;
5102 char *cpu_affinity = NULL;
5103 char *opencl_devices = NULL;
5104 char *opencl_platform = NULL;
5105 char *truecrypt_keyfiles = NULL;
5106 uint workload_profile = WORKLOAD_PROFILE;
5107 uint kernel_accel = KERNEL_ACCEL;
5108 uint kernel_loops = KERNEL_LOOPS;
5109 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5110 uint gpu_temp_abort = GPU_TEMP_ABORT;
5111 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5112 uint powertune_enable = POWERTUNE_ENABLE;
5113 uint logfile_disable = LOGFILE_DISABLE;
5114 uint segment_size = SEGMENT_SIZE;
5115 uint scrypt_tmto = SCRYPT_TMTO;
5116 char separator = SEPARATOR;
5117 uint bitmap_min = BITMAP_MIN;
5118 uint bitmap_max = BITMAP_MAX;
5119 char *custom_charset_1 = NULL;
5120 char *custom_charset_2 = NULL;
5121 char *custom_charset_3 = NULL;
5122 char *custom_charset_4 = NULL;
5123
5124 #define IDX_HELP 'h'
5125 #define IDX_VERSION 'V'
5126 #define IDX_VERSION_LOWER 'v'
5127 #define IDX_QUIET 0xff02
5128 #define IDX_SHOW 0xff03
5129 #define IDX_LEFT 0xff04
5130 #define IDX_REMOVE 0xff05
5131 #define IDX_REMOVE_TIMER 0xff37
5132 #define IDX_SKIP 's'
5133 #define IDX_LIMIT 'l'
5134 #define IDX_KEYSPACE 0xff35
5135 #define IDX_POTFILE_DISABLE 0xff06
5136 #define IDX_DEBUG_MODE 0xff43
5137 #define IDX_DEBUG_FILE 0xff44
5138 #define IDX_INDUCTION_DIR 0xff46
5139 #define IDX_OUTFILE_CHECK_DIR 0xff47
5140 #define IDX_USERNAME 0xff07
5141 #define IDX_FORCE 0xff08
5142 #define IDX_RUNTIME 0xff09
5143 #define IDX_BENCHMARK 'b'
5144 #define IDX_BENCHMARK_MODE 0xff32
5145 #define IDX_HASH_MODE 'm'
5146 #define IDX_ATTACK_MODE 'a'
5147 #define IDX_RP_FILE 'r'
5148 #define IDX_RP_GEN 'g'
5149 #define IDX_RP_GEN_FUNC_MIN 0xff10
5150 #define IDX_RP_GEN_FUNC_MAX 0xff11
5151 #define IDX_RP_GEN_SEED 0xff34
5152 #define IDX_RULE_BUF_L 'j'
5153 #define IDX_RULE_BUF_R 'k'
5154 #define IDX_INCREMENT 'i'
5155 #define IDX_INCREMENT_MIN 0xff12
5156 #define IDX_INCREMENT_MAX 0xff13
5157 #define IDX_OUTFILE 'o'
5158 #define IDX_OUTFILE_FORMAT 0xff14
5159 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5160 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5161 #define IDX_RESTORE 0xff15
5162 #define IDX_RESTORE_DISABLE 0xff27
5163 #define IDX_STATUS 0xff17
5164 #define IDX_STATUS_TIMER 0xff18
5165 #define IDX_STATUS_AUTOMAT 0xff50
5166 #define IDX_LOOPBACK 0xff38
5167 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5168 #define IDX_SESSION 0xff19
5169 #define IDX_HEX_CHARSET 0xff20
5170 #define IDX_HEX_SALT 0xff21
5171 #define IDX_HEX_WORDLIST 0xff40
5172 #define IDX_MARKOV_DISABLE 0xff22
5173 #define IDX_MARKOV_CLASSIC 0xff23
5174 #define IDX_MARKOV_THRESHOLD 't'
5175 #define IDX_MARKOV_HCSTAT 0xff24
5176 #define IDX_CPU_AFFINITY 0xff25
5177 #define IDX_OPENCL_DEVICES 'd'
5178 #define IDX_OPENCL_PLATFORM 0xff72
5179 #define IDX_WORKLOAD_PROFILE 'w'
5180 #define IDX_KERNEL_ACCEL 'n'
5181 #define IDX_KERNEL_LOOPS 'u'
5182 #define IDX_GPU_TEMP_DISABLE 0xff29
5183 #define IDX_GPU_TEMP_ABORT 0xff30
5184 #define IDX_GPU_TEMP_RETAIN 0xff31
5185 #define IDX_POWERTUNE_ENABLE 0xff41
5186 #define IDX_LOGFILE_DISABLE 0xff51
5187 #define IDX_TRUECRYPT_KEYFILES 0xff52
5188 #define IDX_SCRYPT_TMTO 0xff61
5189 #define IDX_SEGMENT_SIZE 'c'
5190 #define IDX_SEPARATOR 'p'
5191 #define IDX_BITMAP_MIN 0xff70
5192 #define IDX_BITMAP_MAX 0xff71
5193 #define IDX_CUSTOM_CHARSET_1 '1'
5194 #define IDX_CUSTOM_CHARSET_2 '2'
5195 #define IDX_CUSTOM_CHARSET_3 '3'
5196 #define IDX_CUSTOM_CHARSET_4 '4'
5197
5198 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5199
5200 struct option long_options[] =
5201 {
5202 {"help", no_argument, 0, IDX_HELP},
5203 {"version", no_argument, 0, IDX_VERSION},
5204 {"quiet", no_argument, 0, IDX_QUIET},
5205 {"show", no_argument, 0, IDX_SHOW},
5206 {"left", no_argument, 0, IDX_LEFT},
5207 {"username", no_argument, 0, IDX_USERNAME},
5208 {"remove", no_argument, 0, IDX_REMOVE},
5209 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5210 {"skip", required_argument, 0, IDX_SKIP},
5211 {"limit", required_argument, 0, IDX_LIMIT},
5212 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5213 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5214 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5215 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5216 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5217 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5218 {"force", no_argument, 0, IDX_FORCE},
5219 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5220 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5221 {"restore", no_argument, 0, IDX_RESTORE},
5222 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5223 {"status", no_argument, 0, IDX_STATUS},
5224 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5225 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5226 {"loopback", no_argument, 0, IDX_LOOPBACK},
5227 {"weak-hash-threshold",
5228 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5229 {"session", required_argument, 0, IDX_SESSION},
5230 {"runtime", required_argument, 0, IDX_RUNTIME},
5231 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5232 {"generate-rules-func-min",
5233 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5234 {"generate-rules-func-max",
5235 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5236 {"generate-rules-seed",
5237 required_argument, 0, IDX_RP_GEN_SEED},
5238 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5239 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5240 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5241 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5242 {"rules-file", required_argument, 0, IDX_RP_FILE},
5243 {"outfile", required_argument, 0, IDX_OUTFILE},
5244 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5245 {"outfile-autohex-disable",
5246 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5247 {"outfile-check-timer",
5248 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5249 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5250 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5251 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5252 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5253 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5254 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5255 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5256 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5257 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5258 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5259 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5260 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5261 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5262 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5263 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5264 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5265 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5266 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5267 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5268 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5269 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5270 // deprecated
5271 {"seperator", required_argument, 0, IDX_SEPARATOR},
5272 {"separator", required_argument, 0, IDX_SEPARATOR},
5273 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5274 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5275 {"increment", no_argument, 0, IDX_INCREMENT},
5276 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5277 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5278 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5279 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5280 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5281 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5282
5283 {0, 0, 0, 0}
5284 };
5285
5286 uint rp_files_cnt = 0;
5287
5288 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5289
5290 int option_index;
5291 int c;
5292
5293 optind = 1;
5294 optopt = 0;
5295 option_index = 0;
5296
5297 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5298 {
5299 switch (c)
5300 {
5301 case IDX_HELP: usage = 1; break;
5302 case IDX_VERSION:
5303 case IDX_VERSION_LOWER: version = 1; break;
5304 case IDX_RESTORE: restore = 1; break;
5305 case IDX_SESSION: session = optarg; break;
5306 case IDX_SHOW: show = 1; break;
5307 case IDX_LEFT: left = 1; break;
5308 case '?': return (-1);
5309 }
5310 }
5311
5312 if (optopt != 0)
5313 {
5314 log_error ("ERROR: Invalid argument specified");
5315
5316 return (-1);
5317 }
5318
5319 /**
5320 * exit functions
5321 */
5322
5323 if (version)
5324 {
5325 log_info (VERSION_TXT);
5326
5327 return (0);
5328 }
5329
5330 if (usage)
5331 {
5332 usage_big_print (PROGNAME);
5333
5334 return (0);
5335 }
5336
5337 /**
5338 * session needs to be set, always!
5339 */
5340
5341 if (session == NULL) session = (char *) PROGNAME;
5342
5343 /**
5344 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5345 */
5346
5347 char *exec_path = get_exec_path ();
5348
5349 #ifdef LINUX
5350
5351 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5352 char *resolved_exec_path = realpath (exec_path, NULL);
5353
5354 char *install_dir = get_install_dir (resolved_exec_path);
5355 char *profile_dir = NULL;
5356 char *session_dir = NULL;
5357 char *shared_dir = NULL;
5358
5359 if (strcmp (install_dir, resolved_install_folder) == 0)
5360 {
5361 struct passwd *pw = getpwuid (getuid ());
5362
5363 const char *homedir = pw->pw_dir;
5364
5365 profile_dir = get_profile_dir (homedir);
5366 session_dir = get_session_dir (profile_dir);
5367 shared_dir = strdup (SHARED_FOLDER);
5368
5369 mkdir (profile_dir, 0700);
5370 mkdir (session_dir, 0700);
5371 }
5372 else
5373 {
5374 profile_dir = install_dir;
5375 session_dir = install_dir;
5376 shared_dir = install_dir;
5377 }
5378
5379 myfree (resolved_install_folder);
5380 myfree (resolved_exec_path);
5381
5382 #else
5383
5384 char *install_dir = get_install_dir (exec_path);
5385 char *profile_dir = install_dir;
5386 char *session_dir = install_dir;
5387 char *shared_dir = install_dir;
5388
5389 #endif
5390
5391 data.install_dir = install_dir;
5392 data.profile_dir = profile_dir;
5393 data.session_dir = session_dir;
5394 data.shared_dir = shared_dir;
5395
5396 myfree (exec_path);
5397
5398 /**
5399 * session
5400 */
5401
5402 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5403
5404 data.session = session;
5405
5406 char *eff_restore_file = (char *) mymalloc (session_size);
5407 char *new_restore_file = (char *) mymalloc (session_size);
5408
5409 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5410 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5411
5412 data.eff_restore_file = eff_restore_file;
5413 data.new_restore_file = new_restore_file;
5414
5415 if (((show == 1) || (left == 1)) && (restore == 1))
5416 {
5417 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5418 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5419
5420 return (-1);
5421 }
5422
5423 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5424 if ((show == 1) || (left == 1))
5425 {
5426 restore_disable = 1;
5427
5428 restore = 0;
5429 }
5430
5431 data.restore_disable = restore_disable;
5432
5433 restore_data_t *rd = init_restore (argc, argv);
5434
5435 data.rd = rd;
5436
5437 /**
5438 * restore file
5439 */
5440
5441 if (restore == 1)
5442 {
5443 read_restore (eff_restore_file, rd);
5444
5445 if (rd->version_bin < RESTORE_MIN)
5446 {
5447 log_error ("ERROR: Incompatible restore-file version");
5448
5449 return (-1);
5450 }
5451
5452 myargc = rd->argc;
5453 myargv = rd->argv;
5454
5455 #ifdef _POSIX
5456 rd->pid = getpid ();
5457 #elif _WIN
5458 rd->pid = GetCurrentProcessId ();
5459 #endif
5460 }
5461
5462 uint hash_mode_chgd = 0;
5463 uint runtime_chgd = 0;
5464 uint kernel_loops_chgd = 0;
5465 uint kernel_accel_chgd = 0;
5466 uint attack_mode_chgd = 0;
5467 uint outfile_format_chgd = 0;
5468 uint rp_gen_seed_chgd = 0;
5469 uint remove_timer_chgd = 0;
5470 uint increment_min_chgd = 0;
5471 uint increment_max_chgd = 0;
5472 uint gpu_temp_abort_chgd = 0;
5473 uint gpu_temp_retain_chgd = 0;
5474
5475 optind = 1;
5476 optopt = 0;
5477 option_index = 0;
5478
5479 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5480 {
5481 switch (c)
5482 {
5483 //case IDX_HELP: usage = 1; break;
5484 //case IDX_VERSION: version = 1; break;
5485 //case IDX_RESTORE: restore = 1; break;
5486 case IDX_QUIET: quiet = 1; break;
5487 //case IDX_SHOW: show = 1; break;
5488 case IDX_SHOW: break;
5489 //case IDX_LEFT: left = 1; break;
5490 case IDX_LEFT: break;
5491 case IDX_USERNAME: username = 1; break;
5492 case IDX_REMOVE: remove = 1; break;
5493 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5494 remove_timer_chgd = 1; break;
5495 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5496 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5497 case IDX_DEBUG_FILE: debug_file = optarg; break;
5498 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5499 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5500 case IDX_FORCE: force = 1; break;
5501 case IDX_SKIP: skip = atoll (optarg); break;
5502 case IDX_LIMIT: limit = atoll (optarg); break;
5503 case IDX_KEYSPACE: keyspace = 1; break;
5504 case IDX_BENCHMARK: benchmark = 1; break;
5505 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5506 case IDX_RESTORE: break;
5507 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5508 case IDX_STATUS: status = 1; break;
5509 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5510 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5511 case IDX_LOOPBACK: loopback = 1; break;
5512 case IDX_WEAK_HASH_THRESHOLD:
5513 weak_hash_threshold = atoi (optarg); break;
5514 //case IDX_SESSION: session = optarg; break;
5515 case IDX_SESSION: break;
5516 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5517 hash_mode_chgd = 1; break;
5518 case IDX_RUNTIME: runtime = atoi (optarg);
5519 runtime_chgd = 1; break;
5520 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5521 attack_mode_chgd = 1; break;
5522 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5523 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5524 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5525 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5526 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5527 rp_gen_seed_chgd = 1; break;
5528 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5529 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5530 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5531 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5532 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5533 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5534 case IDX_OUTFILE: outfile = optarg; break;
5535 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5536 outfile_format_chgd = 1; break;
5537 case IDX_OUTFILE_AUTOHEX_DISABLE:
5538 outfile_autohex = 0; break;
5539 case IDX_OUTFILE_CHECK_TIMER:
5540 outfile_check_timer = atoi (optarg); break;
5541 case IDX_HEX_CHARSET: hex_charset = 1; break;
5542 case IDX_HEX_SALT: hex_salt = 1; break;
5543 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5544 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5545 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5546 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5547 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5548 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5549 kernel_accel_chgd = 1; break;
5550 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5551 kernel_loops_chgd = 1; break;
5552 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5553 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5554 gpu_temp_abort = atoi (optarg); break;
5555 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5556 gpu_temp_retain = atoi (optarg); break;
5557 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5558 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5559 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5560 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5561 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5562 case IDX_SEPARATOR: separator = optarg[0]; break;
5563 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5564 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5565 case IDX_INCREMENT: increment = 1; break;
5566 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5567 increment_min_chgd = 1; break;
5568 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5569 increment_max_chgd = 1; break;
5570 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5571 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5572 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5573 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5574
5575 default:
5576 log_error ("ERROR: Invalid argument specified");
5577 return (-1);
5578 }
5579 }
5580
5581 if (optopt != 0)
5582 {
5583 log_error ("ERROR: Invalid argument specified");
5584
5585 return (-1);
5586 }
5587
5588 /**
5589 * Inform user things getting started,
5590 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5591 * - we do not need to check algorithm_pos
5592 */
5593
5594 if (quiet == 0)
5595 {
5596 if (benchmark == 1)
5597 {
5598 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5599
5600 log_info ("");
5601 }
5602 else if (restore == 1)
5603 {
5604 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5605
5606 log_info ("");
5607 }
5608 else
5609 {
5610 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5611
5612 log_info ("");
5613 }
5614 }
5615
5616 /**
5617 * sanity check
5618 */
5619
5620 if (attack_mode > 7)
5621 {
5622 log_error ("ERROR: Invalid attack-mode specified");
5623
5624 return (-1);
5625 }
5626
5627 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5628 {
5629 log_error ("ERROR: Invalid runtime specified");
5630
5631 return (-1);
5632 }
5633
5634 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5635 {
5636 log_error ("ERROR: Invalid hash-type specified");
5637
5638 return (-1);
5639 }
5640
5641 // renamed hash modes
5642
5643 if (hash_mode_chgd)
5644 {
5645 int n = -1;
5646
5647 switch (hash_mode)
5648 {
5649 case 123: n = 124;
5650 break;
5651 }
5652
5653 if (n >= 0)
5654 {
5655 log_error ("Old -m specified, use -m %d instead", n);
5656
5657 return (-1);
5658 }
5659 }
5660
5661 if (username == 1)
5662 {
5663 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5664 {
5665 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5666
5667 return (-1);
5668 }
5669 }
5670
5671 if (outfile_format > 16)
5672 {
5673 log_error ("ERROR: Invalid outfile-format specified");
5674
5675 return (-1);
5676 }
5677
5678 if (left == 1)
5679 {
5680 if (outfile_format_chgd == 1)
5681 {
5682 if (outfile_format > 1)
5683 {
5684 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5685
5686 return (-1);
5687 }
5688 }
5689 else
5690 {
5691 outfile_format = OUTFILE_FMT_HASH;
5692 }
5693 }
5694
5695 if (show == 1)
5696 {
5697 if (outfile_format_chgd == 1)
5698 {
5699 if ((outfile_format > 7) && (outfile_format < 16))
5700 {
5701 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5702
5703 return (-1);
5704 }
5705 }
5706 }
5707
5708 if (increment_min < INCREMENT_MIN)
5709 {
5710 log_error ("ERROR: Invalid increment-min specified");
5711
5712 return (-1);
5713 }
5714
5715 if (increment_max > INCREMENT_MAX)
5716 {
5717 log_error ("ERROR: Invalid increment-max specified");
5718
5719 return (-1);
5720 }
5721
5722 if (increment_min > increment_max)
5723 {
5724 log_error ("ERROR: Invalid increment-min specified");
5725
5726 return (-1);
5727 }
5728
5729 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5730 {
5731 log_error ("ERROR: increment is not allowed in attack-mode 0");
5732
5733 return (-1);
5734 }
5735
5736 if ((increment == 0) && (increment_min_chgd == 1))
5737 {
5738 log_error ("ERROR: increment-min is only supported together with increment switch");
5739
5740 return (-1);
5741 }
5742
5743 if ((increment == 0) && (increment_max_chgd == 1))
5744 {
5745 log_error ("ERROR: increment-max is only supported together with increment switch");
5746
5747 return (-1);
5748 }
5749
5750 if (rp_files_cnt && rp_gen)
5751 {
5752 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5753
5754 return (-1);
5755 }
5756
5757 if (rp_files_cnt || rp_gen)
5758 {
5759 if (attack_mode != ATTACK_MODE_STRAIGHT)
5760 {
5761 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5762
5763 return (-1);
5764 }
5765 }
5766
5767 if (rp_gen_func_min > rp_gen_func_max)
5768 {
5769 log_error ("ERROR: Invalid rp-gen-func-min specified");
5770
5771 return (-1);
5772 }
5773
5774 if (kernel_accel_chgd == 1)
5775 {
5776 if (workload_profile != WORKLOAD_PROFILE)
5777 {
5778 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5779
5780 return (-1);
5781 }
5782
5783 if (kernel_accel < 1)
5784 {
5785 log_error ("ERROR: Invalid kernel-accel specified");
5786
5787 return (-1);
5788 }
5789
5790 if (kernel_accel > 800)
5791 {
5792 log_error ("ERROR: Invalid kernel-accel specified");
5793
5794 return (-1);
5795 }
5796 }
5797
5798 if (kernel_loops_chgd == 1)
5799 {
5800 if (workload_profile != WORKLOAD_PROFILE)
5801 {
5802 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5803
5804 return (-1);
5805 }
5806
5807 if (kernel_loops < 1)
5808 {
5809 log_error ("ERROR: Invalid kernel-loops specified");
5810
5811 return (-1);
5812 }
5813
5814 if (kernel_loops > 1024)
5815 {
5816 log_error ("ERROR: Invalid kernel-loops specified");
5817
5818 return (-1);
5819 }
5820 }
5821
5822 if (benchmark == 1)
5823 {
5824 if (workload_profile != WORKLOAD_PROFILE)
5825 {
5826 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5827
5828 return (-1);
5829 }
5830 }
5831
5832 if ((workload_profile < 1) || (workload_profile > 3))
5833 {
5834 log_error ("ERROR: workload-profile %i not available", workload_profile);
5835
5836 return (-1);
5837 }
5838
5839 if (show == 1 || left == 1)
5840 {
5841 attack_mode = ATTACK_MODE_NONE;
5842
5843 if (remove == 1)
5844 {
5845 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5846
5847 return (-1);
5848 }
5849
5850 if (potfile_disable == 1)
5851 {
5852 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 uint attack_kern = ATTACK_KERN_NONE;
5859
5860 switch (attack_mode)
5861 {
5862 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5863 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5864 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5865 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5866 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5867 }
5868
5869 if (benchmark == 0)
5870 {
5871 if (keyspace == 1)
5872 {
5873 int num_additional_params = 1;
5874
5875 if (attack_kern == ATTACK_KERN_COMBI)
5876 {
5877 num_additional_params = 2;
5878 }
5879
5880 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5881
5882 if (keyspace_wordlist_specified == 0) optind--;
5883 }
5884
5885 if (attack_kern == ATTACK_KERN_NONE)
5886 {
5887 if ((optind + 1) != myargc)
5888 {
5889 usage_mini_print (myargv[0]);
5890
5891 return (-1);
5892 }
5893 }
5894 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5895 {
5896 if ((optind + 1) > myargc)
5897 {
5898 usage_mini_print (myargv[0]);
5899
5900 return (-1);
5901 }
5902 }
5903 else if (attack_kern == ATTACK_KERN_COMBI)
5904 {
5905 if ((optind + 3) != myargc)
5906 {
5907 usage_mini_print (myargv[0]);
5908
5909 return (-1);
5910 }
5911 }
5912 else if (attack_kern == ATTACK_KERN_BF)
5913 {
5914 if ((optind + 1) > myargc)
5915 {
5916 usage_mini_print (myargv[0]);
5917
5918 return (-1);
5919 }
5920 }
5921 else
5922 {
5923 usage_mini_print (myargv[0]);
5924
5925 return (-1);
5926 }
5927 }
5928 else
5929 {
5930 if (myargv[optind] != 0)
5931 {
5932 log_error ("ERROR: Invalid argument for benchmark mode specified");
5933
5934 return (-1);
5935 }
5936
5937 if (attack_mode_chgd == 1)
5938 {
5939 if (attack_mode != ATTACK_MODE_BF)
5940 {
5941 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (benchmark_mode == 0)
5948 {
5949 // nothing to do
5950 }
5951 else if (benchmark_mode == 1)
5952 {
5953 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5954 {
5955 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5956
5957 return (-1);
5958 }
5959 }
5960 else
5961 {
5962 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5963
5964 return (-1);
5965 }
5966 }
5967
5968 if (skip != 0 && limit != 0)
5969 {
5970 limit += skip;
5971 }
5972
5973 if (keyspace == 1)
5974 {
5975 if (show == 1)
5976 {
5977 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5978
5979 return (-1);
5980 }
5981 else if (left == 1)
5982 {
5983 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5984
5985 return (-1);
5986 }
5987
5988 potfile_disable = 1;
5989
5990 restore_disable = 1;
5991
5992 restore = 0;
5993
5994 weak_hash_threshold = 0;
5995
5996 quiet = 1;
5997 }
5998
5999 if (remove_timer_chgd == 1)
6000 {
6001 if (remove == 0)
6002 {
6003 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6004
6005 return (-1);
6006 }
6007
6008 if (remove_timer < 1)
6009 {
6010 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6011
6012 return (-1);
6013 }
6014 }
6015
6016 if (loopback == 1)
6017 {
6018 if (attack_mode == ATTACK_MODE_BF)
6019 {
6020 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6021
6022 return (-1);
6023 }
6024 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6025 {
6026 if ((rp_files_cnt == 0) && (rp_gen == 0))
6027 {
6028 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6029
6030 return (-1);
6031 }
6032 }
6033 }
6034
6035 if (debug_mode > 0)
6036 {
6037 if (attack_mode != ATTACK_MODE_STRAIGHT)
6038 {
6039 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6040
6041 return (-1);
6042 }
6043
6044 if ((rp_files_cnt == 0) && (rp_gen == 0))
6045 {
6046 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6047
6048 return (-1);
6049 }
6050 }
6051
6052 if (debug_mode > 4)
6053 {
6054 log_error ("ERROR: Invalid debug-mode specified");
6055
6056 return (-1);
6057 }
6058
6059 if (debug_file != NULL)
6060 {
6061 if (debug_mode < 1)
6062 {
6063 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6064
6065 return (-1);
6066 }
6067 }
6068
6069 if (induction_dir != NULL)
6070 {
6071 if (attack_mode == ATTACK_MODE_BF)
6072 {
6073 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6074
6075 return (-1);
6076 }
6077 }
6078
6079 /**
6080 * induction directory
6081 */
6082
6083 char *induction_directory = NULL;
6084
6085 if (attack_mode != ATTACK_MODE_BF)
6086 {
6087 if (induction_dir == NULL)
6088 {
6089 induction_directory = (char *) mymalloc (session_size);
6090
6091 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6092
6093 // create induction folder if it does not already exist
6094
6095 if (keyspace == 0)
6096 {
6097 if (rmdir (induction_directory) == -1)
6098 {
6099 if (errno == ENOENT)
6100 {
6101 // good, we can ignore
6102 }
6103 else if (errno == ENOTEMPTY)
6104 {
6105 char *induction_directory_mv = (char *) mymalloc (session_size);
6106
6107 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6108
6109 if (rename (induction_directory, induction_directory_mv) != 0)
6110 {
6111 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6112
6113 return (-1);
6114 }
6115 }
6116 else
6117 {
6118 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6119
6120 return (-1);
6121 }
6122 }
6123
6124 if (mkdir (induction_directory, 0700) == -1)
6125 {
6126 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6127
6128 return (-1);
6129 }
6130 }
6131 }
6132 else
6133 {
6134 induction_directory = induction_dir;
6135 }
6136 }
6137
6138 data.induction_directory = induction_directory;
6139
6140 /**
6141 * loopback
6142 */
6143
6144 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6145
6146 char *loopback_file = (char *) mymalloc (loopback_size);
6147
6148 /**
6149 * outfile-check directory
6150 */
6151
6152 char *outfile_check_directory = NULL;
6153
6154 if (outfile_check_dir == NULL)
6155 {
6156 outfile_check_directory = (char *) mymalloc (session_size);
6157
6158 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6159 }
6160 else
6161 {
6162 outfile_check_directory = outfile_check_dir;
6163 }
6164
6165 data.outfile_check_directory = outfile_check_directory;
6166
6167 if (keyspace == 0)
6168 {
6169 struct stat outfile_check_stat;
6170
6171 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6172 {
6173 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6174
6175 if (is_dir == 0)
6176 {
6177 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6178
6179 return (-1);
6180 }
6181 }
6182 else if (outfile_check_dir == NULL)
6183 {
6184 if (mkdir (outfile_check_directory, 0700) == -1)
6185 {
6186 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6187
6188 return (-1);
6189 }
6190 }
6191 }
6192
6193 /**
6194 * special other stuff
6195 */
6196
6197 if (hash_mode == 9710)
6198 {
6199 outfile_format = 5;
6200 outfile_format_chgd = 1;
6201 }
6202
6203 if (hash_mode == 9810)
6204 {
6205 outfile_format = 5;
6206 outfile_format_chgd = 1;
6207 }
6208
6209 if (hash_mode == 10410)
6210 {
6211 outfile_format = 5;
6212 outfile_format_chgd = 1;
6213 }
6214
6215 /**
6216 * store stuff
6217 */
6218
6219 data.hash_mode = hash_mode;
6220 data.restore = restore;
6221 data.restore_timer = restore_timer;
6222 data.restore_disable = restore_disable;
6223 data.status = status;
6224 data.status_timer = status_timer;
6225 data.status_automat = status_automat;
6226 data.loopback = loopback;
6227 data.runtime = runtime;
6228 data.remove = remove;
6229 data.remove_timer = remove_timer;
6230 data.debug_mode = debug_mode;
6231 data.debug_file = debug_file;
6232 data.username = username;
6233 data.quiet = quiet;
6234 data.outfile = outfile;
6235 data.outfile_format = outfile_format;
6236 data.outfile_autohex = outfile_autohex;
6237 data.hex_charset = hex_charset;
6238 data.hex_salt = hex_salt;
6239 data.hex_wordlist = hex_wordlist;
6240 data.separator = separator;
6241 data.rp_files = rp_files;
6242 data.rp_files_cnt = rp_files_cnt;
6243 data.rp_gen = rp_gen;
6244 data.rp_gen_seed = rp_gen_seed;
6245 data.force = force;
6246 data.benchmark = benchmark;
6247 data.skip = skip;
6248 data.limit = limit;
6249 data.powertune_enable = powertune_enable;
6250 data.logfile_disable = logfile_disable;
6251 data.truecrypt_keyfiles = truecrypt_keyfiles;
6252 data.scrypt_tmto = scrypt_tmto;
6253
6254 /**
6255 * cpu affinity
6256 */
6257
6258 if (cpu_affinity)
6259 {
6260 set_cpu_affinity (cpu_affinity);
6261 }
6262
6263 if (rp_gen_seed_chgd == 0)
6264 {
6265 srand (proc_start);
6266 }
6267 else
6268 {
6269 srand (rp_gen_seed);
6270 }
6271
6272 /**
6273 * logfile init
6274 */
6275
6276 if (logfile_disable == 0)
6277 {
6278 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6279
6280 char *logfile = (char *) mymalloc (logfile_size);
6281
6282 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6283
6284 data.logfile = logfile;
6285
6286 char *topid = logfile_generate_topid ();
6287
6288 data.topid = topid;
6289 }
6290
6291 // logfile_append() checks for logfile_disable internally to make it easier from here
6292
6293 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6294 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6295 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6296 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6297 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6298 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6299 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6300 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6301 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6302 #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));
6303
6304 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6305 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6306 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6307 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6308 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6309 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6310 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6311 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6312
6313 logfile_top_msg ("START");
6314
6315 logfile_top_uint (attack_mode);
6316 logfile_top_uint (attack_kern);
6317 logfile_top_uint (benchmark);
6318 logfile_top_uint (benchmark_mode);
6319 logfile_top_uint (bitmap_min);
6320 logfile_top_uint (bitmap_max);
6321 logfile_top_uint (debug_mode);
6322 logfile_top_uint (force);
6323 logfile_top_uint (kernel_accel);
6324 logfile_top_uint (kernel_loops);
6325 logfile_top_uint (gpu_temp_abort);
6326 logfile_top_uint (gpu_temp_disable);
6327 logfile_top_uint (gpu_temp_retain);
6328 logfile_top_uint (hash_mode);
6329 logfile_top_uint (hex_charset);
6330 logfile_top_uint (hex_salt);
6331 logfile_top_uint (hex_wordlist);
6332 logfile_top_uint (increment);
6333 logfile_top_uint (increment_max);
6334 logfile_top_uint (increment_min);
6335 logfile_top_uint (keyspace);
6336 logfile_top_uint (left);
6337 logfile_top_uint (logfile_disable);
6338 logfile_top_uint (loopback);
6339 logfile_top_uint (markov_classic);
6340 logfile_top_uint (markov_disable);
6341 logfile_top_uint (markov_threshold);
6342 logfile_top_uint (outfile_autohex);
6343 logfile_top_uint (outfile_check_timer);
6344 logfile_top_uint (outfile_format);
6345 logfile_top_uint (potfile_disable);
6346 logfile_top_uint (powertune_enable);
6347 logfile_top_uint (scrypt_tmto);
6348 logfile_top_uint (quiet);
6349 logfile_top_uint (remove);
6350 logfile_top_uint (remove_timer);
6351 logfile_top_uint (restore);
6352 logfile_top_uint (restore_disable);
6353 logfile_top_uint (restore_timer);
6354 logfile_top_uint (rp_gen);
6355 logfile_top_uint (rp_gen_func_max);
6356 logfile_top_uint (rp_gen_func_min);
6357 logfile_top_uint (rp_gen_seed);
6358 logfile_top_uint (runtime);
6359 logfile_top_uint (segment_size);
6360 logfile_top_uint (show);
6361 logfile_top_uint (status);
6362 logfile_top_uint (status_automat);
6363 logfile_top_uint (status_timer);
6364 logfile_top_uint (usage);
6365 logfile_top_uint (username);
6366 logfile_top_uint (version);
6367 logfile_top_uint (weak_hash_threshold);
6368 logfile_top_uint (workload_profile);
6369 logfile_top_uint64 (limit);
6370 logfile_top_uint64 (skip);
6371 logfile_top_char (separator);
6372 logfile_top_string (cpu_affinity);
6373 logfile_top_string (custom_charset_1);
6374 logfile_top_string (custom_charset_2);
6375 logfile_top_string (custom_charset_3);
6376 logfile_top_string (custom_charset_4);
6377 logfile_top_string (debug_file);
6378 logfile_top_string (opencl_devices);
6379 logfile_top_string (opencl_platform);
6380 logfile_top_string (induction_dir);
6381 logfile_top_string (markov_hcstat);
6382 logfile_top_string (outfile);
6383 logfile_top_string (outfile_check_dir);
6384 logfile_top_string (rule_buf_l);
6385 logfile_top_string (rule_buf_r);
6386 logfile_top_string (session);
6387 logfile_top_string (truecrypt_keyfiles);
6388
6389 /**
6390 * devices
6391 */
6392
6393 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6394
6395 /**
6396 * benchmark
6397 */
6398
6399 if (benchmark == 1)
6400 {
6401 /**
6402 * disable useless stuff for benchmark
6403 */
6404
6405 restore_timer = 0;
6406 status_timer = 0;
6407 restore_disable = 1;
6408 potfile_disable = 1;
6409 weak_hash_threshold = 0;
6410
6411 data.restore_timer = restore_timer;
6412 data.status_timer = status_timer;
6413 data.restore_disable = restore_disable;
6414
6415 if (benchmark_mode == 1)
6416 {
6417 markov_disable = 1;
6418 }
6419
6420 /**
6421 * force attack mode to be bruteforce
6422 */
6423
6424 attack_mode = ATTACK_MODE_BF;
6425 attack_kern = ATTACK_KERN_BF;
6426
6427 if (runtime_chgd == 0)
6428 {
6429 runtime = 4;
6430
6431 if (benchmark_mode == 1) runtime = 17;
6432
6433 data.runtime = runtime;
6434 }
6435 }
6436
6437 /**
6438 * config
6439 */
6440
6441 uint hash_type = 0;
6442 uint salt_type = 0;
6443 uint attack_exec = 0;
6444 uint opts_type = 0;
6445 uint kern_type = 0;
6446 uint dgst_size = 0;
6447 uint esalt_size = 0;
6448 uint opti_type = 0;
6449 uint dgst_pos0 = -1;
6450 uint dgst_pos1 = -1;
6451 uint dgst_pos2 = -1;
6452 uint dgst_pos3 = -1;
6453
6454 int (*parse_func) (char *, uint, hash_t *);
6455 int (*sort_by_digest) (const void *, const void *);
6456
6457 uint algorithm_pos = 0;
6458 uint algorithm_max = 1;
6459
6460 uint *algorithms = default_benchmark_algorithms;
6461
6462 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6463
6464 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6465 {
6466 /*
6467 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6468 * the following algos are skipped entirely
6469 */
6470
6471 if (algorithm_pos > 0)
6472 {
6473 local_free (rd);
6474
6475 rd = init_restore (argc, argv);
6476
6477 data.rd = rd;
6478 }
6479
6480 /**
6481 * update hash_mode in case of multihash benchmark
6482 */
6483
6484 if (benchmark == 1)
6485 {
6486 if (hash_mode_chgd == 0)
6487 {
6488 hash_mode = algorithms[algorithm_pos];
6489
6490 data.hash_mode = hash_mode;
6491 }
6492
6493 quiet = 1;
6494
6495 data.quiet = quiet;
6496 }
6497
6498 switch (hash_mode)
6499 {
6500 case 0: hash_type = HASH_TYPE_MD5;
6501 salt_type = SALT_TYPE_NONE;
6502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6503 opts_type = OPTS_TYPE_PT_GENERATE_LE
6504 | OPTS_TYPE_PT_ADD80
6505 | OPTS_TYPE_PT_ADDBITS14;
6506 kern_type = KERN_TYPE_MD5;
6507 dgst_size = DGST_SIZE_4_4;
6508 parse_func = md5_parse_hash;
6509 sort_by_digest = sort_by_digest_4_4;
6510 opti_type = OPTI_TYPE_ZERO_BYTE
6511 | OPTI_TYPE_PRECOMPUTE_INIT
6512 | OPTI_TYPE_PRECOMPUTE_MERKLE
6513 | OPTI_TYPE_MEET_IN_MIDDLE
6514 | OPTI_TYPE_EARLY_SKIP
6515 | OPTI_TYPE_NOT_ITERATED
6516 | OPTI_TYPE_NOT_SALTED
6517 | OPTI_TYPE_RAW_HASH;
6518 dgst_pos0 = 0;
6519 dgst_pos1 = 3;
6520 dgst_pos2 = 2;
6521 dgst_pos3 = 1;
6522 break;
6523
6524 case 10: hash_type = HASH_TYPE_MD5;
6525 salt_type = SALT_TYPE_INTERN;
6526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6527 opts_type = OPTS_TYPE_PT_GENERATE_LE
6528 | OPTS_TYPE_ST_ADD80
6529 | OPTS_TYPE_ST_ADDBITS14;
6530 kern_type = KERN_TYPE_MD5_PWSLT;
6531 dgst_size = DGST_SIZE_4_4;
6532 parse_func = md5s_parse_hash;
6533 sort_by_digest = sort_by_digest_4_4;
6534 opti_type = OPTI_TYPE_ZERO_BYTE
6535 | OPTI_TYPE_PRECOMPUTE_INIT
6536 | OPTI_TYPE_PRECOMPUTE_MERKLE
6537 | OPTI_TYPE_MEET_IN_MIDDLE
6538 | OPTI_TYPE_EARLY_SKIP
6539 | OPTI_TYPE_NOT_ITERATED
6540 | OPTI_TYPE_APPENDED_SALT
6541 | OPTI_TYPE_RAW_HASH;
6542 dgst_pos0 = 0;
6543 dgst_pos1 = 3;
6544 dgst_pos2 = 2;
6545 dgst_pos3 = 1;
6546 break;
6547
6548 case 11: hash_type = HASH_TYPE_MD5;
6549 salt_type = SALT_TYPE_INTERN;
6550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6551 opts_type = OPTS_TYPE_PT_GENERATE_LE
6552 | OPTS_TYPE_ST_ADD80
6553 | OPTS_TYPE_ST_ADDBITS14;
6554 kern_type = KERN_TYPE_MD5_PWSLT;
6555 dgst_size = DGST_SIZE_4_4;
6556 parse_func = joomla_parse_hash;
6557 sort_by_digest = sort_by_digest_4_4;
6558 opti_type = OPTI_TYPE_ZERO_BYTE
6559 | OPTI_TYPE_PRECOMPUTE_INIT
6560 | OPTI_TYPE_PRECOMPUTE_MERKLE
6561 | OPTI_TYPE_MEET_IN_MIDDLE
6562 | OPTI_TYPE_EARLY_SKIP
6563 | OPTI_TYPE_NOT_ITERATED
6564 | OPTI_TYPE_APPENDED_SALT
6565 | OPTI_TYPE_RAW_HASH;
6566 dgst_pos0 = 0;
6567 dgst_pos1 = 3;
6568 dgst_pos2 = 2;
6569 dgst_pos3 = 1;
6570 break;
6571
6572 case 12: hash_type = HASH_TYPE_MD5;
6573 salt_type = SALT_TYPE_INTERN;
6574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6575 opts_type = OPTS_TYPE_PT_GENERATE_LE
6576 | OPTS_TYPE_ST_ADD80
6577 | OPTS_TYPE_ST_ADDBITS14;
6578 kern_type = KERN_TYPE_MD5_PWSLT;
6579 dgst_size = DGST_SIZE_4_4;
6580 parse_func = postgresql_parse_hash;
6581 sort_by_digest = sort_by_digest_4_4;
6582 opti_type = OPTI_TYPE_ZERO_BYTE
6583 | OPTI_TYPE_PRECOMPUTE_INIT
6584 | OPTI_TYPE_PRECOMPUTE_MERKLE
6585 | OPTI_TYPE_MEET_IN_MIDDLE
6586 | OPTI_TYPE_EARLY_SKIP
6587 | OPTI_TYPE_NOT_ITERATED
6588 | OPTI_TYPE_APPENDED_SALT
6589 | OPTI_TYPE_RAW_HASH;
6590 dgst_pos0 = 0;
6591 dgst_pos1 = 3;
6592 dgst_pos2 = 2;
6593 dgst_pos3 = 1;
6594 break;
6595
6596 case 20: hash_type = HASH_TYPE_MD5;
6597 salt_type = SALT_TYPE_INTERN;
6598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6599 opts_type = OPTS_TYPE_PT_GENERATE_LE
6600 | OPTS_TYPE_PT_ADD80
6601 | OPTS_TYPE_PT_ADDBITS14;
6602 kern_type = KERN_TYPE_MD5_SLTPW;
6603 dgst_size = DGST_SIZE_4_4;
6604 parse_func = md5s_parse_hash;
6605 sort_by_digest = sort_by_digest_4_4;
6606 opti_type = OPTI_TYPE_ZERO_BYTE
6607 | OPTI_TYPE_PRECOMPUTE_INIT
6608 | OPTI_TYPE_PRECOMPUTE_MERKLE
6609 | OPTI_TYPE_EARLY_SKIP
6610 | OPTI_TYPE_NOT_ITERATED
6611 | OPTI_TYPE_PREPENDED_SALT
6612 | OPTI_TYPE_RAW_HASH;
6613 dgst_pos0 = 0;
6614 dgst_pos1 = 3;
6615 dgst_pos2 = 2;
6616 dgst_pos3 = 1;
6617 break;
6618
6619 case 21: hash_type = HASH_TYPE_MD5;
6620 salt_type = SALT_TYPE_INTERN;
6621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6622 opts_type = OPTS_TYPE_PT_GENERATE_LE
6623 | OPTS_TYPE_PT_ADD80
6624 | OPTS_TYPE_PT_ADDBITS14;
6625 kern_type = KERN_TYPE_MD5_SLTPW;
6626 dgst_size = DGST_SIZE_4_4;
6627 parse_func = osc_parse_hash;
6628 sort_by_digest = sort_by_digest_4_4;
6629 opti_type = OPTI_TYPE_ZERO_BYTE
6630 | OPTI_TYPE_PRECOMPUTE_INIT
6631 | OPTI_TYPE_PRECOMPUTE_MERKLE
6632 | OPTI_TYPE_EARLY_SKIP
6633 | OPTI_TYPE_NOT_ITERATED
6634 | OPTI_TYPE_PREPENDED_SALT
6635 | OPTI_TYPE_RAW_HASH;
6636 dgst_pos0 = 0;
6637 dgst_pos1 = 3;
6638 dgst_pos2 = 2;
6639 dgst_pos3 = 1;
6640 break;
6641
6642 case 22: hash_type = HASH_TYPE_MD5;
6643 salt_type = SALT_TYPE_EMBEDDED;
6644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6645 opts_type = OPTS_TYPE_PT_GENERATE_LE
6646 | OPTS_TYPE_PT_ADD80
6647 | OPTS_TYPE_PT_ADDBITS14;
6648 kern_type = KERN_TYPE_MD5_SLTPW;
6649 dgst_size = DGST_SIZE_4_4;
6650 parse_func = netscreen_parse_hash;
6651 sort_by_digest = sort_by_digest_4_4;
6652 opti_type = OPTI_TYPE_ZERO_BYTE
6653 | OPTI_TYPE_PRECOMPUTE_INIT
6654 | OPTI_TYPE_PRECOMPUTE_MERKLE
6655 | OPTI_TYPE_EARLY_SKIP
6656 | OPTI_TYPE_NOT_ITERATED
6657 | OPTI_TYPE_PREPENDED_SALT
6658 | OPTI_TYPE_RAW_HASH;
6659 dgst_pos0 = 0;
6660 dgst_pos1 = 3;
6661 dgst_pos2 = 2;
6662 dgst_pos3 = 1;
6663 break;
6664
6665 case 23: hash_type = HASH_TYPE_MD5;
6666 salt_type = SALT_TYPE_EMBEDDED;
6667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6668 opts_type = OPTS_TYPE_PT_GENERATE_LE
6669 | OPTS_TYPE_PT_ADD80
6670 | OPTS_TYPE_PT_ADDBITS14;
6671 kern_type = KERN_TYPE_MD5_SLTPW;
6672 dgst_size = DGST_SIZE_4_4;
6673 parse_func = skype_parse_hash;
6674 sort_by_digest = sort_by_digest_4_4;
6675 opti_type = OPTI_TYPE_ZERO_BYTE
6676 | OPTI_TYPE_PRECOMPUTE_INIT
6677 | OPTI_TYPE_PRECOMPUTE_MERKLE
6678 | OPTI_TYPE_EARLY_SKIP
6679 | OPTI_TYPE_NOT_ITERATED
6680 | OPTI_TYPE_PREPENDED_SALT
6681 | OPTI_TYPE_RAW_HASH;
6682 dgst_pos0 = 0;
6683 dgst_pos1 = 3;
6684 dgst_pos2 = 2;
6685 dgst_pos3 = 1;
6686 break;
6687
6688 case 30: hash_type = HASH_TYPE_MD5;
6689 salt_type = SALT_TYPE_INTERN;
6690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6691 opts_type = OPTS_TYPE_PT_GENERATE_LE
6692 | OPTS_TYPE_PT_UNICODE
6693 | OPTS_TYPE_ST_ADD80
6694 | OPTS_TYPE_ST_ADDBITS14;
6695 kern_type = KERN_TYPE_MD5_PWUSLT;
6696 dgst_size = DGST_SIZE_4_4;
6697 parse_func = md5s_parse_hash;
6698 sort_by_digest = sort_by_digest_4_4;
6699 opti_type = OPTI_TYPE_ZERO_BYTE
6700 | OPTI_TYPE_PRECOMPUTE_INIT
6701 | OPTI_TYPE_PRECOMPUTE_MERKLE
6702 | OPTI_TYPE_MEET_IN_MIDDLE
6703 | OPTI_TYPE_EARLY_SKIP
6704 | OPTI_TYPE_NOT_ITERATED
6705 | OPTI_TYPE_APPENDED_SALT
6706 | OPTI_TYPE_RAW_HASH;
6707 dgst_pos0 = 0;
6708 dgst_pos1 = 3;
6709 dgst_pos2 = 2;
6710 dgst_pos3 = 1;
6711 break;
6712
6713 case 40: hash_type = HASH_TYPE_MD5;
6714 salt_type = SALT_TYPE_INTERN;
6715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6716 opts_type = OPTS_TYPE_PT_GENERATE_LE
6717 | OPTS_TYPE_PT_ADD80
6718 | OPTS_TYPE_PT_ADDBITS14
6719 | OPTS_TYPE_PT_UNICODE;
6720 kern_type = KERN_TYPE_MD5_SLTPWU;
6721 dgst_size = DGST_SIZE_4_4;
6722 parse_func = md5s_parse_hash;
6723 sort_by_digest = sort_by_digest_4_4;
6724 opti_type = OPTI_TYPE_ZERO_BYTE
6725 | OPTI_TYPE_PRECOMPUTE_INIT
6726 | OPTI_TYPE_PRECOMPUTE_MERKLE
6727 | OPTI_TYPE_EARLY_SKIP
6728 | OPTI_TYPE_NOT_ITERATED
6729 | OPTI_TYPE_PREPENDED_SALT
6730 | OPTI_TYPE_RAW_HASH;
6731 dgst_pos0 = 0;
6732 dgst_pos1 = 3;
6733 dgst_pos2 = 2;
6734 dgst_pos3 = 1;
6735 break;
6736
6737 case 50: hash_type = HASH_TYPE_MD5;
6738 salt_type = SALT_TYPE_INTERN;
6739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6740 opts_type = OPTS_TYPE_PT_GENERATE_LE
6741 | OPTS_TYPE_ST_ADD80
6742 | OPTS_TYPE_ST_ADDBITS14;
6743 kern_type = KERN_TYPE_HMACMD5_PW;
6744 dgst_size = DGST_SIZE_4_4;
6745 parse_func = hmacmd5_parse_hash;
6746 sort_by_digest = sort_by_digest_4_4;
6747 opti_type = OPTI_TYPE_ZERO_BYTE
6748 | OPTI_TYPE_NOT_ITERATED;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 60: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_INTERN;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_HMACMD5_SLT;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = hmacmd5_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_NOT_ITERATED;
6767 dgst_pos0 = 0;
6768 dgst_pos1 = 3;
6769 dgst_pos2 = 2;
6770 dgst_pos3 = 1;
6771 break;
6772
6773 case 100: hash_type = HASH_TYPE_SHA1;
6774 salt_type = SALT_TYPE_NONE;
6775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6776 opts_type = OPTS_TYPE_PT_GENERATE_BE
6777 | OPTS_TYPE_PT_ADD80
6778 | OPTS_TYPE_PT_ADDBITS15;
6779 kern_type = KERN_TYPE_SHA1;
6780 dgst_size = DGST_SIZE_4_5;
6781 parse_func = sha1_parse_hash;
6782 sort_by_digest = sort_by_digest_4_5;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_PRECOMPUTE_INIT
6785 | OPTI_TYPE_PRECOMPUTE_MERKLE
6786 | OPTI_TYPE_EARLY_SKIP
6787 | OPTI_TYPE_NOT_ITERATED
6788 | OPTI_TYPE_NOT_SALTED
6789 | OPTI_TYPE_RAW_HASH;
6790 dgst_pos0 = 3;
6791 dgst_pos1 = 4;
6792 dgst_pos2 = 2;
6793 dgst_pos3 = 1;
6794 break;
6795
6796 case 101: hash_type = HASH_TYPE_SHA1;
6797 salt_type = SALT_TYPE_NONE;
6798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6799 opts_type = OPTS_TYPE_PT_GENERATE_BE
6800 | OPTS_TYPE_PT_ADD80
6801 | OPTS_TYPE_PT_ADDBITS15;
6802 kern_type = KERN_TYPE_SHA1;
6803 dgst_size = DGST_SIZE_4_5;
6804 parse_func = sha1b64_parse_hash;
6805 sort_by_digest = sort_by_digest_4_5;
6806 opti_type = OPTI_TYPE_ZERO_BYTE
6807 | OPTI_TYPE_PRECOMPUTE_INIT
6808 | OPTI_TYPE_PRECOMPUTE_MERKLE
6809 | OPTI_TYPE_EARLY_SKIP
6810 | OPTI_TYPE_NOT_ITERATED
6811 | OPTI_TYPE_NOT_SALTED
6812 | OPTI_TYPE_RAW_HASH;
6813 dgst_pos0 = 3;
6814 dgst_pos1 = 4;
6815 dgst_pos2 = 2;
6816 dgst_pos3 = 1;
6817 break;
6818
6819 case 110: hash_type = HASH_TYPE_SHA1;
6820 salt_type = SALT_TYPE_INTERN;
6821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6822 opts_type = OPTS_TYPE_PT_GENERATE_BE
6823 | OPTS_TYPE_ST_ADD80
6824 | OPTS_TYPE_ST_ADDBITS15;
6825 kern_type = KERN_TYPE_SHA1_PWSLT;
6826 dgst_size = DGST_SIZE_4_5;
6827 parse_func = sha1s_parse_hash;
6828 sort_by_digest = sort_by_digest_4_5;
6829 opti_type = OPTI_TYPE_ZERO_BYTE
6830 | OPTI_TYPE_PRECOMPUTE_INIT
6831 | OPTI_TYPE_PRECOMPUTE_MERKLE
6832 | OPTI_TYPE_EARLY_SKIP
6833 | OPTI_TYPE_NOT_ITERATED
6834 | OPTI_TYPE_APPENDED_SALT
6835 | OPTI_TYPE_RAW_HASH;
6836 dgst_pos0 = 3;
6837 dgst_pos1 = 4;
6838 dgst_pos2 = 2;
6839 dgst_pos3 = 1;
6840 break;
6841
6842 case 111: hash_type = HASH_TYPE_SHA1;
6843 salt_type = SALT_TYPE_EMBEDDED;
6844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6845 opts_type = OPTS_TYPE_PT_GENERATE_BE
6846 | OPTS_TYPE_ST_ADD80
6847 | OPTS_TYPE_ST_ADDBITS15;
6848 kern_type = KERN_TYPE_SHA1_PWSLT;
6849 dgst_size = DGST_SIZE_4_5;
6850 parse_func = sha1b64s_parse_hash;
6851 sort_by_digest = sort_by_digest_4_5;
6852 opti_type = OPTI_TYPE_ZERO_BYTE
6853 | OPTI_TYPE_PRECOMPUTE_INIT
6854 | OPTI_TYPE_PRECOMPUTE_MERKLE
6855 | OPTI_TYPE_EARLY_SKIP
6856 | OPTI_TYPE_NOT_ITERATED
6857 | OPTI_TYPE_APPENDED_SALT
6858 | OPTI_TYPE_RAW_HASH;
6859 dgst_pos0 = 3;
6860 dgst_pos1 = 4;
6861 dgst_pos2 = 2;
6862 dgst_pos3 = 1;
6863 break;
6864
6865 case 112: hash_type = HASH_TYPE_SHA1;
6866 salt_type = SALT_TYPE_INTERN;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_BE
6869 | OPTS_TYPE_ST_ADD80
6870 | OPTS_TYPE_ST_ADDBITS15
6871 | OPTS_TYPE_ST_HEX;
6872 kern_type = KERN_TYPE_SHA1_PWSLT;
6873 dgst_size = DGST_SIZE_4_5;
6874 parse_func = oracles_parse_hash;
6875 sort_by_digest = sort_by_digest_4_5;
6876 opti_type = OPTI_TYPE_ZERO_BYTE
6877 | OPTI_TYPE_PRECOMPUTE_INIT
6878 | OPTI_TYPE_PRECOMPUTE_MERKLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_APPENDED_SALT
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 3;
6884 dgst_pos1 = 4;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 120: hash_type = HASH_TYPE_SHA1;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_BE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS15;
6895 kern_type = KERN_TYPE_SHA1_SLTPW;
6896 dgst_size = DGST_SIZE_4_5;
6897 parse_func = sha1s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_5;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_PREPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 3;
6907 dgst_pos1 = 4;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 121: hash_type = HASH_TYPE_SHA1;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_BE
6916 | OPTS_TYPE_PT_ADD80
6917 | OPTS_TYPE_PT_ADDBITS15
6918 | OPTS_TYPE_ST_LOWER;
6919 kern_type = KERN_TYPE_SHA1_SLTPW;
6920 dgst_size = DGST_SIZE_4_5;
6921 parse_func = smf_parse_hash;
6922 sort_by_digest = sort_by_digest_4_5;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_EARLY_SKIP
6927 | OPTI_TYPE_NOT_ITERATED
6928 | OPTI_TYPE_PREPENDED_SALT
6929 | OPTI_TYPE_RAW_HASH;
6930 dgst_pos0 = 3;
6931 dgst_pos1 = 4;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 122: hash_type = HASH_TYPE_SHA1;
6937 salt_type = SALT_TYPE_EMBEDDED;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_BE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS15
6942 | OPTS_TYPE_ST_HEX;
6943 kern_type = KERN_TYPE_SHA1_SLTPW;
6944 dgst_size = DGST_SIZE_4_5;
6945 parse_func = osx1_parse_hash;
6946 sort_by_digest = sort_by_digest_4_5;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_EARLY_SKIP
6951 | OPTI_TYPE_NOT_ITERATED
6952 | OPTI_TYPE_PREPENDED_SALT
6953 | OPTI_TYPE_RAW_HASH;
6954 dgst_pos0 = 3;
6955 dgst_pos1 = 4;
6956 dgst_pos2 = 2;
6957 dgst_pos3 = 1;
6958 break;
6959
6960 case 124: hash_type = HASH_TYPE_SHA1;
6961 salt_type = SALT_TYPE_EMBEDDED;
6962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6963 opts_type = OPTS_TYPE_PT_GENERATE_BE
6964 | OPTS_TYPE_PT_ADD80
6965 | OPTS_TYPE_PT_ADDBITS15;
6966 kern_type = KERN_TYPE_SHA1_SLTPW;
6967 dgst_size = DGST_SIZE_4_5;
6968 parse_func = djangosha1_parse_hash;
6969 sort_by_digest = sort_by_digest_4_5;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 3;
6978 dgst_pos1 = 4;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 130: hash_type = HASH_TYPE_SHA1;
6984 salt_type = SALT_TYPE_INTERN;
6985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6986 opts_type = OPTS_TYPE_PT_GENERATE_BE
6987 | OPTS_TYPE_PT_UNICODE
6988 | OPTS_TYPE_ST_ADD80
6989 | OPTS_TYPE_ST_ADDBITS15;
6990 kern_type = KERN_TYPE_SHA1_PWUSLT;
6991 dgst_size = DGST_SIZE_4_5;
6992 parse_func = sha1s_parse_hash;
6993 sort_by_digest = sort_by_digest_4_5;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_EARLY_SKIP
6998 | OPTI_TYPE_NOT_ITERATED
6999 | OPTI_TYPE_APPENDED_SALT
7000 | OPTI_TYPE_RAW_HASH;
7001 dgst_pos0 = 3;
7002 dgst_pos1 = 4;
7003 dgst_pos2 = 2;
7004 dgst_pos3 = 1;
7005 break;
7006
7007 case 131: hash_type = HASH_TYPE_SHA1;
7008 salt_type = SALT_TYPE_EMBEDDED;
7009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7010 opts_type = OPTS_TYPE_PT_GENERATE_BE
7011 | OPTS_TYPE_PT_UNICODE
7012 | OPTS_TYPE_PT_UPPER
7013 | OPTS_TYPE_ST_ADD80
7014 | OPTS_TYPE_ST_ADDBITS15
7015 | OPTS_TYPE_ST_HEX;
7016 kern_type = KERN_TYPE_SHA1_PWUSLT;
7017 dgst_size = DGST_SIZE_4_5;
7018 parse_func = mssql2000_parse_hash;
7019 sort_by_digest = sort_by_digest_4_5;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_APPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 3;
7028 dgst_pos1 = 4;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 132: hash_type = HASH_TYPE_SHA1;
7034 salt_type = SALT_TYPE_EMBEDDED;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_BE
7037 | OPTS_TYPE_PT_UNICODE
7038 | OPTS_TYPE_ST_ADD80
7039 | OPTS_TYPE_ST_ADDBITS15
7040 | OPTS_TYPE_ST_HEX;
7041 kern_type = KERN_TYPE_SHA1_PWUSLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = mssql2005_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_APPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 3;
7053 dgst_pos1 = 4;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 133: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_EMBEDDED;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_PT_UNICODE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1_PWUSLT;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = peoplesoft_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_APPENDED_SALT
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 140: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_PT_ADD80
7087 | OPTS_TYPE_PT_ADDBITS15
7088 | OPTS_TYPE_PT_UNICODE;
7089 kern_type = KERN_TYPE_SHA1_SLTPWU;
7090 dgst_size = DGST_SIZE_4_5;
7091 parse_func = sha1s_parse_hash;
7092 sort_by_digest = sort_by_digest_4_5;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_PREPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 3;
7101 dgst_pos1 = 4;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 141: hash_type = HASH_TYPE_SHA1;
7107 salt_type = SALT_TYPE_EMBEDDED;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_BE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS15
7112 | OPTS_TYPE_PT_UNICODE
7113 | OPTS_TYPE_ST_BASE64;
7114 kern_type = KERN_TYPE_SHA1_SLTPWU;
7115 dgst_size = DGST_SIZE_4_5;
7116 parse_func = episerver_parse_hash;
7117 sort_by_digest = sort_by_digest_4_5;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_PREPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 150: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS15;
7137 kern_type = KERN_TYPE_HMACSHA1_PW;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = hmacsha1_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_NOT_ITERATED;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 160: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_INTERN;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_HMACSHA1_SLT;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = hmacsha1_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_NOT_ITERATED;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 190: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_NONE;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_PT_ADD80
7172 | OPTS_TYPE_PT_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1linkedin_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_EARLY_SKIP
7180 | OPTI_TYPE_NOT_ITERATED
7181 | OPTI_TYPE_NOT_SALTED;
7182 dgst_pos0 = 0;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 3;
7185 dgst_pos3 = 2;
7186 break;
7187
7188 case 200: hash_type = HASH_TYPE_MYSQL;
7189 salt_type = SALT_TYPE_NONE;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = 0;
7192 kern_type = KERN_TYPE_MYSQL;
7193 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7194 parse_func = mysql323_parse_hash;
7195 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7196 opti_type = OPTI_TYPE_ZERO_BYTE;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 1;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 3;
7201 break;
7202
7203 case 300: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_NONE;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS15;
7209 kern_type = KERN_TYPE_MYSQL41;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_NOT_SALTED;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 400: hash_type = HASH_TYPE_MD5;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7229 kern_type = KERN_TYPE_PHPASS;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = phpass_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
7233 opti_type = OPTI_TYPE_ZERO_BYTE;
7234 dgst_pos0 = 0;
7235 dgst_pos1 = 1;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 3;
7238 break;
7239
7240 case 500: hash_type = HASH_TYPE_MD5;
7241 salt_type = SALT_TYPE_EMBEDDED;
7242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7244 kern_type = KERN_TYPE_MD5CRYPT;
7245 dgst_size = DGST_SIZE_4_4;
7246 parse_func = md5crypt_parse_hash;
7247 sort_by_digest = sort_by_digest_4_4;
7248 opti_type = OPTI_TYPE_ZERO_BYTE;
7249 dgst_pos0 = 0;
7250 dgst_pos1 = 1;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 3;
7253 break;
7254
7255 case 501: hash_type = HASH_TYPE_MD5;
7256 salt_type = SALT_TYPE_EMBEDDED;
7257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_LE
7259 | OPTS_TYPE_HASH_COPY;
7260 kern_type = KERN_TYPE_MD5CRYPT;
7261 dgst_size = DGST_SIZE_4_4;
7262 parse_func = juniper_parse_hash;
7263 sort_by_digest = sort_by_digest_4_4;
7264 opti_type = OPTI_TYPE_ZERO_BYTE;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 1;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 3;
7269 break;
7270
7271 case 900: hash_type = HASH_TYPE_MD4;
7272 salt_type = SALT_TYPE_NONE;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14;
7277 kern_type = KERN_TYPE_MD4;
7278 dgst_size = DGST_SIZE_4_4;
7279 parse_func = md4_parse_hash;
7280 sort_by_digest = sort_by_digest_4_4;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_MEET_IN_MIDDLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_NOT_SALTED
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 1000: hash_type = HASH_TYPE_MD4;
7296 salt_type = SALT_TYPE_NONE;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS14
7301 | OPTS_TYPE_PT_UNICODE;
7302 kern_type = KERN_TYPE_MD4_PWU;
7303 dgst_size = DGST_SIZE_4_4;
7304 parse_func = md4_parse_hash;
7305 sort_by_digest = sort_by_digest_4_4;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_MEET_IN_MIDDLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_NOT_SALTED
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 0;
7315 dgst_pos1 = 3;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 1100: hash_type = HASH_TYPE_MD4;
7321 salt_type = SALT_TYPE_INTERN;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_LE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS14
7326 | OPTS_TYPE_PT_UNICODE
7327 | OPTS_TYPE_ST_ADD80
7328 | OPTS_TYPE_ST_UNICODE
7329 | OPTS_TYPE_ST_LOWER;
7330 kern_type = KERN_TYPE_MD44_PWUSLT;
7331 dgst_size = DGST_SIZE_4_4;
7332 parse_func = dcc_parse_hash;
7333 sort_by_digest = sort_by_digest_4_4;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED;
7339 dgst_pos0 = 0;
7340 dgst_pos1 = 3;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 1400: hash_type = HASH_TYPE_SHA256;
7346 salt_type = SALT_TYPE_NONE;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA256;
7352 dgst_size = DGST_SIZE_4_8;
7353 parse_func = sha256_parse_hash;
7354 sort_by_digest = sort_by_digest_4_8;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_NOT_SALTED
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 7;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 6;
7366 break;
7367
7368 case 1410: hash_type = HASH_TYPE_SHA256;
7369 salt_type = SALT_TYPE_INTERN;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA256_PWSLT;
7375 dgst_size = DGST_SIZE_4_8;
7376 parse_func = sha256s_parse_hash;
7377 sort_by_digest = sort_by_digest_4_8;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 7;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 6;
7389 break;
7390
7391 case 1420: hash_type = HASH_TYPE_SHA256;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_ADD80
7396 | OPTS_TYPE_PT_ADDBITS15;
7397 kern_type = KERN_TYPE_SHA256_SLTPW;
7398 dgst_size = DGST_SIZE_4_8;
7399 parse_func = sha256s_parse_hash;
7400 sort_by_digest = sort_by_digest_4_8;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_PREPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 7;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 6;
7412 break;
7413
7414 case 1421: hash_type = HASH_TYPE_SHA256;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_PT_ADD80
7419 | OPTS_TYPE_PT_ADDBITS15;
7420 kern_type = KERN_TYPE_SHA256_SLTPW;
7421 dgst_size = DGST_SIZE_4_8;
7422 parse_func = hmailserver_parse_hash;
7423 sort_by_digest = sort_by_digest_4_8;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_PREPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 7;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 6;
7435 break;
7436
7437 case 1430: hash_type = HASH_TYPE_SHA256;
7438 salt_type = SALT_TYPE_INTERN;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA256_PWUSLT;
7445 dgst_size = DGST_SIZE_4_8;
7446 parse_func = sha256s_parse_hash;
7447 sort_by_digest = sort_by_digest_4_8;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 7;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 6;
7459 break;
7460
7461 case 1440: hash_type = HASH_TYPE_SHA256;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA256_SLTPWU;
7469 dgst_size = DGST_SIZE_4_8;
7470 parse_func = sha256s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_8;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 7;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 6;
7483 break;
7484
7485 case 1441: hash_type = HASH_TYPE_SHA256;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA256_SLTPWU;
7494 dgst_size = DGST_SIZE_4_8;
7495 parse_func = episerver4_parse_hash;
7496 sort_by_digest = sort_by_digest_4_8;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 7;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 6;
7508 break;
7509
7510 case 1450: hash_type = HASH_TYPE_SHA256;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80;
7515 kern_type = KERN_TYPE_HMACSHA256_PW;
7516 dgst_size = DGST_SIZE_4_8;
7517 parse_func = hmacsha256_parse_hash;
7518 sort_by_digest = sort_by_digest_4_8;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_NOT_ITERATED;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1460: hash_type = HASH_TYPE_SHA256;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_PT_ADD80
7532 | OPTS_TYPE_PT_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA256_SLT;
7534 dgst_size = DGST_SIZE_4_8;
7535 parse_func = hmacsha256_parse_hash;
7536 sort_by_digest = sort_by_digest_4_8;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 7;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 6;
7543 break;
7544
7545 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7546 salt_type = SALT_TYPE_EMBEDDED;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_LE
7549 | OPTS_TYPE_PT_BITSLICE;
7550 kern_type = KERN_TYPE_DESCRYPT;
7551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7552 parse_func = descrypt_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7556 dgst_pos0 = 0;
7557 dgst_pos1 = 1;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 3;
7560 break;
7561
7562 case 1600: hash_type = HASH_TYPE_MD5;
7563 salt_type = SALT_TYPE_EMBEDDED;
7564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7566 kern_type = KERN_TYPE_APR1CRYPT;
7567 dgst_size = DGST_SIZE_4_4;
7568 parse_func = md5apr1_parse_hash;
7569 sort_by_digest = sort_by_digest_4_4;
7570 opti_type = OPTI_TYPE_ZERO_BYTE;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 1;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 3;
7575 break;
7576
7577 case 1700: hash_type = HASH_TYPE_SHA512;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_PT_ADD80
7582 | OPTS_TYPE_PT_ADDBITS15;
7583 kern_type = KERN_TYPE_SHA512;
7584 dgst_size = DGST_SIZE_8_8;
7585 parse_func = sha512_parse_hash;
7586 sort_by_digest = sort_by_digest_8_8;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_PRECOMPUTE_INIT
7589 | OPTI_TYPE_PRECOMPUTE_MERKLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_NOT_SALTED
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 14;
7595 dgst_pos1 = 15;
7596 dgst_pos2 = 6;
7597 dgst_pos3 = 7;
7598 break;
7599
7600 case 1710: hash_type = HASH_TYPE_SHA512;
7601 salt_type = SALT_TYPE_INTERN;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_ST_ADD80
7605 | OPTS_TYPE_ST_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA512_PWSLT;
7607 dgst_size = DGST_SIZE_8_8;
7608 parse_func = sha512s_parse_hash;
7609 sort_by_digest = sort_by_digest_8_8;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_APPENDED_SALT
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 14;
7618 dgst_pos1 = 15;
7619 dgst_pos2 = 6;
7620 dgst_pos3 = 7;
7621 break;
7622
7623 case 1711: hash_type = HASH_TYPE_SHA512;
7624 salt_type = SALT_TYPE_EMBEDDED;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA512_PWSLT;
7630 dgst_size = DGST_SIZE_8_8;
7631 parse_func = sha512b64s_parse_hash;
7632 sort_by_digest = sort_by_digest_8_8;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 14;
7641 dgst_pos1 = 15;
7642 dgst_pos2 = 6;
7643 dgst_pos3 = 7;
7644 break;
7645
7646 case 1720: hash_type = HASH_TYPE_SHA512;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_PT_ADD80
7651 | OPTS_TYPE_PT_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA512_SLTPW;
7653 dgst_size = DGST_SIZE_8_8;
7654 parse_func = sha512s_parse_hash;
7655 sort_by_digest = sort_by_digest_8_8;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_PREPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 14;
7664 dgst_pos1 = 15;
7665 dgst_pos2 = 6;
7666 dgst_pos3 = 7;
7667 break;
7668
7669 case 1722: hash_type = HASH_TYPE_SHA512;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15
7675 | OPTS_TYPE_ST_HEX;
7676 kern_type = KERN_TYPE_SHA512_SLTPW;
7677 dgst_size = DGST_SIZE_8_8;
7678 parse_func = osx512_parse_hash;
7679 sort_by_digest = sort_by_digest_8_8;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 14;
7688 dgst_pos1 = 15;
7689 dgst_pos2 = 6;
7690 dgst_pos3 = 7;
7691 break;
7692
7693 case 1730: hash_type = HASH_TYPE_SHA512;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_UNICODE
7698 | OPTS_TYPE_ST_ADD80
7699 | OPTS_TYPE_ST_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA512_PWSLTU;
7701 dgst_size = DGST_SIZE_8_8;
7702 parse_func = sha512s_parse_hash;
7703 sort_by_digest = sort_by_digest_8_8;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_APPENDED_SALT
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 14;
7712 dgst_pos1 = 15;
7713 dgst_pos2 = 6;
7714 dgst_pos3 = 7;
7715 break;
7716
7717 case 1731: hash_type = HASH_TYPE_SHA512;
7718 salt_type = SALT_TYPE_EMBEDDED;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_UNICODE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15
7724 | OPTS_TYPE_ST_HEX;
7725 kern_type = KERN_TYPE_SHA512_PWSLTU;
7726 dgst_size = DGST_SIZE_8_8;
7727 parse_func = mssql2012_parse_hash;
7728 sort_by_digest = sort_by_digest_8_8;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_APPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 14;
7737 dgst_pos1 = 15;
7738 dgst_pos2 = 6;
7739 dgst_pos3 = 7;
7740 break;
7741
7742 case 1740: hash_type = HASH_TYPE_SHA512;
7743 salt_type = SALT_TYPE_INTERN;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15
7748 | OPTS_TYPE_PT_UNICODE;
7749 kern_type = KERN_TYPE_SHA512_SLTPWU;
7750 dgst_size = DGST_SIZE_8_8;
7751 parse_func = sha512s_parse_hash;
7752 sort_by_digest = sort_by_digest_8_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 14;
7761 dgst_pos1 = 15;
7762 dgst_pos2 = 6;
7763 dgst_pos3 = 7;
7764 break;
7765
7766 case 1750: hash_type = HASH_TYPE_SHA512;
7767 salt_type = SALT_TYPE_INTERN;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_ST_ADD80;
7771 kern_type = KERN_TYPE_HMACSHA512_PW;
7772 dgst_size = DGST_SIZE_8_8;
7773 parse_func = hmacsha512_parse_hash;
7774 sort_by_digest = sort_by_digest_8_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_NOT_ITERATED;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1760: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_HMACSHA512_SLT;
7790 dgst_size = DGST_SIZE_8_8;
7791 parse_func = hmacsha512_parse_hash;
7792 sort_by_digest = sort_by_digest_8_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_NOT_ITERATED;
7795 dgst_pos0 = 14;
7796 dgst_pos1 = 15;
7797 dgst_pos2 = 6;
7798 dgst_pos3 = 7;
7799 break;
7800
7801 case 1800: hash_type = HASH_TYPE_SHA512;
7802 salt_type = SALT_TYPE_EMBEDDED;
7803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7805 kern_type = KERN_TYPE_SHA512CRYPT;
7806 dgst_size = DGST_SIZE_8_8;
7807 parse_func = sha512crypt_parse_hash;
7808 sort_by_digest = sort_by_digest_8_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 2100: hash_type = HASH_TYPE_DCC2;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_ST_LOWER
7821 | OPTS_TYPE_ST_UNICODE;
7822 kern_type = KERN_TYPE_DCC2;
7823 dgst_size = DGST_SIZE_4_4;
7824 parse_func = dcc2_parse_hash;
7825 sort_by_digest = sort_by_digest_4_4;
7826 opti_type = OPTI_TYPE_ZERO_BYTE;
7827 dgst_pos0 = 0;
7828 dgst_pos1 = 1;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 3;
7831 break;
7832
7833 case 2400: hash_type = HASH_TYPE_MD5;
7834 salt_type = SALT_TYPE_NONE;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7837 kern_type = KERN_TYPE_MD5PIX;
7838 dgst_size = DGST_SIZE_4_4;
7839 parse_func = md5pix_parse_hash;
7840 sort_by_digest = sort_by_digest_4_4;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_NOT_SALTED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 2410: hash_type = HASH_TYPE_MD5;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7857 kern_type = KERN_TYPE_MD5ASA;
7858 dgst_size = DGST_SIZE_4_4;
7859 parse_func = md5asa_parse_hash;
7860 sort_by_digest = sort_by_digest_4_4;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED;
7866 dgst_pos0 = 0;
7867 dgst_pos1 = 3;
7868 dgst_pos2 = 2;
7869 dgst_pos3 = 1;
7870 break;
7871
7872 case 2500: hash_type = HASH_TYPE_WPA;
7873 salt_type = SALT_TYPE_EMBEDDED;
7874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7876 kern_type = KERN_TYPE_WPA;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = wpa_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 1;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 3;
7885 break;
7886
7887 case 2600: hash_type = HASH_TYPE_MD5;
7888 salt_type = SALT_TYPE_VIRTUAL;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_LE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS14
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_MD55_PWSLT1;
7895 dgst_size = DGST_SIZE_4_4;
7896 parse_func = md5md5_parse_hash;
7897 sort_by_digest = sort_by_digest_4_4;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 2611: hash_type = HASH_TYPE_MD5;
7909 salt_type = SALT_TYPE_INTERN;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS14
7914 | OPTS_TYPE_ST_ADD80;
7915 kern_type = KERN_TYPE_MD55_PWSLT1;
7916 dgst_size = DGST_SIZE_4_4;
7917 parse_func = vb3_parse_hash;
7918 sort_by_digest = sort_by_digest_4_4;
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_INIT
7921 | OPTI_TYPE_PRECOMPUTE_MERKLE
7922 | OPTI_TYPE_EARLY_SKIP;
7923 dgst_pos0 = 0;
7924 dgst_pos1 = 3;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 2612: hash_type = HASH_TYPE_MD5;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_LE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS14
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_HEX;
7937 kern_type = KERN_TYPE_MD55_PWSLT1;
7938 dgst_size = DGST_SIZE_4_4;
7939 parse_func = phps_parse_hash;
7940 sort_by_digest = sort_by_digest_4_4;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP;
7945 dgst_pos0 = 0;
7946 dgst_pos1 = 3;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 1;
7949 break;
7950
7951 case 2711: hash_type = HASH_TYPE_MD5;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_LE
7955 | OPTS_TYPE_PT_ADD80
7956 | OPTS_TYPE_PT_ADDBITS14
7957 | OPTS_TYPE_ST_ADD80;
7958 kern_type = KERN_TYPE_MD55_PWSLT2;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = vb30_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_EARLY_SKIP;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 3;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 1;
7969 break;
7970
7971 case 2811: hash_type = HASH_TYPE_MD5;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE
7975 | OPTS_TYPE_PT_ADD80
7976 | OPTS_TYPE_PT_ADDBITS14;
7977 kern_type = KERN_TYPE_MD55_SLTPW;
7978 dgst_size = DGST_SIZE_4_4;
7979 parse_func = ipb2_parse_hash;
7980 sort_by_digest = sort_by_digest_4_4;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_EARLY_SKIP;
7984 dgst_pos0 = 0;
7985 dgst_pos1 = 3;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 1;
7988 break;
7989
7990 case 3000: hash_type = HASH_TYPE_LM;
7991 salt_type = SALT_TYPE_NONE;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE
7994 | OPTS_TYPE_PT_UPPER
7995 | OPTS_TYPE_PT_BITSLICE;
7996 kern_type = KERN_TYPE_LM;
7997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7998 parse_func = lm_parse_hash;
7999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8002 dgst_pos0 = 0;
8003 dgst_pos1 = 1;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 3;
8006 break;
8007
8008 case 3100: hash_type = HASH_TYPE_ORACLEH;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_LE
8012 | OPTS_TYPE_PT_UPPER
8013 | OPTS_TYPE_ST_UPPER;
8014 kern_type = KERN_TYPE_ORACLEH;
8015 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8016 parse_func = oracleh_parse_hash;
8017 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8018 opti_type = OPTI_TYPE_ZERO_BYTE;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 1;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 3;
8023 break;
8024
8025 case 3200: hash_type = HASH_TYPE_BCRYPT;
8026 salt_type = SALT_TYPE_EMBEDDED;
8027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_LE
8029 | OPTS_TYPE_ST_GENERATE_LE;
8030 kern_type = KERN_TYPE_BCRYPT;
8031 dgst_size = DGST_SIZE_4_6;
8032 parse_func = bcrypt_parse_hash;
8033 sort_by_digest = sort_by_digest_4_6;
8034 opti_type = OPTI_TYPE_ZERO_BYTE;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 1;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 3;
8039 break;
8040
8041 case 3710: hash_type = HASH_TYPE_MD5;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_PT_ADD80
8046 | OPTS_TYPE_PT_ADDBITS14;
8047 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8048 dgst_size = DGST_SIZE_4_4;
8049 parse_func = md5s_parse_hash;
8050 sort_by_digest = sort_by_digest_4_4;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 3;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 1;
8059 break;
8060
8061 case 3711: hash_type = HASH_TYPE_MD5;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE
8065 | OPTS_TYPE_PT_ADD80
8066 | OPTS_TYPE_PT_ADDBITS14;
8067 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8068 dgst_size = DGST_SIZE_4_4;
8069 parse_func = mediawiki_b_parse_hash;
8070 sort_by_digest = sort_by_digest_4_4;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP;
8075 dgst_pos0 = 0;
8076 dgst_pos1 = 3;
8077 dgst_pos2 = 2;
8078 dgst_pos3 = 1;
8079 break;
8080
8081 case 3800: hash_type = HASH_TYPE_MD5;
8082 salt_type = SALT_TYPE_INTERN;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_LE
8085 | OPTS_TYPE_ST_ADDBITS14;
8086 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = md5s_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 3;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102 case 4300: hash_type = HASH_TYPE_MD5;
8103 salt_type = SALT_TYPE_VIRTUAL;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS14
8108 | OPTS_TYPE_ST_ADD80;
8109 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8110 dgst_size = DGST_SIZE_4_4;
8111 parse_func = md5md5_parse_hash;
8112 sort_by_digest = sort_by_digest_4_4;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 3;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 1;
8121 break;
8122
8123
8124 case 4400: hash_type = HASH_TYPE_MD5;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_PT_ADD80
8129 | OPTS_TYPE_PT_ADDBITS15;
8130 kern_type = KERN_TYPE_MD5_SHA1;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = md5_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_NOT_SALTED
8140 | OPTI_TYPE_RAW_HASH;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 3;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 4500: hash_type = HASH_TYPE_SHA1;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_BE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS15;
8153 kern_type = KERN_TYPE_SHA11;
8154 dgst_size = DGST_SIZE_4_5;
8155 parse_func = sha1_parse_hash;
8156 sort_by_digest = sort_by_digest_4_5;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_SALTED;
8162 dgst_pos0 = 3;
8163 dgst_pos1 = 4;
8164 dgst_pos2 = 2;
8165 dgst_pos3 = 1;
8166 break;
8167
8168 case 4700: hash_type = HASH_TYPE_SHA1;
8169 salt_type = SALT_TYPE_NONE;
8170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8171 opts_type = OPTS_TYPE_PT_GENERATE_LE
8172 | OPTS_TYPE_PT_ADD80
8173 | OPTS_TYPE_PT_ADDBITS14;
8174 kern_type = KERN_TYPE_SHA1_MD5;
8175 dgst_size = DGST_SIZE_4_5;
8176 parse_func = sha1_parse_hash;
8177 sort_by_digest = sort_by_digest_4_5;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_PRECOMPUTE_INIT
8180 | OPTI_TYPE_PRECOMPUTE_MERKLE
8181 | OPTI_TYPE_EARLY_SKIP
8182 | OPTI_TYPE_NOT_ITERATED
8183 | OPTI_TYPE_NOT_SALTED
8184 | OPTI_TYPE_RAW_HASH;
8185 dgst_pos0 = 3;
8186 dgst_pos1 = 4;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 1;
8189 break;
8190
8191 case 4800: hash_type = HASH_TYPE_MD5;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_ADDBITS14;
8196 kern_type = KERN_TYPE_MD5_CHAP;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = chap_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_MEET_IN_MIDDLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 4900: hash_type = HASH_TYPE_SHA1;
8214 salt_type = SALT_TYPE_INTERN;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8217 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8218 dgst_size = DGST_SIZE_4_5;
8219 parse_func = sha1s_parse_hash;
8220 sort_by_digest = sort_by_digest_4_5;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP;
8225 dgst_pos0 = 3;
8226 dgst_pos1 = 4;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 1;
8229 break;
8230
8231 case 5000: hash_type = HASH_TYPE_KECCAK;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_LE
8235 | OPTS_TYPE_PT_ADD01;
8236 kern_type = KERN_TYPE_KECCAK;
8237 dgst_size = DGST_SIZE_8_25;
8238 parse_func = keccak_parse_hash;
8239 sort_by_digest = sort_by_digest_8_25;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 2;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 4;
8245 dgst_pos3 = 5;
8246 break;
8247
8248 case 5100: hash_type = HASH_TYPE_MD5H;
8249 salt_type = SALT_TYPE_NONE;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14;
8254 kern_type = KERN_TYPE_MD5H;
8255 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8256 parse_func = md5half_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 0;
8261 dgst_pos1 = 1;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 3;
8264 break;
8265
8266 case 5200: hash_type = HASH_TYPE_SHA256;
8267 salt_type = SALT_TYPE_EMBEDDED;
8268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8270 kern_type = KERN_TYPE_PSAFE3;
8271 dgst_size = DGST_SIZE_4_8;
8272 parse_func = psafe3_parse_hash;
8273 sort_by_digest = sort_by_digest_4_8;
8274 opti_type = OPTI_TYPE_ZERO_BYTE;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 1;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 3;
8279 break;
8280
8281 case 5300: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_ST_ADD80;
8286 kern_type = KERN_TYPE_IKEPSK_MD5;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = ikepsk_md5_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 3;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 5400: hash_type = HASH_TYPE_SHA1;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_BE
8301 | OPTS_TYPE_ST_ADD80;
8302 kern_type = KERN_TYPE_IKEPSK_SHA1;
8303 dgst_size = DGST_SIZE_4_5;
8304 parse_func = ikepsk_sha1_parse_hash;
8305 sort_by_digest = sort_by_digest_4_5;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 3;
8308 dgst_pos1 = 4;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 1;
8311 break;
8312
8313 case 5500: hash_type = HASH_TYPE_NETNTLM;
8314 salt_type = SALT_TYPE_EMBEDDED;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_PT_UNICODE
8320 | OPTS_TYPE_ST_HEX;
8321 kern_type = KERN_TYPE_NETNTLMv1;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = netntlmv1_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 1;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 3;
8331 break;
8332
8333 case 5600: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14
8339 | OPTS_TYPE_PT_UNICODE;
8340 kern_type = KERN_TYPE_NETNTLMv2;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = netntlmv2_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 5700: hash_type = HASH_TYPE_SHA256;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_BE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS15;
8357 kern_type = KERN_TYPE_SHA256;
8358 dgst_size = DGST_SIZE_4_8;
8359 parse_func = cisco4_parse_hash;
8360 sort_by_digest = sort_by_digest_4_8;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP
8365 | OPTI_TYPE_NOT_ITERATED
8366 | OPTI_TYPE_NOT_SALTED
8367 | OPTI_TYPE_RAW_HASH;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 7;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 6;
8372 break;
8373
8374 case 5800: hash_type = HASH_TYPE_SHA1;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8378 | OPTS_TYPE_ST_ADD80;
8379 kern_type = KERN_TYPE_ANDROIDPIN;
8380 dgst_size = DGST_SIZE_4_5;
8381 parse_func = androidpin_parse_hash;
8382 sort_by_digest = sort_by_digest_4_5;
8383 opti_type = OPTI_TYPE_ZERO_BYTE;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8391 salt_type = SALT_TYPE_NONE;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80;
8395 kern_type = KERN_TYPE_RIPEMD160;
8396 dgst_size = DGST_SIZE_4_5;
8397 parse_func = ripemd160_parse_hash;
8398 sort_by_digest = sort_by_digest_4_5;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_BE
8410 | OPTS_TYPE_PT_ADD80;
8411 kern_type = KERN_TYPE_WHIRLPOOL;
8412 dgst_size = DGST_SIZE_4_16;
8413 parse_func = whirlpool_parse_hash;
8414 sort_by_digest = sort_by_digest_4_16;
8415 opti_type = OPTI_TYPE_ZERO_BYTE;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 1;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 3;
8420 break;
8421
8422 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8423 salt_type = SALT_TYPE_EMBEDDED;
8424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8426 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8427 dgst_size = DGST_SIZE_4_5;
8428 parse_func = truecrypt_parse_hash_2k;
8429 sort_by_digest = sort_by_digest_4_5;
8430 opti_type = OPTI_TYPE_ZERO_BYTE;
8431 dgst_pos0 = 0;
8432 dgst_pos1 = 1;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 3;
8435 break;
8436
8437 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8438 salt_type = SALT_TYPE_EMBEDDED;
8439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8441 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8442 dgst_size = DGST_SIZE_4_5;
8443 parse_func = truecrypt_parse_hash_2k;
8444 sort_by_digest = sort_by_digest_4_5;
8445 opti_type = OPTI_TYPE_ZERO_BYTE;
8446 dgst_pos0 = 0;
8447 dgst_pos1 = 1;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 3;
8450 break;
8451
8452 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8453 salt_type = SALT_TYPE_EMBEDDED;
8454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8456 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8457 dgst_size = DGST_SIZE_4_5;
8458 parse_func = truecrypt_parse_hash_2k;
8459 sort_by_digest = sort_by_digest_4_5;
8460 opti_type = OPTI_TYPE_ZERO_BYTE;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 1;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 3;
8465 break;
8466
8467 case 6221: hash_type = HASH_TYPE_SHA512;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_TCSHA512_XTS512;
8472 dgst_size = DGST_SIZE_8_8;
8473 parse_func = truecrypt_parse_hash_1k;
8474 sort_by_digest = sort_by_digest_8_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 1;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 3;
8480 break;
8481
8482 case 6222: hash_type = HASH_TYPE_SHA512;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8486 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8487 dgst_size = DGST_SIZE_8_8;
8488 parse_func = truecrypt_parse_hash_1k;
8489 sort_by_digest = sort_by_digest_8_8;
8490 opti_type = OPTI_TYPE_ZERO_BYTE;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 1;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 3;
8495 break;
8496
8497 case 6223: hash_type = HASH_TYPE_SHA512;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8501 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8502 dgst_size = DGST_SIZE_8_8;
8503 parse_func = truecrypt_parse_hash_1k;
8504 sort_by_digest = sort_by_digest_8_8;
8505 opti_type = OPTI_TYPE_ZERO_BYTE;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 1;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 3;
8510 break;
8511
8512 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8516 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8517 dgst_size = DGST_SIZE_4_8;
8518 parse_func = truecrypt_parse_hash_1k;
8519 sort_by_digest = sort_by_digest_4_8;
8520 opti_type = OPTI_TYPE_ZERO_BYTE;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 1;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 3;
8525 break;
8526
8527 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8528 salt_type = SALT_TYPE_EMBEDDED;
8529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8531 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8532 dgst_size = DGST_SIZE_4_8;
8533 parse_func = truecrypt_parse_hash_1k;
8534 sort_by_digest = sort_by_digest_4_8;
8535 opti_type = OPTI_TYPE_ZERO_BYTE;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 1;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 3;
8540 break;
8541
8542 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8543 salt_type = SALT_TYPE_EMBEDDED;
8544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8546 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8547 dgst_size = DGST_SIZE_4_8;
8548 parse_func = truecrypt_parse_hash_1k;
8549 sort_by_digest = sort_by_digest_4_8;
8550 opti_type = OPTI_TYPE_ZERO_BYTE;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 1;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 3;
8555 break;
8556
8557 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8558 salt_type = SALT_TYPE_EMBEDDED;
8559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8561 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8562 dgst_size = DGST_SIZE_4_5;
8563 parse_func = truecrypt_parse_hash_1k;
8564 sort_by_digest = sort_by_digest_4_5;
8565 opti_type = OPTI_TYPE_ZERO_BYTE;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 1;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 3;
8570 break;
8571
8572 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8576 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8577 dgst_size = DGST_SIZE_4_5;
8578 parse_func = truecrypt_parse_hash_1k;
8579 sort_by_digest = sort_by_digest_4_5;
8580 opti_type = OPTI_TYPE_ZERO_BYTE;
8581 dgst_pos0 = 0;
8582 dgst_pos1 = 1;
8583 dgst_pos2 = 2;
8584 dgst_pos3 = 3;
8585 break;
8586
8587 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8588 salt_type = SALT_TYPE_EMBEDDED;
8589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8591 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8592 dgst_size = DGST_SIZE_4_5;
8593 parse_func = truecrypt_parse_hash_1k;
8594 sort_by_digest = sort_by_digest_4_5;
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 1;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 3;
8600 break;
8601
8602 case 6300: hash_type = HASH_TYPE_MD5;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8606 kern_type = KERN_TYPE_MD5AIX;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = md5aix_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 6400: hash_type = HASH_TYPE_SHA256;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8621 kern_type = KERN_TYPE_SHA256AIX;
8622 dgst_size = DGST_SIZE_4_8;
8623 parse_func = sha256aix_parse_hash;
8624 sort_by_digest = sort_by_digest_4_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 6500: hash_type = HASH_TYPE_SHA512;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8636 kern_type = KERN_TYPE_SHA512AIX;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = sha512aix_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 1;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 3;
8645 break;
8646
8647 case 6600: hash_type = HASH_TYPE_AES;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8651 kern_type = KERN_TYPE_AGILEKEY;
8652 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8653 parse_func = agilekey_parse_hash;
8654 sort_by_digest = sort_by_digest_4_5;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 6700: hash_type = HASH_TYPE_SHA1;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8666 kern_type = KERN_TYPE_SHA1AIX;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = sha1aix_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 6800: hash_type = HASH_TYPE_AES;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_LASTPASS;
8682 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8683 parse_func = lastpass_parse_hash;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6900: hash_type = HASH_TYPE_GOST;
8693 salt_type = SALT_TYPE_NONE;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8696 kern_type = KERN_TYPE_GOST;
8697 dgst_size = DGST_SIZE_4_8;
8698 parse_func = gost_parse_hash;
8699 sort_by_digest = sort_by_digest_4_8;
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 7100: hash_type = HASH_TYPE_SHA512;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8711 kern_type = KERN_TYPE_PBKDF2_SHA512;
8712 dgst_size = DGST_SIZE_8_16;
8713 parse_func = sha512osx_parse_hash;
8714 sort_by_digest = sort_by_digest_8_16;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 7200: hash_type = HASH_TYPE_SHA512;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8726 kern_type = KERN_TYPE_PBKDF2_SHA512;
8727 dgst_size = DGST_SIZE_8_16;
8728 parse_func = sha512grub_parse_hash;
8729 sort_by_digest = sort_by_digest_8_16;
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 7300: hash_type = HASH_TYPE_SHA1;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_ST_ADD80
8742 | OPTS_TYPE_ST_ADDBITS15;
8743 kern_type = KERN_TYPE_RAKP;
8744 dgst_size = DGST_SIZE_4_5;
8745 parse_func = rakp_parse_hash;
8746 sort_by_digest = sort_by_digest_4_5;
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_NOT_ITERATED;
8749 dgst_pos0 = 3;
8750 dgst_pos1 = 4;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 7400: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8759 kern_type = KERN_TYPE_SHA256CRYPT;
8760 dgst_size = DGST_SIZE_4_8;
8761 parse_func = sha256crypt_parse_hash;
8762 sort_by_digest = sort_by_digest_4_8;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 7500: hash_type = HASH_TYPE_KRB5PA;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8774 kern_type = KERN_TYPE_KRB5PA;
8775 dgst_size = DGST_SIZE_4_4;
8776 parse_func = krb5pa_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_NOT_ITERATED;
8780 dgst_pos0 = 3;
8781 dgst_pos1 = 7;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 6;
8784 break;
8785
8786 case 7600: hash_type = HASH_TYPE_SHA1;
8787 salt_type = SALT_TYPE_INTERN;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_BE
8790 | OPTS_TYPE_PT_ADD80
8791 | OPTS_TYPE_PT_ADDBITS15;
8792 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8793 dgst_size = DGST_SIZE_4_5;
8794 parse_func = redmine_parse_hash;
8795 sort_by_digest = sort_by_digest_4_5;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_EARLY_SKIP
8799 | OPTI_TYPE_NOT_ITERATED
8800 | OPTI_TYPE_PREPENDED_SALT;
8801 dgst_pos0 = 3;
8802 dgst_pos1 = 4;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 1;
8805 break;
8806
8807 case 7700: hash_type = HASH_TYPE_SAPB;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_UPPER
8812 | OPTS_TYPE_ST_UPPER;
8813 kern_type = KERN_TYPE_SAPB;
8814 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8815 parse_func = sapb_parse_hash;
8816 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_NOT_ITERATED;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 7800: hash_type = HASH_TYPE_SAPG;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_BE
8830 | OPTS_TYPE_ST_ADD80
8831 | OPTS_TYPE_ST_UPPER;
8832 kern_type = KERN_TYPE_SAPG;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = sapg_parse_hash;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_PRECOMPUTE_INIT
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 3;
8840 dgst_pos1 = 4;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 1;
8843 break;
8844
8845 case 7900: hash_type = HASH_TYPE_SHA512;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_DRUPAL7;
8850 dgst_size = DGST_SIZE_8_8;
8851 parse_func = drupal7_parse_hash;
8852 sort_by_digest = sort_by_digest_8_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 8000: hash_type = HASH_TYPE_SHA256;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_BE
8864 | OPTS_TYPE_PT_UNICODE
8865 | OPTS_TYPE_ST_ADD80
8866 | OPTS_TYPE_ST_HEX;
8867 kern_type = KERN_TYPE_SYBASEASE;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = sybasease_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_EARLY_SKIP
8874 | OPTI_TYPE_NOT_ITERATED
8875 | OPTI_TYPE_RAW_HASH;
8876 dgst_pos0 = 3;
8877 dgst_pos1 = 7;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 6;
8880 break;
8881
8882 case 8100: hash_type = HASH_TYPE_SHA1;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8886 kern_type = KERN_TYPE_NETSCALER;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = netscaler_parse_hash;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE
8891 | OPTI_TYPE_PRECOMPUTE_INIT
8892 | OPTI_TYPE_PRECOMPUTE_MERKLE
8893 | OPTI_TYPE_EARLY_SKIP
8894 | OPTI_TYPE_NOT_ITERATED
8895 | OPTI_TYPE_PREPENDED_SALT
8896 | OPTI_TYPE_RAW_HASH;
8897 dgst_pos0 = 3;
8898 dgst_pos1 = 4;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 1;
8901 break;
8902
8903 case 8200: hash_type = HASH_TYPE_SHA256;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_CLOUDKEY;
8908 dgst_size = DGST_SIZE_4_8;
8909 parse_func = cloudkey_parse_hash;
8910 sort_by_digest = sort_by_digest_4_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 8300: hash_type = HASH_TYPE_SHA1;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE
8922 | OPTS_TYPE_ST_HEX
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_NSEC3;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = nsec3_parse_hash;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 8400: hash_type = HASH_TYPE_SHA1;
8936 salt_type = SALT_TYPE_INTERN;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_BE
8939 | OPTS_TYPE_PT_ADD80
8940 | OPTS_TYPE_PT_ADDBITS15;
8941 kern_type = KERN_TYPE_WBB3;
8942 dgst_size = DGST_SIZE_4_5;
8943 parse_func = wbb3_parse_hash;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_INIT
8947 | OPTI_TYPE_NOT_ITERATED;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8500: hash_type = HASH_TYPE_DESRACF;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE
8958 | OPTS_TYPE_ST_UPPER;
8959 kern_type = KERN_TYPE_RACF;
8960 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8961 parse_func = racf_parse_hash;
8962 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8963 opti_type = OPTI_TYPE_ZERO_BYTE
8964 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 8600: hash_type = HASH_TYPE_LOTUS5;
8972 salt_type = SALT_TYPE_NONE;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_LOTUS5;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = lotus5_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_EARLY_SKIP
8980 | OPTI_TYPE_NOT_ITERATED
8981 | OPTI_TYPE_NOT_SALTED
8982 | OPTI_TYPE_RAW_HASH;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 8700: hash_type = HASH_TYPE_LOTUS6;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_LOTUS6;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = lotus6_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_EARLY_SKIP
8998 | OPTI_TYPE_NOT_ITERATED
8999 | OPTI_TYPE_RAW_HASH;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_ANDROIDFDE;
9011 dgst_size = DGST_SIZE_4_4;
9012 parse_func = androidfde_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 8900: hash_type = HASH_TYPE_SCRYPT;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9025 kern_type = KERN_TYPE_SCRYPT;
9026 dgst_size = DGST_SIZE_4_8;
9027 parse_func = scrypt_parse_hash;
9028 sort_by_digest = sort_by_digest_4_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 9000: hash_type = HASH_TYPE_SHA1;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE
9040 | OPTS_TYPE_ST_GENERATE_LE;
9041 kern_type = KERN_TYPE_PSAFE2;
9042 dgst_size = DGST_SIZE_4_5;
9043 parse_func = psafe2_parse_hash;
9044 sort_by_digest = sort_by_digest_4_5;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 9100: hash_type = HASH_TYPE_LOTUS8;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_LOTUS8;
9057 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9058 parse_func = lotus8_parse_hash;
9059 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 9200: hash_type = HASH_TYPE_SHA256;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_PBKDF2_SHA256;
9072 dgst_size = DGST_SIZE_4_32;
9073 parse_func = cisco8_parse_hash;
9074 sort_by_digest = sort_by_digest_4_32;
9075 opti_type = OPTI_TYPE_ZERO_BYTE;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 9300: hash_type = HASH_TYPE_SCRYPT;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9086 kern_type = KERN_TYPE_SCRYPT;
9087 dgst_size = DGST_SIZE_4_8;
9088 parse_func = cisco9_parse_hash;
9089 sort_by_digest = sort_by_digest_4_8;
9090 opti_type = OPTI_TYPE_ZERO_BYTE;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9101 kern_type = KERN_TYPE_OFFICE2007;
9102 dgst_size = DGST_SIZE_4_4;
9103 parse_func = office2007_parse_hash;
9104 sort_by_digest = sort_by_digest_4_4;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_OFFICE2010;
9117 dgst_size = DGST_SIZE_4_4;
9118 parse_func = office2010_parse_hash;
9119 sort_by_digest = sort_by_digest_4_4;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_OFFICE2013;
9132 dgst_size = DGST_SIZE_4_4;
9133 parse_func = office2013_parse_hash;
9134 sort_by_digest = sort_by_digest_4_4;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_UNICODE;
9148 kern_type = KERN_TYPE_OLDOFFICE01;
9149 dgst_size = DGST_SIZE_4_4;
9150 parse_func = oldoffice01_parse_hash;
9151 sort_by_digest = sort_by_digest_4_4;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_NOT_ITERATED;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADD80;
9166 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = oldoffice01cm1_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_NOT_ITERATED;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE
9183 | OPTS_TYPE_PT_ADD80
9184 | OPTS_TYPE_PT_UNICODE
9185 | OPTS_TYPE_PT_NEVERCRACK;
9186 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = oldoffice01cm2_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9200 salt_type = SALT_TYPE_EMBEDDED;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_BE
9203 | OPTS_TYPE_PT_ADD80
9204 | OPTS_TYPE_PT_UNICODE;
9205 kern_type = KERN_TYPE_OLDOFFICE34;
9206 dgst_size = DGST_SIZE_4_4;
9207 parse_func = oldoffice34_parse_hash;
9208 sort_by_digest = sort_by_digest_4_4;
9209 opti_type = OPTI_TYPE_ZERO_BYTE
9210 | OPTI_TYPE_PRECOMPUTE_INIT
9211 | OPTI_TYPE_NOT_ITERATED;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9222 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9223 dgst_size = DGST_SIZE_4_4;
9224 parse_func = oldoffice34cm1_parse_hash;
9225 sort_by_digest = sort_by_digest_4_4;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_BE
9239 | OPTS_TYPE_PT_ADD80
9240 | OPTS_TYPE_PT_UNICODE
9241 | OPTS_TYPE_PT_NEVERCRACK;
9242 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9243 dgst_size = DGST_SIZE_4_4;
9244 parse_func = oldoffice34cm2_parse_hash;
9245 sort_by_digest = sort_by_digest_4_4;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_NOT_ITERATED;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 9900: hash_type = HASH_TYPE_MD5;
9256 salt_type = SALT_TYPE_NONE;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9259 kern_type = KERN_TYPE_RADMIN2;
9260 dgst_size = DGST_SIZE_4_4;
9261 parse_func = radmin2_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_EARLY_SKIP
9266 | OPTI_TYPE_NOT_ITERATED
9267 | OPTI_TYPE_NOT_SALTED;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 3;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 1;
9272 break;
9273
9274 case 10000: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9278 kern_type = KERN_TYPE_PBKDF2_SHA256;
9279 dgst_size = DGST_SIZE_4_32;
9280 parse_func = djangopbkdf2_parse_hash;
9281 sort_by_digest = sort_by_digest_4_32;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 10100: hash_type = HASH_TYPE_SIPHASH;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_SIPHASH;
9294 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9295 parse_func = siphash_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED
9299 | OPTI_TYPE_RAW_HASH;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 10200: hash_type = HASH_TYPE_MD5;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE
9310 | OPTS_TYPE_ST_ADD80
9311 | OPTS_TYPE_ST_ADDBITS14;
9312 kern_type = KERN_TYPE_HMACMD5_PW;
9313 dgst_size = DGST_SIZE_4_4;
9314 parse_func = crammd5_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_NOT_ITERATED;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 3;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 10300: hash_type = HASH_TYPE_SHA1;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9328 kern_type = KERN_TYPE_SAPH_SHA1;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = saph_sha1_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 10400: hash_type = HASH_TYPE_PDFU16;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_PDF11;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = pdf11_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_NOT_ITERATED;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 10410: hash_type = HASH_TYPE_PDFU16;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_PDF11CM1;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = pdf11cm1_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 10420: hash_type = HASH_TYPE_PDFU16;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9375 kern_type = KERN_TYPE_PDF11CM2;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = pdf11cm2_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_NOT_ITERATED;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 10500: hash_type = HASH_TYPE_PDFU16;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_PDF14;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = pdf14_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_ZERO_BYTE
9396 | OPTI_TYPE_NOT_ITERATED;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 10600: hash_type = HASH_TYPE_SHA256;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_BE
9407 | OPTS_TYPE_ST_ADD80
9408 | OPTS_TYPE_ST_ADDBITS15
9409 | OPTS_TYPE_HASH_COPY;
9410 kern_type = KERN_TYPE_SHA256_PWSLT;
9411 dgst_size = DGST_SIZE_4_8;
9412 parse_func = pdf17l3_parse_hash;
9413 sort_by_digest = sort_by_digest_4_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_PRECOMPUTE_INIT
9416 | OPTI_TYPE_PRECOMPUTE_MERKLE
9417 | OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_APPENDED_SALT
9420 | OPTI_TYPE_RAW_HASH;
9421 dgst_pos0 = 3;
9422 dgst_pos1 = 7;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 6;
9425 break;
9426
9427 case 10700: hash_type = HASH_TYPE_PDFU32;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_HASH_COPY;
9432 kern_type = KERN_TYPE_PDF17L8;
9433 dgst_size = DGST_SIZE_4_8;
9434 parse_func = pdf17l8_parse_hash;
9435 sort_by_digest = sort_by_digest_4_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_NOT_ITERATED;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 10800: hash_type = HASH_TYPE_SHA384;
9445 salt_type = SALT_TYPE_NONE;
9446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_BE
9448 | OPTS_TYPE_PT_ADD80
9449 | OPTS_TYPE_PT_ADDBITS15;
9450 kern_type = KERN_TYPE_SHA384;
9451 dgst_size = DGST_SIZE_8_8;
9452 parse_func = sha384_parse_hash;
9453 sort_by_digest = sort_by_digest_8_8;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_PRECOMPUTE_MERKLE
9457 | OPTI_TYPE_EARLY_SKIP
9458 | OPTI_TYPE_NOT_ITERATED
9459 | OPTI_TYPE_NOT_SALTED
9460 | OPTI_TYPE_RAW_HASH;
9461 dgst_pos0 = 6;
9462 dgst_pos1 = 7;
9463 dgst_pos2 = 4;
9464 dgst_pos3 = 5;
9465 break;
9466
9467 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_ST_BASE64
9472 | OPTS_TYPE_HASH_COPY;
9473 kern_type = KERN_TYPE_PBKDF2_SHA256;
9474 dgst_size = DGST_SIZE_4_32;
9475 parse_func = pbkdf2_sha256_parse_hash;
9476 sort_by_digest = sort_by_digest_4_32;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 11000: hash_type = HASH_TYPE_MD5;
9485 salt_type = SALT_TYPE_INTERN;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80;
9489 kern_type = KERN_TYPE_PRESTASHOP;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = prestashop_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_NOT_ITERATED
9496 | OPTI_TYPE_PREPENDED_SALT;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 3;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 1;
9501 break;
9502
9503 case 11100: hash_type = HASH_TYPE_MD5;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_ST_ADD80;
9508 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = postgresql_auth_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_PRECOMPUTE_MERKLE
9515 | OPTI_TYPE_EARLY_SKIP;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 3;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 11200: hash_type = HASH_TYPE_SHA1;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_BE
9526 | OPTS_TYPE_PT_ADD80
9527 | OPTS_TYPE_ST_HEX;
9528 kern_type = KERN_TYPE_MYSQL_AUTH;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = mysql_auth_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_EARLY_SKIP;
9534 dgst_pos0 = 3;
9535 dgst_pos1 = 4;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 1;
9538 break;
9539
9540 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_HEX
9545 | OPTS_TYPE_ST_ADD80;
9546 kern_type = KERN_TYPE_BITCOIN_WALLET;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = bitcoin_wallet_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 11400: hash_type = HASH_TYPE_MD5;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE
9561 | OPTS_TYPE_PT_ADD80
9562 | OPTS_TYPE_HASH_COPY;
9563 kern_type = KERN_TYPE_SIP_AUTH;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = sip_auth_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 3;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 1;
9572 break;
9573
9574 case 11500: hash_type = HASH_TYPE_CRC32;
9575 salt_type = SALT_TYPE_INTERN;
9576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_ST_GENERATE_LE
9579 | OPTS_TYPE_ST_HEX;
9580 kern_type = KERN_TYPE_CRC32;
9581 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9582 parse_func = crc32_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9584 opti_type = OPTI_TYPE_ZERO_BYTE;
9585 dgst_pos0 = 0;
9586 dgst_pos1 = 1;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 3;
9589 break;
9590
9591 case 11600: hash_type = HASH_TYPE_AES;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_PT_NEVERCRACK;
9596 kern_type = KERN_TYPE_SEVEN_ZIP;
9597 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9598 parse_func = seven_zip_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9600 opti_type = OPTI_TYPE_ZERO_BYTE;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9608 salt_type = SALT_TYPE_NONE;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE
9611 | OPTS_TYPE_PT_ADD01;
9612 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9613 dgst_size = DGST_SIZE_4_8;
9614 parse_func = gost2012sbog_256_parse_hash;
9615 sort_by_digest = sort_by_digest_4_8;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9624 salt_type = SALT_TYPE_NONE;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE
9627 | OPTS_TYPE_PT_ADD01;
9628 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9629 dgst_size = DGST_SIZE_4_16;
9630 parse_func = gost2012sbog_512_parse_hash;
9631 sort_by_digest = sort_by_digest_4_16;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE
9643 | OPTS_TYPE_ST_BASE64
9644 | OPTS_TYPE_HASH_COPY;
9645 kern_type = KERN_TYPE_PBKDF2_MD5;
9646 dgst_size = DGST_SIZE_4_32;
9647 parse_func = pbkdf2_md5_parse_hash;
9648 sort_by_digest = sort_by_digest_4_32;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE
9660 | OPTS_TYPE_ST_BASE64
9661 | OPTS_TYPE_HASH_COPY;
9662 kern_type = KERN_TYPE_PBKDF2_SHA1;
9663 dgst_size = DGST_SIZE_4_32;
9664 parse_func = pbkdf2_sha1_parse_hash;
9665 sort_by_digest = sort_by_digest_4_32;
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_ST_BASE64
9678 | OPTS_TYPE_HASH_COPY;
9679 kern_type = KERN_TYPE_PBKDF2_SHA512;
9680 dgst_size = DGST_SIZE_8_16;
9681 parse_func = pbkdf2_sha512_parse_hash;
9682 sort_by_digest = sort_by_digest_8_16;
9683 opti_type = OPTI_TYPE_ZERO_BYTE;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9694 kern_type = KERN_TYPE_ECRYPTFS;
9695 dgst_size = DGST_SIZE_8_8;
9696 parse_func = ecryptfs_parse_hash;
9697 sort_by_digest = sort_by_digest_8_8;
9698 opti_type = OPTI_TYPE_ZERO_BYTE;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 12300: hash_type = HASH_TYPE_ORACLET;
9706 salt_type = SALT_TYPE_EMBEDDED;
9707 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9708 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9709 kern_type = KERN_TYPE_ORACLET;
9710 dgst_size = DGST_SIZE_8_16;
9711 parse_func = oraclet_parse_hash;
9712 sort_by_digest = sort_by_digest_8_16;
9713 opti_type = OPTI_TYPE_ZERO_BYTE;
9714 dgst_pos0 = 0;
9715 dgst_pos1 = 1;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 3;
9718 break;
9719
9720 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9724 kern_type = KERN_TYPE_BSDICRYPT;
9725 dgst_size = DGST_SIZE_4_4;
9726 parse_func = bsdicrypt_parse_hash;
9727 sort_by_digest = sort_by_digest_4_4;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 12500: hash_type = HASH_TYPE_RAR3HP;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9740 kern_type = KERN_TYPE_RAR3;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = rar3hp_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 12600: hash_type = HASH_TYPE_SHA256;
9752 salt_type = SALT_TYPE_INTERN;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_PT_ADD80;
9756 kern_type = KERN_TYPE_CF10;
9757 dgst_size = DGST_SIZE_4_8;
9758 parse_func = cf10_parse_hash;
9759 sort_by_digest = sort_by_digest_4_8;
9760 opti_type = OPTI_TYPE_ZERO_BYTE
9761 | OPTI_TYPE_PRECOMPUTE_INIT
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 3;
9765 dgst_pos1 = 7;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 6;
9768 break;
9769
9770 case 12700: hash_type = HASH_TYPE_AES;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE
9774 | OPTS_TYPE_HASH_COPY;
9775 kern_type = KERN_TYPE_MYWALLET;
9776 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9777 parse_func = mywallet_parse_hash;
9778 sort_by_digest = sort_by_digest_4_5;
9779 opti_type = OPTI_TYPE_ZERO_BYTE;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_MS_DRSR;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = ms_drsr_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9805 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9806 dgst_size = DGST_SIZE_4_8;
9807 parse_func = androidfde_samsung_parse_hash;
9808 sort_by_digest = sort_by_digest_4_8;
9809 opti_type = OPTI_TYPE_ZERO_BYTE;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 1;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 3;
9814 break;
9815
9816 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9820 kern_type = KERN_TYPE_RAR5;
9821 dgst_size = DGST_SIZE_4_4;
9822 parse_func = rar5_parse_hash;
9823 sort_by_digest = sort_by_digest_4_4;
9824 opti_type = OPTI_TYPE_ZERO_BYTE;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 default: usage_mini_print (PROGNAME); return (-1);
9832 }
9833
9834 /**
9835 * transpose
9836 */
9837
9838 data.parse_func = parse_func;
9839
9840 /**
9841 * misc stuff
9842 */
9843
9844 if (hex_salt)
9845 {
9846 if (salt_type == SALT_TYPE_INTERN)
9847 {
9848 opts_type |= OPTS_TYPE_ST_HEX;
9849 }
9850 else
9851 {
9852 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9853
9854 return (-1);
9855 }
9856 }
9857
9858 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9859 | (salt_type == SALT_TYPE_EXTERN)
9860 | (salt_type == SALT_TYPE_EMBEDDED)
9861 | (salt_type == SALT_TYPE_VIRTUAL));
9862
9863 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9864
9865 data.hash_type = hash_type;
9866 data.attack_mode = attack_mode;
9867 data.attack_kern = attack_kern;
9868 data.attack_exec = attack_exec;
9869 data.kern_type = kern_type;
9870 data.opts_type = opts_type;
9871 data.dgst_size = dgst_size;
9872 data.salt_type = salt_type;
9873 data.isSalted = isSalted;
9874 data.sort_by_digest = sort_by_digest;
9875 data.dgst_pos0 = dgst_pos0;
9876 data.dgst_pos1 = dgst_pos1;
9877 data.dgst_pos2 = dgst_pos2;
9878 data.dgst_pos3 = dgst_pos3;
9879
9880 esalt_size = 0;
9881
9882 switch (hash_mode)
9883 {
9884 case 2500: esalt_size = sizeof (wpa_t); break;
9885 case 5300: esalt_size = sizeof (ikepsk_t); break;
9886 case 5400: esalt_size = sizeof (ikepsk_t); break;
9887 case 5500: esalt_size = sizeof (netntlm_t); break;
9888 case 5600: esalt_size = sizeof (netntlm_t); break;
9889 case 6211:
9890 case 6212:
9891 case 6213:
9892 case 6221:
9893 case 6222:
9894 case 6223:
9895 case 6231:
9896 case 6232:
9897 case 6233:
9898 case 6241:
9899 case 6242:
9900 case 6243: esalt_size = sizeof (tc_t); break;
9901 case 6600: esalt_size = sizeof (agilekey_t); break;
9902 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9903 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9904 case 7300: esalt_size = sizeof (rakp_t); break;
9905 case 7500: esalt_size = sizeof (krb5pa_t); break;
9906 case 8200: esalt_size = sizeof (cloudkey_t); break;
9907 case 8800: esalt_size = sizeof (androidfde_t); break;
9908 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9909 case 9400: esalt_size = sizeof (office2007_t); break;
9910 case 9500: esalt_size = sizeof (office2010_t); break;
9911 case 9600: esalt_size = sizeof (office2013_t); break;
9912 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9913 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9914 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9915 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9916 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9917 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9918 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9919 case 10200: esalt_size = sizeof (cram_md5_t); break;
9920 case 10400: esalt_size = sizeof (pdf_t); break;
9921 case 10410: esalt_size = sizeof (pdf_t); break;
9922 case 10420: esalt_size = sizeof (pdf_t); break;
9923 case 10500: esalt_size = sizeof (pdf_t); break;
9924 case 10600: esalt_size = sizeof (pdf_t); break;
9925 case 10700: esalt_size = sizeof (pdf_t); break;
9926 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9927 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9928 case 11400: esalt_size = sizeof (sip_t); break;
9929 case 11600: esalt_size = sizeof (seven_zip_t); break;
9930 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9931 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9932 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9933 case 13000: esalt_size = sizeof (rar5_t); break;
9934 }
9935
9936 data.esalt_size = esalt_size;
9937
9938 /**
9939 * choose dictionary parser
9940 */
9941
9942 if (hash_type == HASH_TYPE_LM)
9943 {
9944 get_next_word_func = get_next_word_lm;
9945 }
9946 else if (opts_type & OPTS_TYPE_PT_UPPER)
9947 {
9948 get_next_word_func = get_next_word_uc;
9949 }
9950 else
9951 {
9952 get_next_word_func = get_next_word_std;
9953 }
9954
9955 /**
9956 * dictstat
9957 */
9958
9959 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9960
9961 #ifdef _POSIX
9962 size_t dictstat_nmemb = 0;
9963 #endif
9964
9965 #ifdef _WIN
9966 uint dictstat_nmemb = 0;
9967 #endif
9968
9969 char dictstat[256];
9970
9971 FILE *dictstat_fp = NULL;
9972
9973 if (keyspace == 0)
9974 {
9975 memset (dictstat, 0, sizeof (dictstat));
9976
9977 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9978
9979 dictstat_fp = fopen (dictstat, "rb");
9980
9981 if (dictstat_fp)
9982 {
9983 #ifdef _POSIX
9984 struct stat tmpstat;
9985
9986 fstat (fileno (dictstat_fp), &tmpstat);
9987 #endif
9988
9989 #ifdef _WIN
9990 struct stat64 tmpstat;
9991
9992 _fstat64 (fileno (dictstat_fp), &tmpstat);
9993 #endif
9994
9995 if (tmpstat.st_mtime < COMPTIME)
9996 {
9997 /* with v0.15 the format changed so we have to ensure user is using a good version
9998 since there is no version-header in the dictstat file */
9999
10000 fclose (dictstat_fp);
10001
10002 unlink (dictstat);
10003 }
10004 else
10005 {
10006 while (!feof (dictstat_fp))
10007 {
10008 dictstat_t d;
10009
10010 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10011
10012 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10013
10014 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10015 {
10016 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10017
10018 return -1;
10019 }
10020 }
10021
10022 fclose (dictstat_fp);
10023 }
10024 }
10025 }
10026
10027 /**
10028 * potfile
10029 */
10030
10031 char potfile[256];
10032
10033 memset (potfile, 0, sizeof (potfile));
10034
10035 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10036
10037 data.pot_fp = NULL;
10038
10039 FILE *out_fp = NULL;
10040 FILE *pot_fp = NULL;
10041
10042 if (show == 1 || left == 1)
10043 {
10044 pot_fp = fopen (potfile, "rb");
10045
10046 if (pot_fp == NULL)
10047 {
10048 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10049
10050 return (-1);
10051 }
10052
10053 if (outfile != NULL)
10054 {
10055 if ((out_fp = fopen (outfile, "ab")) == NULL)
10056 {
10057 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10058
10059 fclose (pot_fp);
10060
10061 return (-1);
10062 }
10063 }
10064 else
10065 {
10066 out_fp = stdout;
10067 }
10068 }
10069 else
10070 {
10071 if (potfile_disable == 0)
10072 {
10073 pot_fp = fopen (potfile, "ab");
10074
10075 if (pot_fp == NULL)
10076 {
10077 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10078
10079 return (-1);
10080 }
10081
10082 data.pot_fp = pot_fp;
10083 }
10084 }
10085
10086 pot_t *pot = NULL;
10087
10088 uint pot_cnt = 0;
10089 uint pot_avail = 0;
10090
10091 if (show == 1 || left == 1)
10092 {
10093 SUPPRESS_OUTPUT = 1;
10094
10095 pot_avail = count_lines (pot_fp);
10096
10097 rewind (pot_fp);
10098
10099 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10100
10101 uint pot_hashes_avail = 0;
10102
10103 uint line_num = 0;
10104
10105 while (!feof (pot_fp))
10106 {
10107 line_num++;
10108
10109 char line_buf[BUFSIZ];
10110
10111 int line_len = fgetl (pot_fp, line_buf);
10112
10113 if (line_len == 0) continue;
10114
10115 char *plain_buf = line_buf + line_len;
10116
10117 pot_t *pot_ptr = &pot[pot_cnt];
10118
10119 hash_t *hashes_buf = &pot_ptr->hash;
10120
10121 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10122 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10123
10124 if (pot_cnt == pot_hashes_avail)
10125 {
10126 uint pos = 0;
10127
10128 for (pos = 0; pos < INCR_POT; pos++)
10129 {
10130 if ((pot_cnt + pos) >= pot_avail) break;
10131
10132 pot_t *tmp_pot = &pot[pot_cnt + pos];
10133
10134 hash_t *tmp_hash = &tmp_pot->hash;
10135
10136 tmp_hash->digest = mymalloc (dgst_size);
10137
10138 if (isSalted)
10139 {
10140 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10141 }
10142
10143 if (esalt_size)
10144 {
10145 tmp_hash->esalt = mymalloc (esalt_size);
10146 }
10147
10148 pot_hashes_avail++;
10149 }
10150 }
10151
10152 int plain_len = 0;
10153
10154 int parser_status;
10155
10156 int iter = MAX_CUT_TRIES;
10157
10158 do
10159 {
10160 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10161 {
10162 if (line_buf[i] == ':')
10163 {
10164 line_len--;
10165
10166 break;
10167 }
10168 }
10169
10170 if (data.hash_mode != 2500)
10171 {
10172 parser_status = parse_func (line_buf, line_len, hashes_buf);
10173 }
10174 else
10175 {
10176 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10177
10178 if (line_len > max_salt_size)
10179 {
10180 parser_status = PARSER_GLOBAL_LENGTH;
10181 }
10182 else
10183 {
10184 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10185
10186 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10187
10188 hashes_buf->salt->salt_len = line_len;
10189
10190 parser_status = PARSER_OK;
10191 }
10192 }
10193
10194 // if NOT parsed without error, we add the ":" to the plain
10195
10196 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10197 {
10198 plain_len++;
10199 plain_buf--;
10200 }
10201
10202 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10203
10204 if (parser_status < PARSER_GLOBAL_ZERO)
10205 {
10206 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10207
10208 continue;
10209 }
10210
10211 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10212
10213 pot_ptr->plain_len = plain_len;
10214
10215 pot_cnt++;
10216 }
10217
10218 fclose (pot_fp);
10219
10220 SUPPRESS_OUTPUT = 0;
10221
10222 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10223 }
10224
10225 /**
10226 * kernel accel and loops auto adjustment
10227 */
10228
10229 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10230 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10231
10232 if (workload_profile == 1)
10233 {
10234 kernel_loops /= 8;
10235 kernel_accel /= 4;
10236
10237 if (kernel_loops == 0) kernel_loops = 8;
10238 if (kernel_accel == 0) kernel_accel = 2;
10239 }
10240 else if (workload_profile == 3)
10241 {
10242 kernel_loops *= 8;
10243 kernel_accel *= 4;
10244
10245 if (kernel_loops > 1024) kernel_loops = 1024;
10246 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10247 }
10248
10249 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10250
10251 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10252 {
10253 kernel_loops = 1024;
10254 }
10255
10256 if (hash_mode == 12500)
10257 {
10258 kernel_loops = ROUNDS_RAR3 / 16;
10259 }
10260
10261 data.kernel_accel = kernel_accel;
10262 data.kernel_loops = kernel_loops;
10263
10264 /**
10265 * word len
10266 */
10267
10268 uint pw_min = PW_MIN;
10269 uint pw_max = PW_MAX;
10270
10271 switch (hash_mode)
10272 {
10273 case 400: if (pw_max > 40) pw_max = 40;
10274 break;
10275 case 500: if (pw_max > 16) pw_max = 16;
10276 break;
10277 case 1500: if (pw_max > 8) pw_max = 8;
10278 break;
10279 case 1600: if (pw_max > 16) pw_max = 16;
10280 break;
10281 case 1800: if (pw_max > 16) pw_max = 16;
10282 break;
10283 case 2100: if (pw_max > 16) pw_max = 16;
10284 break;
10285 case 2500: if (pw_min < 8) pw_min = 8;
10286 break;
10287 case 3000: if (pw_max > 7) pw_max = 7;
10288 break;
10289 case 5200: if (pw_max > 24) pw_max = 24;
10290 break;
10291 case 5800: if (pw_max > 16) pw_max = 16;
10292 break;
10293 case 6300: if (pw_max > 16) pw_max = 16;
10294 break;
10295 case 7400: if (pw_max > 16) pw_max = 16;
10296 break;
10297 case 7900: if (pw_max > 48) pw_max = 48;
10298 break;
10299 case 8500: if (pw_max > 8) pw_max = 8;
10300 break;
10301 case 8600: if (pw_max > 16) pw_max = 16;
10302 break;
10303 case 9710: pw_min = 5;
10304 pw_max = 5;
10305 break;
10306 case 9810: pw_min = 5;
10307 pw_max = 5;
10308 break;
10309 case 10410: pw_min = 5;
10310 pw_max = 5;
10311 break;
10312 case 10300: if (pw_max < 3) pw_min = 3;
10313 if (pw_max > 40) pw_max = 40;
10314 break;
10315 case 10500: if (pw_max < 3) pw_min = 3;
10316 if (pw_max > 40) pw_max = 40;
10317 break;
10318 case 10700: if (pw_max > 16) pw_max = 16;
10319 break;
10320 case 11300: if (pw_max > 40) pw_max = 40;
10321 break;
10322 case 12500: if (pw_max > 20) pw_max = 20;
10323 break;
10324 case 12800: if (pw_max > 24) pw_max = 24;
10325 break;
10326 }
10327
10328 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10329 {
10330 switch (attack_kern)
10331 {
10332 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10333 break;
10334 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10335 break;
10336 }
10337 }
10338
10339 /**
10340 * charsets : keep them together for more easy maintainnce
10341 */
10342
10343 cs_t mp_sys[6];
10344 cs_t mp_usr[4];
10345
10346 memset (mp_sys, 0, sizeof (mp_sys));
10347 memset (mp_usr, 0, sizeof (mp_usr));
10348
10349 mp_setup_sys (mp_sys);
10350
10351 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10352 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10353 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10354 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10355
10356 /**
10357 * load hashes, part I: find input mode, count hashes
10358 */
10359
10360 uint hashlist_mode = 0;
10361 uint hashlist_format = HLFMT_HASHCAT;
10362
10363 uint hashes_avail = 0;
10364
10365 if (benchmark == 0)
10366 {
10367 struct stat f;
10368
10369 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10370
10371 if ((hash_mode == 2500) ||
10372 (hash_mode == 5200) ||
10373 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10374 (hash_mode == 9000))
10375 {
10376 hashlist_mode = HL_MODE_ARG;
10377
10378 char *hashfile = myargv[optind];
10379
10380 data.hashfile = hashfile;
10381
10382 logfile_top_var_string ("target", hashfile);
10383 }
10384
10385 if (hashlist_mode == HL_MODE_ARG)
10386 {
10387 if (hash_mode == 2500)
10388 {
10389 struct stat st;
10390
10391 if (stat (data.hashfile, &st) == -1)
10392 {
10393 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10394
10395 return (-1);
10396 }
10397
10398 hashes_avail = st.st_size / sizeof (hccap_t);
10399 }
10400 else
10401 {
10402 hashes_avail = 1;
10403 }
10404 }
10405 else if (hashlist_mode == HL_MODE_FILE)
10406 {
10407 char *hashfile = myargv[optind];
10408
10409 data.hashfile = hashfile;
10410
10411 logfile_top_var_string ("target", hashfile);
10412
10413 FILE *fp = NULL;
10414
10415 if ((fp = fopen (hashfile, "rb")) == NULL)
10416 {
10417 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10418
10419 return (-1);
10420 }
10421
10422 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10423
10424 hashes_avail = count_lines (fp);
10425
10426 rewind (fp);
10427
10428 if (hashes_avail == 0)
10429 {
10430 log_error ("ERROR: hashfile is empty or corrupt");
10431
10432 fclose (fp);
10433
10434 return (-1);
10435 }
10436
10437 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10438
10439 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10440 {
10441 log_error ("ERROR: remove not supported in native hashfile-format mode");
10442
10443 fclose (fp);
10444
10445 return (-1);
10446 }
10447
10448 fclose (fp);
10449 }
10450 }
10451 else
10452 {
10453 hashlist_mode = HL_MODE_ARG;
10454
10455 hashes_avail = 1;
10456 }
10457
10458 if (hash_mode == 3000) hashes_avail *= 2;
10459
10460 data.hashlist_mode = hashlist_mode;
10461 data.hashlist_format = hashlist_format;
10462
10463 logfile_top_uint (hashlist_mode);
10464 logfile_top_uint (hashlist_format);
10465
10466 /**
10467 * load hashes, part II: allocate required memory, set pointers
10468 */
10469
10470 hash_t *hashes_buf = NULL;
10471 void *digests_buf = NULL;
10472 salt_t *salts_buf = NULL;
10473 void *esalts_buf = NULL;
10474
10475 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10476
10477 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10478
10479 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10480 {
10481 uint32_t hash_pos;
10482
10483 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10484 {
10485 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10486
10487 hashes_buf[hash_pos].hash_info = hash_info;
10488
10489 if (username && (remove || show || left))
10490 {
10491 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10492 }
10493
10494 if (benchmark)
10495 {
10496 hash_info->orighash = (char *) mymalloc (256);
10497 }
10498 }
10499 }
10500
10501 if (isSalted)
10502 {
10503 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10504
10505 if (esalt_size)
10506 {
10507 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10508 }
10509 }
10510 else
10511 {
10512 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10513 }
10514
10515 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10516 {
10517 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10518
10519 if (isSalted)
10520 {
10521 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10522
10523 if (esalt_size)
10524 {
10525 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10526 }
10527 }
10528 else
10529 {
10530 hashes_buf[hash_pos].salt = &salts_buf[0];
10531 }
10532 }
10533
10534 /**
10535 * load hashes, part III: parse hashes or generate them if benchmark
10536 */
10537
10538 uint hashes_cnt = 0;
10539
10540 if (benchmark == 0)
10541 {
10542 if (keyspace == 1)
10543 {
10544 // useless to read hash file for keyspace, cheat a little bit w/ optind
10545 }
10546 else if (hashes_avail == 0)
10547 {
10548 }
10549 else if (hashlist_mode == HL_MODE_ARG)
10550 {
10551 char *input_buf = myargv[optind];
10552
10553 uint input_len = strlen (input_buf);
10554
10555 logfile_top_var_string ("target", input_buf);
10556
10557 char *hash_buf = NULL;
10558 int hash_len = 0;
10559
10560 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10561
10562 if (hash_len)
10563 {
10564 if (opts_type & OPTS_TYPE_HASH_COPY)
10565 {
10566 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10567
10568 hash_info_tmp->orighash = mystrdup (hash_buf);
10569 }
10570
10571 if (isSalted)
10572 {
10573 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10574 }
10575
10576 int parser_status = PARSER_OK;
10577
10578 if (hash_mode == 2500)
10579 {
10580 if (hash_len == 0)
10581 {
10582 log_error ("ERROR: hccap file not specified");
10583
10584 return (-1);
10585 }
10586
10587 hashlist_mode = HL_MODE_FILE;
10588
10589 data.hashlist_mode = hashlist_mode;
10590
10591 FILE *fp = fopen (hash_buf, "rb");
10592
10593 if (fp == NULL)
10594 {
10595 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10596
10597 return (-1);
10598 }
10599
10600 if (hashes_avail < 1)
10601 {
10602 log_error ("ERROR: hccap file is empty or corrupt");
10603
10604 fclose (fp);
10605
10606 return (-1);
10607 }
10608
10609 uint hccap_size = sizeof (hccap_t);
10610
10611 char in[hccap_size];
10612
10613 while (!feof (fp))
10614 {
10615 int n = fread (&in, hccap_size, 1, fp);
10616
10617 if (n != 1)
10618 {
10619 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10620
10621 break;
10622 }
10623
10624 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10625
10626 if (parser_status != PARSER_OK)
10627 {
10628 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10629
10630 continue;
10631 }
10632
10633 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10634
10635 if ((show == 1) || (left == 1))
10636 {
10637 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10638
10639 char *salt_ptr = (char *) tmp_salt->salt_buf;
10640
10641 int cur_pos = tmp_salt->salt_len;
10642 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10643
10644 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10645
10646 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10647
10648 // do the appending task
10649
10650 snprintf (salt_ptr + cur_pos,
10651 rem_len,
10652 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10653 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10654 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10655
10656
10657 // memset () the remaining part of the salt
10658
10659 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10660 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10661
10662 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10663
10664 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10665 }
10666
10667 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);
10668 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);
10669
10670 hashes_cnt++;
10671 }
10672
10673 fclose (fp);
10674 }
10675 else if (hash_mode == 3000)
10676 {
10677 if (hash_len == 32)
10678 {
10679 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10680
10681 hash_t *lm_hash_left = NULL;
10682
10683 if (parser_status == PARSER_OK)
10684 {
10685 lm_hash_left = &hashes_buf[hashes_cnt];
10686
10687 hashes_cnt++;
10688 }
10689 else
10690 {
10691 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10692 }
10693
10694
10695 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10696
10697 hash_t *lm_hash_right = NULL;
10698
10699 if (parser_status == PARSER_OK)
10700 {
10701 lm_hash_right = &hashes_buf[hashes_cnt];
10702
10703 hashes_cnt++;
10704 }
10705 else
10706 {
10707 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10708 }
10709
10710 // show / left
10711
10712 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10713 {
10714 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);
10715 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);
10716 }
10717 }
10718 else
10719 {
10720 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10721
10722 if (parser_status == PARSER_OK)
10723 {
10724 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10725 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10726 }
10727
10728 if (parser_status == PARSER_OK)
10729 {
10730 hashes_cnt++;
10731 }
10732 else
10733 {
10734 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10735 }
10736 }
10737 }
10738 else
10739 {
10740 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10741
10742 if (parser_status == PARSER_OK)
10743 {
10744 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10745 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10746 }
10747
10748 if (parser_status == PARSER_OK)
10749 {
10750 hashes_cnt++;
10751 }
10752 else
10753 {
10754 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10755 }
10756 }
10757 }
10758 }
10759 else if (hashlist_mode == HL_MODE_FILE)
10760 {
10761 char *hashfile = data.hashfile;
10762
10763 FILE *fp;
10764
10765 if ((fp = fopen (hashfile, "rb")) == NULL)
10766 {
10767 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10768
10769 return (-1);
10770 }
10771
10772 uint line_num = 0;
10773
10774 while (!feof (fp))
10775 {
10776 line_num++;
10777
10778 char line_buf[BUFSIZ];
10779
10780 int line_len = fgetl (fp, line_buf);
10781
10782 if (line_len == 0) continue;
10783
10784 char *hash_buf = NULL;
10785 int hash_len = 0;
10786
10787 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10788
10789 if (username)
10790 {
10791 char *user_buf = NULL;
10792 int user_len = 0;
10793
10794 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10795
10796 if (remove || show)
10797 {
10798 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10799
10800 *user = (user_t *) malloc (sizeof (user_t));
10801
10802 user_t *user_ptr = *user;
10803
10804 if (user_buf != NULL)
10805 {
10806 user_ptr->user_name = mystrdup (user_buf);
10807 }
10808 else
10809 {
10810 user_ptr->user_name = mystrdup ("");
10811 }
10812
10813 user_ptr->user_len = user_len;
10814 }
10815 }
10816
10817 if (opts_type & OPTS_TYPE_HASH_COPY)
10818 {
10819 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10820
10821 hash_info_tmp->orighash = mystrdup (hash_buf);
10822 }
10823
10824 if (isSalted)
10825 {
10826 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10827 }
10828
10829 if (hash_mode == 3000)
10830 {
10831 if (hash_len == 32)
10832 {
10833 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10834
10835 if (parser_status < PARSER_GLOBAL_ZERO)
10836 {
10837 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10838
10839 continue;
10840 }
10841
10842 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10843
10844 hashes_cnt++;
10845
10846 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10847
10848 if (parser_status < PARSER_GLOBAL_ZERO)
10849 {
10850 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10851
10852 continue;
10853 }
10854
10855 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10856
10857 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);
10858
10859 hashes_cnt++;
10860
10861 // show / left
10862
10863 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);
10864 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);
10865 }
10866 else
10867 {
10868 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10869
10870 if (parser_status < PARSER_GLOBAL_ZERO)
10871 {
10872 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10873
10874 continue;
10875 }
10876
10877 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);
10878
10879 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10880 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10881
10882 hashes_cnt++;
10883 }
10884 }
10885 else
10886 {
10887 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10888
10889 if (parser_status < PARSER_GLOBAL_ZERO)
10890 {
10891 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10892
10893 continue;
10894 }
10895
10896 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);
10897
10898 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10899 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10900
10901 hashes_cnt++;
10902 }
10903 }
10904
10905 fclose (fp);
10906
10907 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10908
10909 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10910 }
10911 }
10912 else
10913 {
10914 if (isSalted)
10915 {
10916 hashes_buf[0].salt->salt_len = 8;
10917
10918 // special salt handling
10919
10920 switch (hash_mode)
10921 {
10922 case 1500: hashes_buf[0].salt->salt_len = 2;
10923 break;
10924 case 1731: hashes_buf[0].salt->salt_len = 4;
10925 break;
10926 case 2410: hashes_buf[0].salt->salt_len = 4;
10927 break;
10928 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10929 break;
10930 case 3100: hashes_buf[0].salt->salt_len = 1;
10931 break;
10932 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10933 break;
10934 case 5800: hashes_buf[0].salt->salt_len = 16;
10935 break;
10936 case 6800: hashes_buf[0].salt->salt_len = 32;
10937 break;
10938 case 8400: hashes_buf[0].salt->salt_len = 40;
10939 break;
10940 case 8800: hashes_buf[0].salt->salt_len = 16;
10941 break;
10942 case 8900: hashes_buf[0].salt->salt_len = 16;
10943 hashes_buf[0].salt->scrypt_N = 1024;
10944 hashes_buf[0].salt->scrypt_r = 1;
10945 hashes_buf[0].salt->scrypt_p = 1;
10946 break;
10947 case 9100: hashes_buf[0].salt->salt_len = 16;
10948 break;
10949 case 9300: hashes_buf[0].salt->salt_len = 14;
10950 hashes_buf[0].salt->scrypt_N = 16384;
10951 hashes_buf[0].salt->scrypt_r = 1;
10952 hashes_buf[0].salt->scrypt_p = 1;
10953 break;
10954 case 9400: hashes_buf[0].salt->salt_len = 16;
10955 break;
10956 case 9500: hashes_buf[0].salt->salt_len = 16;
10957 break;
10958 case 9600: hashes_buf[0].salt->salt_len = 16;
10959 break;
10960 case 9700: hashes_buf[0].salt->salt_len = 16;
10961 break;
10962 case 9710: hashes_buf[0].salt->salt_len = 16;
10963 break;
10964 case 9720: hashes_buf[0].salt->salt_len = 16;
10965 break;
10966 case 9800: hashes_buf[0].salt->salt_len = 16;
10967 break;
10968 case 9810: hashes_buf[0].salt->salt_len = 16;
10969 break;
10970 case 9820: hashes_buf[0].salt->salt_len = 16;
10971 break;
10972 case 10300: hashes_buf[0].salt->salt_len = 12;
10973 break;
10974 case 11500: hashes_buf[0].salt->salt_len = 4;
10975 break;
10976 case 11600: hashes_buf[0].salt->salt_len = 4;
10977 break;
10978 case 12400: hashes_buf[0].salt->salt_len = 4;
10979 break;
10980 case 12500: hashes_buf[0].salt->salt_len = 8;
10981 break;
10982 case 12600: hashes_buf[0].salt->salt_len = 64;
10983 break;
10984 }
10985
10986 // special esalt handling
10987
10988 switch (hash_mode)
10989 {
10990 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10991 break;
10992 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10993 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10994 break;
10995 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10996 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10997 break;
10998 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10999 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11000 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11001 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11002 break;
11003 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11004 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11005 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11006 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11007 break;
11008 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11009 break;
11010 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11011 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11012 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11013 break;
11014 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11015 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11016 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11017 break;
11018 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11019 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11020 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11021 break;
11022 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11023 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11024 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11025 break;
11026 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11027 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11028 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11029 break;
11030 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11031 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11032 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11033 break;
11034 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11035 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11036 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11037 break;
11038 }
11039 }
11040
11041 // set hashfile
11042
11043 switch (hash_mode)
11044 {
11045 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11046 break;
11047 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11048 break;
11049 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11050 break;
11051 case 6211:
11052 case 6212:
11053 case 6213:
11054 case 6221:
11055 case 6222:
11056 case 6223:
11057 case 6231:
11058 case 6232:
11059 case 6233:
11060 case 6241:
11061 case 6242:
11062 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11063 break;
11064 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11065 break;
11066 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11067 break;
11068 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11069 break;
11070 }
11071
11072 // set default iterations
11073
11074 switch (hash_mode)
11075 {
11076 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11077 break;
11078 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11079 break;
11080 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11081 break;
11082 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11083 break;
11084 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11085 break;
11086 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11087 break;
11088 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11089 break;
11090 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11091 break;
11092 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11093 break;
11094 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11095 break;
11096 case 6211:
11097 case 6212:
11098 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11099 break;
11100 case 6221:
11101 case 6222:
11102 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11103 break;
11104 case 6231:
11105 case 6232:
11106 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11107 break;
11108 case 6241:
11109 case 6242:
11110 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11111 break;
11112 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11113 break;
11114 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11115 break;
11116 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11117 break;
11118 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11119 break;
11120 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11121 break;
11122 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11123 break;
11124 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11125 break;
11126 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11127 break;
11128 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11129 break;
11130 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11131 break;
11132 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11133 break;
11134 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11135 break;
11136 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11137 break;
11138 case 8900: hashes_buf[0].salt->salt_iter = 1;
11139 break;
11140 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11141 break;
11142 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11143 break;
11144 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11145 break;
11146 case 9300: hashes_buf[0].salt->salt_iter = 1;
11147 break;
11148 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11149 break;
11150 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11151 break;
11152 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11153 break;
11154 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11155 break;
11156 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11157 break;
11158 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11159 break;
11160 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11161 break;
11162 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11163 break;
11164 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11165 break;
11166 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11167 break;
11168 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11169 break;
11170 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11171 break;
11172 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11173 break;
11174 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11175 break;
11176 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11177 break;
11178 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11179 break;
11180 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11181 break;
11182 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11183 break;
11184 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11185 break;
11186 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11187 break;
11188 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11189 break;
11190 }
11191
11192 // set special tuning for benchmark-mode 1
11193
11194 if (benchmark_mode == 1)
11195 {
11196 kernel_loops *= 8;
11197 kernel_accel *= 4;
11198
11199 switch (hash_mode)
11200 {
11201 case 400: kernel_loops = ROUNDS_PHPASS;
11202 kernel_accel = 32;
11203 break;
11204 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11205 kernel_accel = 32;
11206 break;
11207 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11208 kernel_accel = 32;
11209 break;
11210 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11211 kernel_accel = 32;
11212 break;
11213 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11214 kernel_accel = 16;
11215 break;
11216 case 2100: kernel_loops = ROUNDS_DCC2;
11217 kernel_accel = 16;
11218 break;
11219 case 2500: kernel_loops = ROUNDS_WPA2;
11220 kernel_accel = 32;
11221 break;
11222 case 3200: kernel_loops = ROUNDS_BCRYPT;
11223 kernel_accel = 8;
11224 break;
11225 case 5200: kernel_loops = ROUNDS_PSAFE3;
11226 kernel_accel = 16;
11227 break;
11228 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11229 kernel_accel = 16;
11230 break;
11231 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11232 kernel_accel = 64;
11233 break;
11234 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11235 kernel_accel = 32;
11236 break;
11237 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11238 kernel_accel = 32;
11239 break;
11240 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11241 kernel_accel = 8;
11242 break;
11243 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11244 kernel_accel = 8;
11245 break;
11246 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11247 kernel_accel = 8;
11248 break;
11249 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11250 kernel_accel = 8;
11251 break;
11252 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11253 kernel_accel = 8;
11254 break;
11255 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11256 kernel_accel = 8;
11257 break;
11258 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11259 kernel_accel = 128;
11260 break;
11261 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11262 kernel_accel = 64;
11263 break;
11264 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11265 kernel_accel = 64;
11266 break;
11267 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11268 kernel_accel = 32;
11269 break;
11270 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11271 kernel_accel = 128;
11272 break;
11273 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11274 kernel_accel = 128;
11275 break;
11276 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11277 kernel_accel = 32;
11278 break;
11279 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11280 kernel_accel = 64;
11281 break;
11282 case 6800: kernel_loops = ROUNDS_LASTPASS;
11283 kernel_accel = 64;
11284 break;
11285 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11286 kernel_accel = 8;
11287 break;
11288 case 7200: kernel_loops = ROUNDS_GRUB;
11289 kernel_accel = 16;
11290 break;
11291 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11292 kernel_accel = 8;
11293 break;
11294 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11295 kernel_accel = 8;
11296 break;
11297 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11298 kernel_accel = 8;
11299 break;
11300 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11301 kernel_accel = 32;
11302 break;
11303 case 8900: kernel_loops = 1;
11304 kernel_accel = 64;
11305 break;
11306 case 9000: kernel_loops = ROUNDS_PSAFE2;
11307 kernel_accel = 16;
11308 break;
11309 case 9100: kernel_loops = ROUNDS_LOTUS8;
11310 kernel_accel = 64;
11311 break;
11312 case 9200: kernel_loops = ROUNDS_CISCO8;
11313 kernel_accel = 8;
11314 break;
11315 case 9300: kernel_loops = 1;
11316 kernel_accel = 4;
11317 break;
11318 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11319 kernel_accel = 32;
11320 break;
11321 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11322 kernel_accel = 32;
11323 break;
11324 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11325 kernel_accel = 8;
11326 break;
11327 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11328 kernel_accel = 8;
11329 break;
11330 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11331 kernel_accel = 16;
11332 break;
11333 case 10500: kernel_loops = ROUNDS_PDF14;
11334 kernel_accel = 256;
11335 break;
11336 case 10700: kernel_loops = ROUNDS_PDF17L8;
11337 kernel_accel = 8;
11338 break;
11339 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11340 kernel_accel = 8;
11341 break;
11342 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11343 kernel_accel = 8;
11344 break;
11345 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11346 kernel_accel = 8;
11347 break;
11348 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11349 kernel_accel = 8;
11350 break;
11351 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11352 kernel_accel = 8;
11353 break;
11354 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11355 kernel_accel = 8;
11356 break;
11357 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11358 kernel_accel = 8;
11359 break;
11360 case 12300: kernel_loops = ROUNDS_ORACLET;
11361 kernel_accel = 8;
11362 break;
11363 case 12500: kernel_loops = ROUNDS_RAR3;
11364 kernel_accel = 32;
11365 break;
11366 case 12700: kernel_loops = ROUNDS_MYWALLET;
11367 kernel_accel = 512;
11368 break;
11369 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11370 kernel_accel = 512;
11371 break;
11372 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11373 kernel_accel = 8;
11374 break;
11375 case 13000: kernel_loops = ROUNDS_RAR5;
11376 kernel_accel = 8;
11377 break;
11378 }
11379
11380 // some algorithm collide too fast, make that impossible
11381
11382 switch (hash_mode)
11383 {
11384 case 11500: ((uint *) digests_buf)[1] = 1;
11385 break;
11386 }
11387
11388 if (kernel_loops > 1024) kernel_loops = 1024;
11389 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11390 }
11391
11392 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11393 {
11394 kernel_loops = 1024;
11395 }
11396
11397 if (hash_mode == 12500)
11398 {
11399 kernel_loops = ROUNDS_RAR3 / 16;
11400 }
11401
11402 data.kernel_accel = kernel_accel;
11403 data.kernel_loops = kernel_loops;
11404
11405 hashes_cnt = 1;
11406 }
11407
11408 if (show == 1 || left == 1)
11409 {
11410 for (uint i = 0; i < pot_cnt; i++)
11411 {
11412 pot_t *pot_ptr = &pot[i];
11413
11414 hash_t *hashes_buf = &pot_ptr->hash;
11415
11416 local_free (hashes_buf->digest);
11417
11418 if (isSalted)
11419 {
11420 local_free (hashes_buf->salt);
11421 }
11422 }
11423
11424 local_free (pot);
11425
11426 if (data.quiet == 0) log_info_nn ("");
11427
11428 return (0);
11429 }
11430
11431 if (keyspace == 0)
11432 {
11433 if (hashes_cnt == 0)
11434 {
11435 log_error ("ERROR: No hashes loaded");
11436
11437 return (-1);
11438 }
11439 }
11440
11441 /**
11442 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11443 */
11444
11445 if (data.outfile != NULL)
11446 {
11447 if (data.hashfile != NULL)
11448 {
11449 #ifdef _POSIX
11450 struct stat tmpstat_outfile;
11451 struct stat tmpstat_hashfile;
11452 #endif
11453
11454 #ifdef _WIN
11455 struct stat64 tmpstat_outfile;
11456 struct stat64 tmpstat_hashfile;
11457 #endif
11458
11459 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11460
11461 if (tmp_outfile_fp)
11462 {
11463 #ifdef _POSIX
11464 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11465 #endif
11466
11467 #ifdef _WIN
11468 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11469 #endif
11470
11471 fclose (tmp_outfile_fp);
11472 }
11473
11474 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11475
11476 if (tmp_hashfile_fp)
11477 {
11478 #ifdef _POSIX
11479 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11480 #endif
11481
11482 #ifdef _WIN
11483 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11484 #endif
11485
11486 fclose (tmp_hashfile_fp);
11487 }
11488
11489 if (tmp_outfile_fp && tmp_outfile_fp)
11490 {
11491 tmpstat_outfile.st_mode = 0;
11492 tmpstat_outfile.st_nlink = 0;
11493 tmpstat_outfile.st_uid = 0;
11494 tmpstat_outfile.st_gid = 0;
11495 tmpstat_outfile.st_rdev = 0;
11496 tmpstat_outfile.st_atime = 0;
11497
11498 tmpstat_hashfile.st_mode = 0;
11499 tmpstat_hashfile.st_nlink = 0;
11500 tmpstat_hashfile.st_uid = 0;
11501 tmpstat_hashfile.st_gid = 0;
11502 tmpstat_hashfile.st_rdev = 0;
11503 tmpstat_hashfile.st_atime = 0;
11504
11505 #ifdef _POSIX
11506 tmpstat_outfile.st_blksize = 0;
11507 tmpstat_outfile.st_blocks = 0;
11508
11509 tmpstat_hashfile.st_blksize = 0;
11510 tmpstat_hashfile.st_blocks = 0;
11511 #endif
11512
11513 #ifdef _POSIX
11514 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11515 {
11516 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11517
11518 return (-1);
11519 }
11520 #endif
11521
11522 #ifdef _WIN
11523 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11524 {
11525 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11526
11527 return (-1);
11528 }
11529 #endif
11530 }
11531 }
11532 }
11533
11534 /**
11535 * Remove duplicates
11536 */
11537
11538 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11539
11540 if (isSalted)
11541 {
11542 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11543 }
11544 else
11545 {
11546 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11547 }
11548
11549 uint hashes_cnt_orig = hashes_cnt;
11550
11551 hashes_cnt = 1;
11552
11553 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11554 {
11555 if (isSalted)
11556 {
11557 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11558 {
11559 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11560 }
11561 }
11562 else
11563 {
11564 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11565 }
11566
11567 if (hashes_pos > hashes_cnt)
11568 {
11569 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11570 }
11571
11572 hashes_cnt++;
11573 }
11574
11575 /**
11576 * Potfile removes
11577 */
11578
11579 uint potfile_remove_cracks = 0;
11580
11581 if (potfile_disable == 0)
11582 {
11583 hash_t hash_buf;
11584
11585 hash_buf.digest = mymalloc (dgst_size);
11586 hash_buf.salt = NULL;
11587 hash_buf.esalt = NULL;
11588 hash_buf.hash_info = NULL;
11589 hash_buf.cracked = 0;
11590
11591 if (isSalted)
11592 {
11593 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11594 }
11595
11596 if (esalt_size)
11597 {
11598 hash_buf.esalt = mymalloc (esalt_size);
11599 }
11600
11601 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11602
11603 // no solution for these special hash types (for instane because they use hashfile in output etc)
11604 if ((hash_mode != 5200) &&
11605 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11606 (hash_mode != 9000))
11607 {
11608 FILE *fp = fopen (potfile, "rb");
11609
11610 if (fp != NULL)
11611 {
11612 while (!feof (fp))
11613 {
11614 char line_buf[BUFSIZ];
11615
11616 memset (line_buf, 0, BUFSIZ);
11617
11618 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11619
11620 if (ptr == NULL) break;
11621
11622 int line_len = strlen (line_buf);
11623
11624 if (line_len == 0) continue;
11625
11626 int iter = MAX_CUT_TRIES;
11627
11628 for (int i = line_len - 1; i && iter; i--, line_len--)
11629 {
11630 if (line_buf[i] != ':') continue;
11631
11632 if (isSalted)
11633 {
11634 memset (hash_buf.salt, 0, sizeof (salt_t));
11635 }
11636
11637 hash_t *found = NULL;
11638
11639 if (hash_mode == 6800)
11640 {
11641 if (i < 48) // 48 = 12 * uint in salt_buf[]
11642 {
11643 // manipulate salt_buf
11644 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11645
11646 hash_buf.salt->salt_len = i;
11647
11648 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11649 }
11650 }
11651 else if (hash_mode == 2500)
11652 {
11653 if (i < 48) // 48 = 12 * uint in salt_buf[]
11654 {
11655 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11656 // manipulate salt_buf
11657
11658 // to be safe work with a copy (because of line_len loop, i etc)
11659
11660 char line_buf_cpy[BUFSIZ];
11661 memset (line_buf_cpy, 0, BUFSIZ);
11662
11663 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11664
11665 memcpy (line_buf_cpy, line_buf, i);
11666
11667 char *mac2_pos = strrchr (line_buf_cpy, ':');
11668
11669 if (mac2_pos == NULL) continue;
11670
11671 mac2_pos[0] = 0;
11672 mac2_pos++;
11673
11674 if (strlen (mac2_pos) != 12) continue;
11675
11676 char *mac1_pos = strrchr (line_buf_cpy, ':');
11677
11678 if (mac1_pos == NULL) continue;
11679
11680 mac1_pos[0] = 0;
11681 mac1_pos++;
11682
11683 if (strlen (mac1_pos) != 12) continue;
11684
11685 uint essid_length = mac1_pos - line_buf_cpy - 1;
11686
11687 // here we need the ESSID
11688 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11689
11690 hash_buf.salt->salt_len = essid_length;
11691
11692 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11693
11694 if (found)
11695 {
11696 wpa_t *wpa = (wpa_t *) found->esalt;
11697
11698 uint pke[25];
11699
11700 char *pke_ptr = (char *) pke;
11701
11702 for (uint i = 0; i < 25; i++)
11703 {
11704 pke[i] = byte_swap_32 (wpa->pke[i]);
11705 }
11706
11707 unsigned char mac1[6];
11708 unsigned char mac2[6];
11709
11710 memcpy (mac1, pke_ptr + 23, 6);
11711 memcpy (mac2, pke_ptr + 29, 6);
11712
11713 // compare hex string(s) vs binary MAC address(es)
11714
11715 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11716 {
11717 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11718 {
11719 found = NULL;
11720 break;
11721 }
11722 }
11723
11724 // early skip ;)
11725 if (!found) continue;
11726
11727 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11728 {
11729 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11730 {
11731 found = NULL;
11732 break;
11733 }
11734 }
11735 }
11736 }
11737 }
11738 else
11739 {
11740 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11741
11742 if (parser_status == PARSER_OK)
11743 {
11744 if (isSalted)
11745 {
11746 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11747 }
11748 else
11749 {
11750 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11751 }
11752 }
11753 }
11754
11755 if (found == NULL) continue;
11756
11757 if (!found->cracked) potfile_remove_cracks++;
11758
11759 found->cracked = 1;
11760
11761 if (found) break;
11762
11763 iter--;
11764 }
11765 }
11766
11767 fclose (fp);
11768 }
11769 }
11770
11771 if (esalt_size)
11772 {
11773 local_free (hash_buf.esalt);
11774 }
11775
11776 if (isSalted)
11777 {
11778 local_free (hash_buf.salt);
11779 }
11780
11781 local_free (hash_buf.digest);
11782 }
11783
11784 /**
11785 * Now generate all the buffers required for later
11786 */
11787
11788 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11789
11790 salt_t *salts_buf_new = NULL;
11791 void *esalts_buf_new = NULL;
11792
11793 if (isSalted)
11794 {
11795 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11796
11797 if (esalt_size)
11798 {
11799 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11800 }
11801 }
11802 else
11803 {
11804 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11805 }
11806
11807 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11808
11809 uint digests_cnt = hashes_cnt;
11810 uint digests_done = 0;
11811
11812 uint size_digests = digests_cnt * dgst_size;
11813 uint size_shown = digests_cnt * sizeof (uint);
11814
11815 uint *digests_shown = (uint *) mymalloc (size_shown);
11816 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11817
11818 uint salts_cnt = 0;
11819 uint salts_done = 0;
11820
11821 hashinfo_t **hash_info = NULL;
11822
11823 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11824 {
11825 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11826
11827 if (username && (remove || show))
11828 {
11829 uint user_pos;
11830
11831 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11832 {
11833 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11834
11835 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11836 }
11837 }
11838 }
11839
11840 uint *salts_shown = (uint *) mymalloc (size_shown);
11841
11842 salt_t *salt_buf;
11843
11844 {
11845 // copied from inner loop
11846
11847 salt_buf = &salts_buf_new[salts_cnt];
11848
11849 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11850
11851 if (esalt_size)
11852 {
11853 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11854 }
11855
11856 salt_buf->digests_cnt = 0;
11857 salt_buf->digests_done = 0;
11858 salt_buf->digests_offset = 0;
11859
11860 salts_cnt++;
11861 }
11862
11863 if (hashes_buf[0].cracked == 1)
11864 {
11865 digests_shown[0] = 1;
11866
11867 digests_done++;
11868
11869 salt_buf->digests_done++;
11870 }
11871
11872 salt_buf->digests_cnt++;
11873
11874 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11875
11876 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11877 {
11878 hash_info[0] = hashes_buf[0].hash_info;
11879 }
11880
11881 // copy from inner loop
11882
11883 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11884 {
11885 if (isSalted)
11886 {
11887 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11888 {
11889 salt_buf = &salts_buf_new[salts_cnt];
11890
11891 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11892
11893 if (esalt_size)
11894 {
11895 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11896 }
11897
11898 salt_buf->digests_cnt = 0;
11899 salt_buf->digests_done = 0;
11900 salt_buf->digests_offset = hashes_pos;
11901
11902 salts_cnt++;
11903 }
11904 }
11905
11906 if (hashes_buf[hashes_pos].cracked == 1)
11907 {
11908 digests_shown[hashes_pos] = 1;
11909
11910 digests_done++;
11911
11912 salt_buf->digests_done++;
11913 }
11914
11915 salt_buf->digests_cnt++;
11916
11917 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11918
11919 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11920 {
11921 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11922 }
11923 }
11924
11925 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11926 {
11927 salt_t *salt_buf = &salts_buf_new[salt_pos];
11928
11929 if (salt_buf->digests_done == salt_buf->digests_cnt)
11930 {
11931 salts_shown[salt_pos] = 1;
11932
11933 salts_done++;
11934 }
11935
11936 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11937 }
11938
11939 local_free (digests_buf);
11940 local_free (salts_buf);
11941 local_free (esalts_buf);
11942
11943 digests_buf = digests_buf_new;
11944 salts_buf = salts_buf_new;
11945 esalts_buf = esalts_buf_new;
11946
11947 local_free (hashes_buf);
11948
11949 /**
11950 * special modification not set from parser
11951 */
11952
11953 switch (hash_mode)
11954 {
11955 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11956 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11957 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11958 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11959 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11960 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11961 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11962 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11963 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11964 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11965 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11966 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11967 }
11968
11969 if (truecrypt_keyfiles)
11970 {
11971 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11972
11973 char *keyfiles = strdup (truecrypt_keyfiles);
11974
11975 char *keyfile = strtok (keyfiles, ",");
11976
11977 do
11978 {
11979 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11980
11981 } while ((keyfile = strtok (NULL, ",")) != NULL);
11982
11983 free (keyfiles);
11984 }
11985
11986 data.digests_cnt = digests_cnt;
11987 data.digests_done = digests_done;
11988 data.digests_buf = digests_buf;
11989 data.digests_shown = digests_shown;
11990 data.digests_shown_tmp = digests_shown_tmp;
11991
11992 data.salts_cnt = salts_cnt;
11993 data.salts_done = salts_done;
11994 data.salts_buf = salts_buf;
11995 data.salts_shown = salts_shown;
11996
11997 data.esalts_buf = esalts_buf;
11998 data.hash_info = hash_info;
11999
12000 /**
12001 * Automatic Optimizers
12002 */
12003
12004 if (salts_cnt == 1)
12005 opti_type |= OPTI_TYPE_SINGLE_SALT;
12006
12007 if (digests_cnt == 1)
12008 opti_type |= OPTI_TYPE_SINGLE_HASH;
12009
12010 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12011 opti_type |= OPTI_TYPE_NOT_ITERATED;
12012
12013 if (attack_mode == ATTACK_MODE_BF)
12014 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12015
12016 data.opti_type = opti_type;
12017
12018 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12019 {
12020 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12021 {
12022 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12023 {
12024 if (opts_type & OPTS_TYPE_ST_ADD80)
12025 {
12026 opts_type &= ~OPTS_TYPE_ST_ADD80;
12027 opts_type |= OPTS_TYPE_PT_ADD80;
12028 }
12029
12030 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12031 {
12032 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12033 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12034 }
12035
12036 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12037 {
12038 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12039 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12040 }
12041 }
12042 }
12043 }
12044
12045 /**
12046 * Some algorithm, like descrypt, can benefit from JIT compilation
12047 */
12048
12049 uint force_jit_compilation = 0;
12050
12051 if (hash_mode == 8900)
12052 {
12053 force_jit_compilation = 8900;
12054 }
12055 else if (hash_mode == 9300)
12056 {
12057 force_jit_compilation = 8900;
12058 }
12059 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12060 {
12061 force_jit_compilation = 1500;
12062 }
12063
12064 /**
12065 * generate bitmap tables
12066 */
12067
12068 const uint bitmap_shift1 = 5;
12069 const uint bitmap_shift2 = 13;
12070
12071 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12072
12073 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12074 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12075 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12076 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12077 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12078 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12079 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12080 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12081
12082 uint bitmap_bits;
12083 uint bitmap_nums;
12084 uint bitmap_mask;
12085 uint bitmap_size;
12086
12087 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12088 {
12089 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12090
12091 bitmap_nums = 1 << bitmap_bits;
12092
12093 bitmap_mask = bitmap_nums - 1;
12094
12095 bitmap_size = bitmap_nums * sizeof (uint);
12096
12097 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12098
12099 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;
12100 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;
12101
12102 break;
12103 }
12104
12105 bitmap_nums = 1 << bitmap_bits;
12106
12107 bitmap_mask = bitmap_nums - 1;
12108
12109 bitmap_size = bitmap_nums * sizeof (uint);
12110
12111 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);
12112 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);
12113
12114 /**
12115 * prepare quick rule
12116 */
12117
12118 data.rule_buf_l = rule_buf_l;
12119 data.rule_buf_r = rule_buf_r;
12120
12121 int rule_len_l = (int) strlen (rule_buf_l);
12122 int rule_len_r = (int) strlen (rule_buf_r);
12123
12124 data.rule_len_l = rule_len_l;
12125 data.rule_len_r = rule_len_r;
12126
12127 /**
12128 * load rules
12129 */
12130
12131 uint *all_kernel_rules_cnt = NULL;
12132
12133 kernel_rule_t **all_kernel_rules_buf = NULL;
12134
12135 if (rp_files_cnt)
12136 {
12137 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12138
12139 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12140 }
12141
12142 char rule_buf[BUFSIZ];
12143
12144 int rule_len = 0;
12145
12146 for (uint i = 0; i < rp_files_cnt; i++)
12147 {
12148 uint kernel_rules_avail = 0;
12149
12150 uint kernel_rules_cnt = 0;
12151
12152 kernel_rule_t *kernel_rules_buf = NULL;
12153
12154 char *rp_file = rp_files[i];
12155
12156 char in[BLOCK_SIZE];
12157 char out[BLOCK_SIZE];
12158
12159 FILE *fp = NULL;
12160
12161 uint rule_line = 0;
12162
12163 if ((fp = fopen (rp_file, "rb")) == NULL)
12164 {
12165 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12166
12167 return (-1);
12168 }
12169
12170 while (!feof (fp))
12171 {
12172 memset (rule_buf, 0, BUFSIZ);
12173
12174 rule_len = fgetl (fp, rule_buf);
12175
12176 rule_line++;
12177
12178 if (rule_len == 0) continue;
12179
12180 if (rule_buf[0] == '#') continue;
12181
12182 if (kernel_rules_avail == kernel_rules_cnt)
12183 {
12184 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12185
12186 kernel_rules_avail += INCR_RULES;
12187 }
12188
12189 memset (in, 0, BLOCK_SIZE);
12190 memset (out, 0, BLOCK_SIZE);
12191
12192 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12193
12194 if (result == -1)
12195 {
12196 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12197
12198 continue;
12199 }
12200
12201 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12202 {
12203 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12204
12205 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12206
12207 continue;
12208 }
12209
12210 /* its so slow
12211 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12212 {
12213 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12214
12215 continue;
12216 }
12217 */
12218
12219 kernel_rules_cnt++;
12220 }
12221
12222 fclose (fp);
12223
12224 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12225
12226 all_kernel_rules_buf[i] = kernel_rules_buf;
12227 }
12228
12229 /**
12230 * merge rules or automatic rule generator
12231 */
12232
12233 uint kernel_rules_cnt = 0;
12234
12235 kernel_rule_t *kernel_rules_buf = NULL;
12236
12237 if (attack_mode == ATTACK_MODE_STRAIGHT)
12238 {
12239 if (rp_files_cnt)
12240 {
12241 kernel_rules_cnt = 1;
12242
12243 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12244
12245 repeats[0] = kernel_rules_cnt;
12246
12247 for (uint i = 0; i < rp_files_cnt; i++)
12248 {
12249 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12250
12251 repeats[i + 1] = kernel_rules_cnt;
12252 }
12253
12254 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12255
12256 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12257
12258 for (uint i = 0; i < kernel_rules_cnt; i++)
12259 {
12260 uint out_pos = 0;
12261
12262 kernel_rule_t *out = &kernel_rules_buf[i];
12263
12264 for (uint j = 0; j < rp_files_cnt; j++)
12265 {
12266 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12267 uint in_pos;
12268
12269 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12270
12271 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12272 {
12273 if (out_pos == RULES_MAX - 1)
12274 {
12275 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12276
12277 break;
12278 }
12279
12280 out->cmds[out_pos] = in->cmds[in_pos];
12281 }
12282 }
12283 }
12284
12285 local_free (repeats);
12286 }
12287 else if (rp_gen)
12288 {
12289 uint kernel_rules_avail = 0;
12290
12291 while (kernel_rules_cnt < rp_gen)
12292 {
12293 if (kernel_rules_avail == kernel_rules_cnt)
12294 {
12295 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12296
12297 kernel_rules_avail += INCR_RULES;
12298 }
12299
12300 memset (rule_buf, 0, BLOCK_SIZE);
12301
12302 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12303
12304 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12305
12306 kernel_rules_cnt++;
12307 }
12308 }
12309 }
12310
12311 /**
12312 * generate NOP rules
12313 */
12314
12315 if (kernel_rules_cnt == 0)
12316 {
12317 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12318
12319 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12320
12321 kernel_rules_cnt++;
12322 }
12323
12324 data.kernel_rules_cnt = kernel_rules_cnt;
12325 data.kernel_rules_buf = kernel_rules_buf;
12326
12327 /**
12328 * platform
12329 */
12330
12331 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12332
12333 uint CL_platforms_cnt = 0;
12334
12335 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12336
12337 if (CL_platforms_cnt == 0)
12338 {
12339 log_error ("ERROR: No OpenCL compatible platform found");
12340
12341 return (-1);
12342 }
12343
12344 int CL_platform_sel = 1;
12345
12346 if (opencl_platform != NULL)
12347 {
12348 CL_platform_sel = atoi (opencl_platform);
12349 }
12350
12351 if (CL_platforms_cnt > 1)
12352 {
12353 if (opencl_platform == NULL)
12354 {
12355 log_error ("ERROR: Too many OpenCL compatible platforms found");
12356
12357 log_info ("Please select a single platform using the --opencl-platform option");
12358 log_info ("");
12359 log_info ("Available OpenCL platforms:");
12360 log_info ("");
12361
12362 for (uint i = 0; i < CL_platforms_cnt; i++)
12363 {
12364 char CL_platform_vendor[INFOSZ];
12365
12366 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12367
12368 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12369
12370 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12371 }
12372
12373 log_info ("");
12374
12375 return (-1);
12376 }
12377 else
12378 {
12379 if (CL_platform_sel < 1)
12380 {
12381 log_error ("ERROR: --opencl-platform < 1");
12382
12383 return (-1);
12384 }
12385
12386 if (CL_platform_sel > (int) CL_platforms_cnt)
12387 {
12388 log_error ("ERROR: invalid OpenCL platforms selected");
12389
12390 return (-1);
12391 }
12392 }
12393 }
12394 else
12395 {
12396 if (CL_platform_sel != 1)
12397 {
12398 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12399
12400 return (-1);
12401 }
12402 }
12403
12404 // zero-indexed: not starting to count at 1, as user does
12405
12406 CL_platform_sel -= 1;
12407
12408
12409 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12410
12411 char CL_platform_vendor[INFOSZ];
12412
12413 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12414
12415 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12416
12417 cl_device_type device_type_filter;
12418
12419 uint vendor_id;
12420
12421 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12422 {
12423 vendor_id = VENDOR_ID_AMD;
12424
12425 device_type_filter = CL_DEVICE_TYPE_GPU;
12426 }
12427 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12428 {
12429 vendor_id = VENDOR_ID_NV;
12430
12431 device_type_filter = CL_DEVICE_TYPE_GPU;
12432
12433 // make sure that we do not directly control the fan for NVidia
12434
12435 gpu_temp_retain = 0;
12436
12437 data.gpu_temp_retain = gpu_temp_retain;
12438 }
12439 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12440 {
12441 if (force == 0)
12442 {
12443 log_error ("");
12444 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12445 log_error ("You are STRONGLY encouraged not to use it");
12446 log_error ("You can use --force to override this but do not post error reports if you do so");
12447
12448 return (-1);
12449 }
12450
12451 vendor_id = VENDOR_ID_GENERIC;
12452
12453 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12454 }
12455 else
12456 {
12457 vendor_id = VENDOR_ID_GENERIC;
12458
12459 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12460 }
12461
12462 if (vendor_id == VENDOR_ID_GENERIC)
12463 {
12464 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12465
12466 gpu_temp_disable = 1;
12467 }
12468
12469 data.vendor_id = vendor_id;
12470
12471 /**
12472 * cached kernel path depends on vendor_id which we don't know, so create it here
12473 */
12474
12475 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12476
12477 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12478
12479 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12480
12481 mkdir (vendor_id_folder, 0700);
12482
12483 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12484
12485 mkdir (vendor_id_folder, 0700);
12486
12487 myfree (vendor_id_folder);
12488
12489 /**
12490 * devices
12491 */
12492
12493 cl_device_id devices_all[DEVICES_MAX];
12494 cl_device_id devices[DEVICES_MAX];
12495
12496 uint devices_all_cnt = 0;
12497
12498 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12499
12500 int hm_adapters_all = devices_all_cnt;
12501
12502 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12503
12504 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12505
12506 if (gpu_temp_disable == 0)
12507 {
12508 if (vendor_id == VENDOR_ID_NV)
12509 {
12510 #ifdef LINUX
12511 HM_LIB hm_dll = hm_init ();
12512
12513 data.hm_dll = hm_dll;
12514
12515 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12516 {
12517 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12518
12519 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12520
12521 int tmp_out = 0;
12522
12523 for (int i = 0; i < tmp_in; i++)
12524 {
12525 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12526 }
12527
12528 hm_adapters_all = tmp_out;
12529
12530 for (int i = 0; i < tmp_out; i++)
12531 {
12532 unsigned int speed;
12533
12534 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll, 1, hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12535 }
12536 }
12537 #endif
12538
12539 #ifdef WIN
12540 if (NvAPI_Initialize () == NVAPI_OK)
12541 {
12542 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12543
12544 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12545
12546 int tmp_out = 0;
12547
12548 for (int i = 0; i < tmp_in; i++)
12549 {
12550 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12551 }
12552
12553 hm_adapters_all = tmp_out;
12554
12555 for (int i = 0; i < tmp_out; i++)
12556 {
12557 NvU32 speed;
12558
12559 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12560 }
12561 }
12562 #endif
12563 }
12564
12565 if (vendor_id == VENDOR_ID_AMD)
12566 {
12567 HM_LIB hm_dll = hm_init ();
12568
12569 data.hm_dll = hm_dll;
12570
12571 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12572 {
12573 // total number of adapters
12574
12575 int hm_adapters_num;
12576
12577 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12578
12579 // adapter info
12580
12581 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12582
12583 if (lpAdapterInfo == NULL) return (-1);
12584
12585 // get a list (of ids of) valid/usable adapters
12586
12587 int num_adl_adapters = 0;
12588
12589 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12590
12591 if (num_adl_adapters > 0)
12592 {
12593 hc_thread_mutex_lock (mux_adl);
12594
12595 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12596
12597 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12598
12599 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12600 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12601
12602 hc_thread_mutex_unlock (mux_adl);
12603 }
12604
12605 hm_adapters_all = num_adl_adapters;
12606
12607 myfree (valid_adl_device_list);
12608 myfree (lpAdapterInfo);
12609 }
12610 }
12611 }
12612
12613 if (hm_adapters_all == 0)
12614 {
12615 gpu_temp_disable = 1;
12616 }
12617
12618 if (gpu_temp_disable == 1)
12619 {
12620 gpu_temp_abort = 0;
12621 gpu_temp_retain = 0;
12622 }
12623
12624 /**
12625 * enable custom signal handler(s)
12626 */
12627
12628 if (benchmark == 0)
12629 {
12630 hc_signal (sigHandler_default);
12631 }
12632 else
12633 {
12634 hc_signal (sigHandler_benchmark);
12635 }
12636
12637 /**
12638 * devices mask and properties
12639 */
12640
12641 uint hm_adapter_index = 0;
12642
12643 uint devices_cnt = 0;
12644
12645 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12646 {
12647 const uint device_id = devices_cnt;
12648
12649 devices[device_id] = devices_all[device_all_id];
12650
12651 cl_device_type device_type;
12652
12653 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12654
12655 // skip the device, if the user did specify a list of GPUs to skip
12656
12657 if (opencl_devicemask)
12658 {
12659 uint device_all_id_mask = 1 << device_all_id;
12660
12661 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12662 {
12663 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12664
12665 if (device_type & CL_DEVICE_TYPE_GPU) hm_adapter_index++;
12666
12667 continue;
12668 }
12669 }
12670
12671 char device_name[INFOSZ];
12672
12673 memset (device_name, 0, sizeof (device_name));
12674
12675 cl_ulong global_mem_size;
12676 cl_ulong max_mem_alloc_size;
12677 cl_uint max_clock_frequency;
12678 cl_uint max_compute_units;
12679
12680 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12681 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12682 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12683 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12684 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12685
12686 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12687 {
12688 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12689 device_all_id + 1,
12690 device_name,
12691 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12692 (unsigned int) (global_mem_size / 1024 / 1024),
12693 (unsigned int) (max_clock_frequency),
12694 (unsigned int) max_compute_units);
12695 }
12696
12697 // copy hm_adapter info to data.hm_device[]
12698
12699 uint hm_adapter_cur = hm_adapter_index;
12700
12701 if ((device_type & CL_DEVICE_TYPE_GPU) == 0)
12702 {
12703 // assign a CPU adapter (i.e. not initialized hm_adapter_all[] entry)
12704
12705 hm_adapter_cur = devices_all_cnt - 1;
12706 }
12707
12708 memcpy (&data.hm_device[device_id], &hm_adapter_all[hm_adapter_cur], sizeof (hm_attrs_t));
12709
12710 if (device_type & CL_DEVICE_TYPE_GPU)
12711 {
12712 hm_adapter_index++;
12713 }
12714
12715 devices_cnt++;
12716 }
12717
12718 if (devices_cnt == 0)
12719 {
12720 log_error ("ERROR: No devices left that matches your specification.");
12721
12722 return (-1);
12723 }
12724
12725 data.devices_cnt = devices_cnt;
12726
12727 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12728 {
12729 log_info ("");
12730 }
12731
12732 /**
12733 * inform the user
12734 */
12735
12736 // gpu temp sanity check
12737
12738 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12739 {
12740 if (gpu_temp_abort < gpu_temp_retain)
12741 {
12742 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12743
12744 return (-1);
12745 }
12746 }
12747
12748 data.gpu_temp_disable = gpu_temp_disable;
12749 data.gpu_temp_abort = gpu_temp_abort;
12750 data.gpu_temp_retain = gpu_temp_retain;
12751
12752 if (data.quiet == 0)
12753 {
12754 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12755
12756 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);
12757
12758 if (attack_mode == ATTACK_MODE_STRAIGHT)
12759 {
12760 log_info ("Rules: %u", kernel_rules_cnt);
12761 }
12762
12763 if (opti_type)
12764 {
12765 log_info ("Applicable Optimizers:");
12766
12767 for (uint i = 0; i < 32; i++)
12768 {
12769 const uint opti_bit = 1 << i;
12770
12771 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12772 }
12773 }
12774
12775 /**
12776 * Watchdog and Temperature balance
12777 */
12778
12779 if (gpu_temp_abort == 0)
12780 {
12781 log_info ("Watchdog: Temperature abort trigger disabled");
12782 }
12783 else
12784 {
12785 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12786 }
12787
12788 if (gpu_temp_retain == 0)
12789 {
12790 log_info ("Watchdog: Temperature retain trigger disabled");
12791 }
12792 else
12793 {
12794 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12795 }
12796 }
12797
12798 /**
12799 * devices init
12800 */
12801
12802 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12803
12804 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12805
12806 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12807
12808 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12809
12810 data.devices_param = devices_param;
12811
12812 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12813 {
12814 hc_device_param_t *device_param = &data.devices_param[device_id];
12815
12816 cl_device_id device = devices[device_id];
12817
12818 device_param->device = device;
12819
12820 cl_device_type device_type = 0;
12821
12822 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12823
12824 device_param->device_type = device_type;
12825
12826 cl_uint max_compute_units = 0;
12827
12828 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12829
12830 device_param->device_processors = max_compute_units;
12831
12832 cl_ulong max_mem_alloc_size = 0;
12833
12834 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12835
12836 device_param->device_maxmem_alloc = max_mem_alloc_size;
12837
12838 char tmp[INFOSZ], t1[64];
12839
12840 memset (tmp, 0, sizeof (tmp));
12841
12842 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12843
12844 device_param->device_name = mystrdup (tmp);
12845
12846 memset (tmp, 0, sizeof (tmp));
12847
12848 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12849
12850 memset (t1, 0, sizeof (t1));
12851
12852 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12853
12854 device_param->device_version = mystrdup (t1);
12855
12856 memset (tmp, 0, sizeof (tmp));
12857
12858 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12859
12860 device_param->driver_version = mystrdup (tmp);
12861
12862 // create some filename that is easier to read on cached folder
12863
12864 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12865
12866 uint device_name_digest[4];
12867
12868 device_name_digest[0] = 0;
12869 device_name_digest[1] = 0;
12870 device_name_digest[2] = 0;
12871 device_name_digest[3] = 0;
12872
12873 md5_64 ((uint *) tmp, device_name_digest);
12874
12875 sprintf (tmp, "%08x", device_name_digest[0]);
12876
12877 device_param->device_name_chksum = mystrdup (tmp);
12878
12879 if (device_type & CL_DEVICE_TYPE_CPU)
12880 {
12881 cl_uint device_processor_cores = 1;
12882
12883 device_param->device_processor_cores = device_processor_cores;
12884 }
12885
12886 if (device_type & CL_DEVICE_TYPE_GPU)
12887 {
12888 if (vendor_id == VENDOR_ID_AMD)
12889 {
12890 cl_uint device_processor_cores = 0;
12891
12892 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12893
12894 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12895
12896 device_param->device_processor_cores = device_processor_cores;
12897 }
12898
12899 if (vendor_id == VENDOR_ID_NV)
12900 {
12901 cl_uint kernel_exec_timeout = 0;
12902
12903 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12904
12905 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12906
12907 device_param->kernel_exec_timeout = kernel_exec_timeout;
12908
12909 cl_uint device_processor_cores = 0;
12910
12911 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12912
12913 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12914
12915 device_param->device_processor_cores = device_processor_cores;
12916
12917 cl_uint sm_minor = 0;
12918 cl_uint sm_major = 0;
12919
12920 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12921 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12922
12923 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12924 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12925
12926 device_param->sm_minor = sm_minor;
12927 device_param->sm_major = sm_major;
12928 }
12929 }
12930
12931 /**
12932 * common driver check
12933 */
12934
12935 if (device_type & CL_DEVICE_TYPE_GPU)
12936 {
12937 if (vendor_id == VENDOR_ID_NV)
12938 {
12939 if (device_param->kernel_exec_timeout != 0)
12940 {
12941 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);
12942 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12943 }
12944 }
12945
12946 if (vendor_id == VENDOR_ID_AMD)
12947 {
12948 int catalyst_check = (force == 1) ? 0 : 1;
12949
12950 int catalyst_warn = 0;
12951
12952 int catalyst_broken = 0;
12953
12954 if (catalyst_check == 1)
12955 {
12956 catalyst_warn = 1;
12957
12958 // v14.9 and higher
12959 if ((atoi (device_param->device_version) >= 1573)
12960 && (atoi (device_param->driver_version) >= 1573))
12961 {
12962 catalyst_warn = 0;
12963 }
12964
12965 catalyst_check = 0;
12966 }
12967
12968 if (catalyst_broken == 1)
12969 {
12970 log_error ("");
12971 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12972 log_error ("It will pass over cracked hashes and does not report them as cracked");
12973 log_error ("You are STRONGLY encouraged not to use it");
12974 log_error ("You can use --force to override this but do not post error reports if you do so");
12975
12976 return (-1);
12977 }
12978
12979 if (catalyst_warn == 1)
12980 {
12981 log_error ("");
12982 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12983 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12984 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12985 #ifdef _WIN
12986 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12987 #endif
12988 log_error ("You can use --force to override this but do not post error reports if you do so");
12989
12990 return (-1);
12991 }
12992 }
12993 }
12994 }
12995
12996 /*
12997 * Temporary fix:
12998 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12999 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13000 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13001 * Driver / ADL bug?
13002 */
13003
13004 if (vendor_id == VENDOR_ID_AMD)
13005 {
13006 if (powertune_enable == 1)
13007 {
13008 hc_thread_mutex_lock (mux_adl);
13009
13010 for (uint i = 0; i < devices_cnt; i++)
13011 {
13012 if (data.hm_device[i].od_version == 6)
13013 {
13014 // set powertune value only
13015
13016 int powertune_supported = 0;
13017
13018 int ADL_rc = 0;
13019
13020 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
13021 {
13022 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13023
13024 return (-1);
13025 }
13026
13027 if (powertune_supported != 0)
13028 {
13029 // powertune set
13030 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13031
13032 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
13033 {
13034 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13035
13036 return (-1);
13037 }
13038
13039 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13040 {
13041 log_error ("ERROR: Failed to set new ADL PowerControl values");
13042
13043 return (-1);
13044 }
13045 }
13046 }
13047 }
13048
13049 hc_thread_mutex_unlock (mux_adl);
13050 }
13051 }
13052
13053 uint kernel_blocks_all = 0;
13054
13055 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13056 {
13057 /**
13058 * host buffer
13059 */
13060
13061 hc_device_param_t *device_param = &data.devices_param[device_id];
13062
13063 /**
13064 * device properties
13065 */
13066
13067 char *device_name_chksum = device_param->device_name_chksum;
13068
13069 uint device_processors = device_param->device_processors;
13070
13071 uint device_processor_cores = device_param->device_processor_cores;
13072
13073 cl_device_type device_type = device_param->device_type;
13074
13075 /**
13076 * create context for each device
13077 */
13078
13079 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13080
13081 /**
13082 * create command-queue
13083 */
13084
13085 // not support with NV
13086 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13087
13088 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13089
13090 /**
13091 * create input buffers on device
13092 */
13093
13094 uint kernel_threads = KERNEL_THREADS;
13095
13096 // bcrypt
13097 if (hash_mode == 3200) kernel_threads = 8;
13098 if (hash_mode == 9000) kernel_threads = 8;
13099
13100 if (device_type & CL_DEVICE_TYPE_CPU)
13101 {
13102 // CPU still need lots of workitems, don't know why...
13103 // for testing phase, lets start with this
13104
13105 kernel_accel = 1;
13106 }
13107
13108 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13109 uint kernel_blocks = kernel_power;
13110
13111 device_param->kernel_threads = kernel_threads;
13112 device_param->kernel_power_user = kernel_power;
13113 device_param->kernel_blocks_user = kernel_blocks;
13114
13115 kernel_blocks_all += kernel_blocks;
13116
13117 uint size_pws = kernel_power * sizeof (pw_t);
13118
13119 uint size_tmps = 4;
13120
13121 switch (hash_mode)
13122 {
13123 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13124 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13125 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13126 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13127 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13128 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13129 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13130 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13131 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13132 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13133 case 6211:
13134 case 6212:
13135 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13136 case 6221:
13137 case 6222:
13138 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13139 case 6231:
13140 case 6232:
13141 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13142 case 6241:
13143 case 6242:
13144 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13145 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13146 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13147 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13148 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13149 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13150 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13151 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13152 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13153 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13154 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13155 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13156 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13157 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13158 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13159 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13160 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13161 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13162 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13163 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13164 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13165 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13166 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13167 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13168 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13169 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13170 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13171 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13172 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13173 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13174 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13175 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13176 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13177 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13178 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13179 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13180 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13181 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13182 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13183 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13184 };
13185
13186 uint size_hooks = 4;
13187
13188 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13189 {
13190 // insert correct hook size
13191 }
13192
13193 // we can optimize some stuff here...
13194
13195 device_param->size_pws = size_pws;
13196 device_param->size_tmps = size_tmps;
13197 device_param->size_hooks = size_hooks;
13198
13199 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13200 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13201
13202 device_param->size_root_css = size_root_css;
13203 device_param->size_markov_css = size_markov_css;
13204
13205 uint size_results = KERNEL_THREADS * sizeof (uint);
13206
13207 device_param->size_results = size_results;
13208
13209 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13210 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13211
13212 uint size_plains = digests_cnt * sizeof (plain_t);
13213 uint size_salts = salts_cnt * sizeof (salt_t);
13214 uint size_esalts = salts_cnt * esalt_size;
13215
13216 device_param->size_plains = size_plains;
13217 device_param->size_digests = size_digests;
13218 device_param->size_shown = size_shown;
13219 device_param->size_salts = size_salts;
13220
13221 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13222 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13223 uint size_tm = 32 * sizeof (bs_word_t);
13224
13225 uint64_t size_scryptV = 1;
13226
13227 if ((hash_mode == 8900) || (hash_mode == 9300))
13228 {
13229 uint tmto_start = 0;
13230 uint tmto_stop = 10;
13231
13232 if (scrypt_tmto)
13233 {
13234 tmto_start = scrypt_tmto;
13235 }
13236 else
13237 {
13238 // in case the user did not specify the tmto manually
13239 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13240 // but set the lower end only in case the user has a device with too less memory
13241
13242 if (hash_mode == 8900)
13243 {
13244 if (vendor_id == VENDOR_ID_AMD)
13245 {
13246 tmto_start = 1;
13247 }
13248 else if (vendor_id == VENDOR_ID_NV)
13249 {
13250 tmto_start = 3;
13251 }
13252 }
13253 else if (hash_mode == 9300)
13254 {
13255 if (vendor_id == VENDOR_ID_AMD)
13256 {
13257 tmto_start = 3;
13258 }
13259 else if (vendor_id == VENDOR_ID_NV)
13260 {
13261 tmto_start = 5;
13262 }
13263 }
13264 }
13265
13266 if (quiet == 0) log_info ("");
13267
13268 uint shader_per_mp = 1;
13269
13270 if (vendor_id == VENDOR_ID_AMD)
13271 {
13272 shader_per_mp = 8;
13273 }
13274
13275 if (vendor_id == VENDOR_ID_NV)
13276 {
13277 shader_per_mp = 32;
13278 }
13279
13280 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13281 {
13282 // TODO: in theory the following calculation needs to be done per salt, not global
13283 // we assume all hashes have the same scrypt settings
13284
13285 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13286
13287 size_scryptV /= 1 << tmto;
13288
13289 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13290
13291 if (size_scryptV > device_param->device_maxmem_alloc)
13292 {
13293 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13294
13295 continue;
13296 }
13297
13298 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13299 {
13300 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13301 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13302 }
13303
13304 break;
13305 }
13306
13307 if (data.salts_buf[0].scrypt_phy == 0)
13308 {
13309 log_error ("ERROR: can't allocate enough device memory");
13310
13311 return -1;
13312 }
13313
13314 if (quiet == 0) log_info ("");
13315 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13316 }
13317
13318 /**
13319 * default building options
13320 */
13321
13322 char build_opts[1024];
13323
13324 // we don't have sm_* on AMD but it doesn't matter
13325
13326 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13327
13328 /**
13329 * a0 kernel, required for some fast hashes to make weak_hash_check work
13330 */
13331
13332 const uint add_flag = OPTS_TYPE_PT_ADD01
13333 | OPTS_TYPE_PT_ADD02
13334 | OPTS_TYPE_PT_ADD80
13335 | OPTS_TYPE_PT_ADDBITS14
13336 | OPTS_TYPE_PT_ADDBITS15
13337 | OPTS_TYPE_ST_ADD01
13338 | OPTS_TYPE_ST_ADD02
13339 | OPTS_TYPE_ST_ADD80
13340 | OPTS_TYPE_ST_ADDBITS14
13341 | OPTS_TYPE_ST_ADDBITS15;
13342
13343 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13344 {
13345 /**
13346 * kernel source filename
13347 */
13348
13349 char source_file[256];
13350
13351 memset (source_file, 0, sizeof (source_file));
13352
13353 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13354
13355 struct stat sst;
13356
13357 if (stat (source_file, &sst) == -1)
13358 {
13359 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13360
13361 return -1;
13362 }
13363
13364 /**
13365 * kernel cached filename
13366 */
13367
13368 char cached_file[256];
13369
13370 memset (cached_file, 0, sizeof (cached_file));
13371
13372 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13373
13374 int cached = 1;
13375
13376 struct stat cst;
13377
13378 if (stat (cached_file, &cst) == -1)
13379 {
13380 cached = 0;
13381 }
13382
13383 /**
13384 * kernel compile or load
13385 */
13386
13387 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13388
13389 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13390
13391 if (force_jit_compilation == 0)
13392 {
13393 if (cached == 0)
13394 {
13395 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13396
13397 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13398
13399 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13400
13401 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13402
13403 size_t binary_size;
13404
13405 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13406
13407 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13408
13409 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13410
13411 writeProgramBin (cached_file, binary, binary_size);
13412
13413 local_free (binary);
13414 }
13415 else
13416 {
13417 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13418
13419 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13420
13421 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13422
13423 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13424 }
13425 }
13426 else
13427 {
13428 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13429
13430 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13431
13432 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13433
13434 if (force_jit_compilation == 1500)
13435 {
13436 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13437 }
13438 else if (force_jit_compilation == 8900)
13439 {
13440 sprintf (build_opts, "%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);
13441 }
13442
13443 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13444 }
13445
13446 local_free (kernel_lengths);
13447 local_free (kernel_sources[0]);
13448 local_free (kernel_sources);
13449
13450 // this is mostly for debug
13451
13452 size_t ret_val_size = 0;
13453
13454 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13455
13456 if (ret_val_size > 2)
13457 {
13458 char *build_log = (char *) mymalloc (ret_val_size + 1);
13459
13460 memset (build_log, 0, ret_val_size + 1);
13461
13462 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13463
13464 puts (build_log);
13465
13466 myfree (build_log);
13467 }
13468 }
13469
13470 /**
13471 * main kernel
13472 */
13473
13474 {
13475 /**
13476 * kernel source filename
13477 */
13478
13479 char source_file[256];
13480
13481 memset (source_file, 0, sizeof (source_file));
13482
13483 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13484
13485 struct stat sst;
13486
13487 if (stat (source_file, &sst) == -1)
13488 {
13489 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13490
13491 return -1;
13492 }
13493
13494 /**
13495 * kernel cached filename
13496 */
13497
13498 char cached_file[256];
13499
13500 memset (cached_file, 0, sizeof (cached_file));
13501
13502 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13503
13504 int cached = 1;
13505
13506 struct stat cst;
13507
13508 if (stat (cached_file, &cst) == -1)
13509 {
13510 cached = 0;
13511 }
13512
13513 /**
13514 * kernel compile or load
13515 */
13516
13517 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13518
13519 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13520
13521 if (force_jit_compilation == 0)
13522 {
13523 if (cached == 0)
13524 {
13525 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13526
13527 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13528
13529 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13530
13531 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13532
13533 size_t binary_size;
13534
13535 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13536
13537 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13538
13539 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13540
13541 writeProgramBin (cached_file, binary, binary_size);
13542
13543 local_free (binary);
13544 }
13545 else
13546 {
13547 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13548
13549 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13550
13551 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13552
13553 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13554 }
13555 }
13556 else
13557 {
13558 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13559
13560 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13561
13562 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13563
13564 if (force_jit_compilation == 1500)
13565 {
13566 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13567 }
13568 else if (force_jit_compilation == 8900)
13569 {
13570 sprintf (build_opts, "%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);
13571 }
13572
13573 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13574 }
13575
13576 local_free (kernel_lengths);
13577 local_free (kernel_sources[0]);
13578 local_free (kernel_sources);
13579
13580 // this is mostly for debug
13581
13582 size_t ret_val_size = 0;
13583
13584 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13585
13586 if (ret_val_size > 2)
13587 {
13588 char *build_log = (char *) mymalloc (ret_val_size + 1);
13589
13590 memset (build_log, 0, ret_val_size + 1);
13591
13592 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13593
13594 puts (build_log);
13595
13596 myfree (build_log);
13597 }
13598 }
13599
13600 /**
13601 * word generator kernel
13602 */
13603
13604 if (attack_mode != ATTACK_MODE_STRAIGHT)
13605 {
13606 /**
13607 * kernel mp source filename
13608 */
13609
13610 char source_file[256];
13611
13612 memset (source_file, 0, sizeof (source_file));
13613
13614 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13615
13616 struct stat sst;
13617
13618 if (stat (source_file, &sst) == -1)
13619 {
13620 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13621
13622 return -1;
13623 }
13624
13625 /**
13626 * kernel mp cached filename
13627 */
13628
13629 char cached_file[256];
13630
13631 memset (cached_file, 0, sizeof (cached_file));
13632
13633 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13634
13635 int cached = 1;
13636
13637 struct stat cst;
13638
13639 if (stat (cached_file, &cst) == -1)
13640 {
13641 cached = 0;
13642 }
13643
13644 /**
13645 * kernel compile or load
13646 */
13647
13648 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13649
13650 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13651
13652 if (cached == 0)
13653 {
13654 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13655
13656 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13657
13658 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13659
13660 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13661
13662 size_t binary_size;
13663
13664 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13665
13666 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13667
13668 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13669
13670 writeProgramBin (cached_file, binary, binary_size);
13671
13672 local_free (binary);
13673 }
13674 else
13675 {
13676 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13677
13678 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13679
13680 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13681
13682 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13683 }
13684
13685 local_free (kernel_lengths);
13686 local_free (kernel_sources[0]);
13687 local_free (kernel_sources);
13688
13689 // this is mostly for debug
13690
13691 size_t ret_val_size = 0;
13692
13693 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13694
13695 if (ret_val_size > 2)
13696 {
13697 char *build_log = (char *) mymalloc (ret_val_size + 1);
13698
13699 memset (build_log, 0, ret_val_size + 1);
13700
13701 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13702
13703 puts (build_log);
13704
13705 myfree (build_log);
13706 }
13707 }
13708
13709 /**
13710 * amplifier kernel
13711 */
13712
13713 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13714 {
13715
13716 }
13717 else
13718 {
13719 /**
13720 * kernel amp source filename
13721 */
13722
13723 char source_file[256];
13724
13725 memset (source_file, 0, sizeof (source_file));
13726
13727 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13728
13729 struct stat sst;
13730
13731 if (stat (source_file, &sst) == -1)
13732 {
13733 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13734
13735 return -1;
13736 }
13737
13738 /**
13739 * kernel amp cached filename
13740 */
13741
13742 char cached_file[256];
13743
13744 memset (cached_file, 0, sizeof (cached_file));
13745
13746 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13747
13748 int cached = 1;
13749
13750 struct stat cst;
13751
13752 if (stat (cached_file, &cst) == -1)
13753 {
13754 cached = 0;
13755 }
13756
13757 /**
13758 * kernel compile or load
13759 */
13760
13761 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13762
13763 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13764
13765 if (cached == 0)
13766 {
13767 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13768
13769 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13770
13771 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13772
13773 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13774
13775 size_t binary_size;
13776
13777 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13778
13779 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13780
13781 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13782
13783 writeProgramBin (cached_file, binary, binary_size);
13784
13785 local_free (binary);
13786 }
13787 else
13788 {
13789 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13790
13791 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13792
13793 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13794
13795 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13796 }
13797
13798 local_free (kernel_lengths);
13799 local_free (kernel_sources[0]);
13800 local_free (kernel_sources);
13801
13802 // this is mostly for debug
13803
13804 size_t ret_val_size = 0;
13805
13806 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13807
13808 if (ret_val_size > 2)
13809 {
13810 char *build_log = (char *) mymalloc (ret_val_size + 1);
13811
13812 memset (build_log, 0, ret_val_size + 1);
13813
13814 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13815
13816 puts (build_log);
13817
13818 myfree (build_log);
13819 }
13820 }
13821
13822 /**
13823 * global buffers
13824 */
13825
13826 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13827 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13828 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13829 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13830 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13831 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13832 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13833 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13834 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13835 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13836 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13837 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13838 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13839 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13840 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13841 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13842 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13843 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13844
13845 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13846 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13847 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13848 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13849 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13850 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13851 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13852 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13853 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13854 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13855 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13856
13857 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13858 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13859 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13860 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13861 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13862 run_kernel_bzero (device_param, device_param->d_result, size_results);
13863
13864 /**
13865 * special buffers
13866 */
13867
13868 if (attack_kern == ATTACK_KERN_STRAIGHT)
13869 {
13870 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13871 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13872
13873 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13874
13875 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13876 }
13877 else if (attack_kern == ATTACK_KERN_COMBI)
13878 {
13879 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13880 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13881 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13882 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13883
13884 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13885 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13886 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13887 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13888 }
13889 else if (attack_kern == ATTACK_KERN_BF)
13890 {
13891 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13892 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13893 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13894 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13895 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13896
13897 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13898 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13899 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13900 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13901 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13902 }
13903
13904 if (size_esalts)
13905 {
13906 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13907
13908 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13909 }
13910
13911 /**
13912 * main host data
13913 */
13914
13915 uint *result = (uint *) mymalloc (size_results);
13916
13917 memset (result, 0, size_results);
13918
13919 device_param->result = result;
13920
13921 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13922
13923 memset (pws_buf, 0, size_pws);
13924
13925 device_param->pws_buf = pws_buf;
13926
13927 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13928
13929 for (int i = 0; i < 64; i++)
13930 {
13931 pw_caches[i].pw_buf.pw_len = i;
13932 pw_caches[i].cnt = 0;
13933 }
13934
13935 device_param->pw_caches = pw_caches;
13936
13937 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13938
13939 device_param->combs_buf = combs_buf;
13940
13941 void *hooks_buf = mymalloc (size_hooks);
13942
13943 device_param->hooks_buf = hooks_buf;
13944
13945 device_param->pw_transpose = pw_transpose_to_hi1;
13946 device_param->pw_add = pw_add_to_hc1;
13947
13948 /**
13949 * kernel args
13950 */
13951
13952 device_param->kernel_params_buf32[21] = bitmap_mask;
13953 device_param->kernel_params_buf32[22] = bitmap_shift1;
13954 device_param->kernel_params_buf32[23] = bitmap_shift2;
13955 device_param->kernel_params_buf32[24] = 0; // salt_pos
13956 device_param->kernel_params_buf32[25] = 0; // loop_pos
13957 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13958 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13959 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13960 device_param->kernel_params_buf32[29] = 0; // digests_offset
13961 device_param->kernel_params_buf32[30] = 0; // combs_mode
13962 device_param->kernel_params_buf32[31] = 0; // gid_max
13963
13964 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13965 ? &device_param->d_pws_buf
13966 : &device_param->d_pws_amp_buf;
13967 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13968 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13969 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13970 device_param->kernel_params[ 4] = &device_param->d_tmps;
13971 device_param->kernel_params[ 5] = &device_param->d_hooks;
13972 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13973 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13974 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13975 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13976 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13977 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13978 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13979 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13980 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13981 device_param->kernel_params[15] = &device_param->d_digests_buf;
13982 device_param->kernel_params[16] = &device_param->d_digests_shown;
13983 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13984 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13985 device_param->kernel_params[19] = &device_param->d_result;
13986 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13987 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13988 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13989 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13990 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13991 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13992 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13993 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13994 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13995 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13996 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13997 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13998
13999 device_param->kernel_params_mp_buf64[3] = 0;
14000 device_param->kernel_params_mp_buf32[4] = 0;
14001 device_param->kernel_params_mp_buf32[5] = 0;
14002 device_param->kernel_params_mp_buf32[6] = 0;
14003 device_param->kernel_params_mp_buf32[7] = 0;
14004 device_param->kernel_params_mp_buf32[8] = 0;
14005
14006 device_param->kernel_params_mp[0] = NULL;
14007 device_param->kernel_params_mp[1] = NULL;
14008 device_param->kernel_params_mp[2] = NULL;
14009 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14010 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14011 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14012 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14013 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14014 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14015
14016 device_param->kernel_params_mp_l_buf64[3] = 0;
14017 device_param->kernel_params_mp_l_buf32[4] = 0;
14018 device_param->kernel_params_mp_l_buf32[5] = 0;
14019 device_param->kernel_params_mp_l_buf32[6] = 0;
14020 device_param->kernel_params_mp_l_buf32[7] = 0;
14021 device_param->kernel_params_mp_l_buf32[8] = 0;
14022 device_param->kernel_params_mp_l_buf32[9] = 0;
14023
14024 device_param->kernel_params_mp_l[0] = NULL;
14025 device_param->kernel_params_mp_l[1] = NULL;
14026 device_param->kernel_params_mp_l[2] = NULL;
14027 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14028 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14029 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14030 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14031 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14032 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14033 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14034
14035 device_param->kernel_params_mp_r_buf64[3] = 0;
14036 device_param->kernel_params_mp_r_buf32[4] = 0;
14037 device_param->kernel_params_mp_r_buf32[5] = 0;
14038 device_param->kernel_params_mp_r_buf32[6] = 0;
14039 device_param->kernel_params_mp_r_buf32[7] = 0;
14040 device_param->kernel_params_mp_r_buf32[8] = 0;
14041
14042 device_param->kernel_params_mp_r[0] = NULL;
14043 device_param->kernel_params_mp_r[1] = NULL;
14044 device_param->kernel_params_mp_r[2] = NULL;
14045 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14046 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14047 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14048 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14049 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14050 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14051
14052 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14053 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14054
14055 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14056 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14057 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14058 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14059 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14060 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14061 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14062
14063 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14064
14065 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14066 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14067
14068 /**
14069 * kernel name
14070 */
14071
14072 char kernel_name[64];
14073
14074 memset (kernel_name, 0, sizeof (kernel_name));
14075
14076 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14077 {
14078 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14079 {
14080 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14081
14082 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14083
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14085
14086 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14087
14088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14089
14090 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14091 }
14092 else
14093 {
14094 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14095
14096 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14097
14098 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14099
14100 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14101
14102 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14103
14104 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14105 }
14106
14107 if (weak_hash_threshold)
14108 {
14109 if (opts_type & add_flag)
14110 {
14111 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14112 {
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14114
14115 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14116 }
14117 else
14118 {
14119 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14120
14121 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14122 }
14123 }
14124 else
14125 {
14126 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14127 {
14128 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14129
14130 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14131 }
14132 else
14133 {
14134 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14135
14136 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14137 }
14138 }
14139 }
14140
14141 if (data.attack_mode == ATTACK_MODE_BF)
14142 {
14143 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14144 {
14145 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14146
14147 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14148
14149 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14150
14151 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14152 }
14153 }
14154 }
14155 else
14156 {
14157 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14158
14159 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14160
14161 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14162
14163 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14164
14165 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14166
14167 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14168
14169 if (opts_type & OPTS_TYPE_HOOK12)
14170 {
14171 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14172
14173 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14174 }
14175
14176 if (opts_type & OPTS_TYPE_HOOK23)
14177 {
14178 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14179
14180 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14181 }
14182 }
14183
14184 for (uint i = 0; i <= 20; i++)
14185 {
14186 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14187 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14188 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14189
14190 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14191 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14192
14193 if (weak_hash_threshold)
14194 {
14195 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14196 }
14197 }
14198
14199 for (uint i = 21; i <= 31; i++)
14200 {
14201 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14202 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14203 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14204
14205 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14206 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14207
14208 if (weak_hash_threshold)
14209 {
14210 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14211 }
14212 }
14213
14214 if (attack_mode == ATTACK_MODE_BF)
14215 {
14216 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14217 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14218
14219 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14220 {
14221 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14222
14223 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14224 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14225 }
14226 }
14227 else if (attack_mode == ATTACK_MODE_HYBRID1)
14228 {
14229 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14230 }
14231 else if (attack_mode == ATTACK_MODE_HYBRID2)
14232 {
14233 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14234 }
14235
14236 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14237 {
14238 // nothing to do
14239 }
14240 else
14241 {
14242 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14243 }
14244
14245 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14246 {
14247 // nothing to do
14248 }
14249 else
14250 {
14251 for (uint i = 0; i < 5; i++)
14252 {
14253 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14254 }
14255
14256 for (uint i = 5; i < 7; i++)
14257 {
14258 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14259 }
14260 }
14261
14262 /**
14263 * Store initial fanspeed if gpu_temp_retain is enabled
14264 */
14265
14266 int gpu_temp_retain_set = 0;
14267
14268 if (gpu_temp_disable == 0)
14269 {
14270 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14271 {
14272 hc_thread_mutex_lock (mux_adl);
14273
14274 if (data.hm_device[device_id].fan_supported == 1)
14275 {
14276 if (gpu_temp_retain_chgd == 0)
14277 {
14278 uint cur_temp = 0;
14279 uint default_temp = 0;
14280
14281 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14282
14283 if (ADL_rc == ADL_OK)
14284 {
14285 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14286
14287 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14288
14289 // special case with multi gpu setups: always use minimum retain
14290
14291 if (gpu_temp_retain_set == 0)
14292 {
14293 gpu_temp_retain = gpu_temp_retain_target;
14294 gpu_temp_retain_set = 1;
14295 }
14296 else
14297 {
14298 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14299 }
14300
14301 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14302 }
14303 }
14304
14305 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14306
14307 temp_retain_fanspeed_value[device_id] = fan_speed;
14308
14309 if (fan_speed == -1)
14310 {
14311 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14312
14313 temp_retain_fanspeed_value[device_id] = 0;
14314 }
14315 }
14316
14317 hc_thread_mutex_unlock (mux_adl);
14318 }
14319 }
14320
14321 /**
14322 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14323 */
14324
14325 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14326 {
14327 hc_thread_mutex_lock (mux_adl);
14328
14329 if (data.hm_device[device_id].od_version == 6)
14330 {
14331 int ADL_rc;
14332
14333 // check powertune capabilities first, if not available then skip device
14334
14335 int powertune_supported = 0;
14336
14337 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14338 {
14339 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14340
14341 return (-1);
14342 }
14343
14344 if (powertune_supported != 0)
14345 {
14346 // powercontrol settings
14347
14348 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14349
14350 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14351 {
14352 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14353 }
14354
14355 if (ADL_rc != ADL_OK)
14356 {
14357 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14358
14359 return (-1);
14360 }
14361
14362 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14363 {
14364 log_error ("ERROR: Failed to set new ADL PowerControl values");
14365
14366 return (-1);
14367 }
14368
14369 // clocks
14370
14371 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14372
14373 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14374
14375 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14376 {
14377 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14378
14379 return (-1);
14380 }
14381
14382 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14383
14384 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14385
14386 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14387 {
14388 log_error ("ERROR: Failed to get ADL device capabilities");
14389
14390 return (-1);
14391 }
14392
14393 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14394 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14395
14396 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14397 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14398
14399 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14400 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14401
14402 // warning if profile has to low max values
14403
14404 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14405 {
14406 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14407 }
14408
14409 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14410 {
14411 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14412 }
14413
14414 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14415
14416 performance_state->iNumberOfPerformanceLevels = 2;
14417
14418 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14419 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14420 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14421 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14422
14423 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14424 {
14425 log_info ("ERROR: Failed to set ADL performance state");
14426
14427 return (-1);
14428 }
14429
14430 local_free (performance_state);
14431 }
14432 }
14433
14434 hc_thread_mutex_unlock (mux_adl);
14435 }
14436 }
14437
14438 data.kernel_blocks_all = kernel_blocks_all;
14439
14440 if (data.quiet == 0) log_info ("");
14441
14442 /**
14443 * Inform user which algorithm is checked and at which workload setting
14444 */
14445
14446 if (benchmark == 1)
14447 {
14448 quiet = 0;
14449
14450 data.quiet = quiet;
14451
14452 char *hash_type = strhashtype (data.hash_mode); // not a bug
14453
14454 log_info ("Hashtype: %s", hash_type);
14455 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14456 log_info ("");
14457 }
14458
14459 /**
14460 * keep track of the progress
14461 */
14462
14463 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14464 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14465 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14466
14467 /**
14468 * open filehandles
14469 */
14470
14471 #if _WIN
14472 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14473 {
14474 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14475
14476 return (-1);
14477 }
14478
14479 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14480 {
14481 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14482
14483 return (-1);
14484 }
14485
14486 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14487 {
14488 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14489
14490 return (-1);
14491 }
14492 #endif
14493
14494 /**
14495 * dictionary pad
14496 */
14497
14498 segment_size *= (1024 * 1024);
14499
14500 data.segment_size = segment_size;
14501
14502 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14503
14504 wl_data->buf = (char *) mymalloc (segment_size);
14505 wl_data->avail = segment_size;
14506 wl_data->incr = segment_size;
14507 wl_data->cnt = 0;
14508 wl_data->pos = 0;
14509
14510 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14511
14512 data.wordlist_mode = wordlist_mode;
14513
14514 cs_t *css_buf = NULL;
14515 uint css_cnt = 0;
14516 uint dictcnt = 0;
14517 uint maskcnt = 1;
14518 char **masks = NULL;
14519 char **dictfiles = NULL;
14520
14521 uint mask_from_file = 0;
14522
14523 if (attack_mode == ATTACK_MODE_STRAIGHT)
14524 {
14525 if (wordlist_mode == WL_MODE_FILE)
14526 {
14527 int wls_left = myargc - (optind + 1);
14528
14529 for (int i = 0; i < wls_left; i++)
14530 {
14531 char *l0_filename = myargv[optind + 1 + i];
14532
14533 struct stat l0_stat;
14534
14535 if (stat (l0_filename, &l0_stat) == -1)
14536 {
14537 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14538
14539 return (-1);
14540 }
14541
14542 uint is_dir = S_ISDIR (l0_stat.st_mode);
14543
14544 if (is_dir == 0)
14545 {
14546 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14547
14548 dictcnt++;
14549
14550 dictfiles[dictcnt - 1] = l0_filename;
14551 }
14552 else
14553 {
14554 // do not allow --keyspace w/ a directory
14555
14556 if (keyspace == 1)
14557 {
14558 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14559
14560 return (-1);
14561 }
14562
14563 char **dictionary_files = NULL;
14564
14565 dictionary_files = scan_directory (l0_filename);
14566
14567 if (dictionary_files != NULL)
14568 {
14569 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14570
14571 for (int d = 0; dictionary_files[d] != NULL; d++)
14572 {
14573 char *l1_filename = dictionary_files[d];
14574
14575 struct stat l1_stat;
14576
14577 if (stat (l1_filename, &l1_stat) == -1)
14578 {
14579 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14580
14581 return (-1);
14582 }
14583
14584 if (S_ISREG (l1_stat.st_mode))
14585 {
14586 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14587
14588 dictcnt++;
14589
14590 dictfiles[dictcnt - 1] = strdup (l1_filename);
14591 }
14592 }
14593 }
14594
14595 local_free (dictionary_files);
14596 }
14597 }
14598
14599 if (dictcnt < 1)
14600 {
14601 log_error ("ERROR: No usable dictionary file found.");
14602
14603 return (-1);
14604 }
14605 }
14606 else if (wordlist_mode == WL_MODE_STDIN)
14607 {
14608 dictcnt = 1;
14609 }
14610 }
14611 else if (attack_mode == ATTACK_MODE_COMBI)
14612 {
14613 // display
14614
14615 char *dictfile1 = myargv[optind + 1 + 0];
14616 char *dictfile2 = myargv[optind + 1 + 1];
14617
14618 // find the bigger dictionary and use as base
14619
14620 FILE *fp1;
14621 FILE *fp2;
14622
14623 struct stat tmp_stat;
14624
14625 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14626 {
14627 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14628
14629 return (-1);
14630 }
14631
14632 if (stat (dictfile1, &tmp_stat) == -1)
14633 {
14634 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14635
14636 fclose (fp1);
14637
14638 return (-1);
14639 }
14640
14641 if (S_ISDIR (tmp_stat.st_mode))
14642 {
14643 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14644
14645 fclose (fp1);
14646
14647 return (-1);
14648 }
14649
14650 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14651 {
14652 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14653
14654 fclose (fp1);
14655
14656 return (-1);
14657 }
14658
14659 if (stat (dictfile2, &tmp_stat) == -1)
14660 {
14661 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14662
14663 fclose (fp1);
14664 fclose (fp2);
14665
14666 return (-1);
14667 }
14668
14669 if (S_ISDIR (tmp_stat.st_mode))
14670 {
14671 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14672
14673 fclose (fp1);
14674 fclose (fp2);
14675
14676 return (-1);
14677 }
14678
14679 data.combs_cnt = 1;
14680
14681 data.quiet = 1;
14682
14683 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14684
14685 data.quiet = quiet;
14686
14687 if (words1_cnt == 0)
14688 {
14689 log_error ("ERROR: %s: empty file", dictfile1);
14690
14691 fclose (fp1);
14692 fclose (fp2);
14693
14694 return (-1);
14695 }
14696
14697 data.combs_cnt = 1;
14698
14699 data.quiet = 1;
14700
14701 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14702
14703 data.quiet = quiet;
14704
14705 if (words2_cnt == 0)
14706 {
14707 log_error ("ERROR: %s: empty file", dictfile2);
14708
14709 fclose (fp1);
14710 fclose (fp2);
14711
14712 return (-1);
14713 }
14714
14715 fclose (fp1);
14716 fclose (fp2);
14717
14718 data.dictfile = dictfile1;
14719 data.dictfile2 = dictfile2;
14720
14721 if (words1_cnt >= words2_cnt)
14722 {
14723 data.combs_cnt = words2_cnt;
14724 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14725
14726 dictfiles = &data.dictfile;
14727
14728 dictcnt = 1;
14729 }
14730 else
14731 {
14732 data.combs_cnt = words1_cnt;
14733 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14734
14735 dictfiles = &data.dictfile2;
14736
14737 dictcnt = 1;
14738
14739 // we also have to switch wordlist related rules!
14740
14741 char *tmpc = data.rule_buf_l;
14742
14743 data.rule_buf_l = data.rule_buf_r;
14744 data.rule_buf_r = tmpc;
14745
14746 int tmpi = data.rule_len_l;
14747
14748 data.rule_len_l = data.rule_len_r;
14749 data.rule_len_r = tmpi;
14750 }
14751 }
14752 else if (attack_mode == ATTACK_MODE_BF)
14753 {
14754 char *mask = NULL;
14755
14756 maskcnt = 0;
14757
14758 if (benchmark == 0)
14759 {
14760 mask = myargv[optind + 1];
14761
14762 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14763
14764 if ((optind + 2) <= myargc)
14765 {
14766 struct stat file_stat;
14767
14768 if (stat (mask, &file_stat) == -1)
14769 {
14770 maskcnt = 1;
14771
14772 masks[maskcnt - 1] = mystrdup (mask);
14773 }
14774 else
14775 {
14776 int wls_left = myargc - (optind + 1);
14777
14778 uint masks_avail = INCR_MASKS;
14779
14780 for (int i = 0; i < wls_left; i++)
14781 {
14782 if (i != 0)
14783 {
14784 mask = myargv[optind + 1 + i];
14785
14786 if (stat (mask, &file_stat) == -1)
14787 {
14788 log_error ("ERROR: %s: %s", mask, strerror (errno));
14789
14790 return (-1);
14791 }
14792 }
14793
14794 uint is_file = S_ISREG (file_stat.st_mode);
14795
14796 if (is_file == 1)
14797 {
14798 FILE *mask_fp;
14799
14800 if ((mask_fp = fopen (mask, "r")) == NULL)
14801 {
14802 log_error ("ERROR: %s: %s", mask, strerror (errno));
14803
14804 return (-1);
14805 }
14806
14807 char line_buf[BUFSIZ];
14808
14809 while (!feof (mask_fp))
14810 {
14811 memset (line_buf, 0, BUFSIZ);
14812
14813 int line_len = fgetl (mask_fp, line_buf);
14814
14815 if (line_len == 0) continue;
14816
14817 if (line_buf[0] == '#') continue;
14818
14819 if (masks_avail == maskcnt)
14820 {
14821 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14822
14823 masks_avail += INCR_MASKS;
14824 }
14825
14826 masks[maskcnt] = mystrdup (line_buf);
14827
14828 maskcnt++;
14829 }
14830
14831 fclose (mask_fp);
14832 }
14833 else
14834 {
14835 log_error ("ERROR: %s: unsupported file-type", mask);
14836
14837 return (-1);
14838 }
14839 }
14840
14841 mask_from_file = 1;
14842 }
14843 }
14844 else
14845 {
14846 custom_charset_1 = (char *) "?l?d?u";
14847 custom_charset_2 = (char *) "?l?d";
14848 custom_charset_3 = (char *) "?l?d*!$@_";
14849
14850 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14851 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14852 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14853
14854 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14855
14856 wordlist_mode = WL_MODE_MASK;
14857
14858 data.wordlist_mode = wordlist_mode;
14859
14860 increment = 1;
14861
14862 maskcnt = 1;
14863 }
14864 }
14865 else
14866 {
14867 /**
14868 * generate full masks and charsets
14869 */
14870
14871 masks = (char **) mymalloc (sizeof (char *));
14872
14873 switch (hash_mode)
14874 {
14875 case 1731: pw_min = 5;
14876 pw_max = 5;
14877 mask = mystrdup ("?b?b?b?b?b");
14878 break;
14879 case 12500: pw_min = 5;
14880 pw_max = 5;
14881 mask = mystrdup ("?b?b?b?b?b");
14882 break;
14883 default: pw_min = 7;
14884 pw_max = 7;
14885 mask = mystrdup ("?b?b?b?b?b?b?b");
14886 break;
14887 }
14888
14889 maskcnt = 1;
14890
14891 masks[maskcnt - 1] = mystrdup (mask);
14892
14893 wordlist_mode = WL_MODE_MASK;
14894
14895 data.wordlist_mode = wordlist_mode;
14896
14897 increment = 1;
14898 }
14899
14900 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14901
14902 if (increment)
14903 {
14904 if (increment_min > pw_min) pw_min = increment_min;
14905
14906 if (increment_max < pw_max) pw_max = increment_max;
14907 }
14908 }
14909 else if (attack_mode == ATTACK_MODE_HYBRID1)
14910 {
14911 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14912
14913 // display
14914
14915 char *mask = myargv[myargc - 1];
14916
14917 maskcnt = 0;
14918
14919 masks = (char **) mymalloc (1 * sizeof (char *));
14920
14921 // mod
14922
14923 struct stat file_stat;
14924
14925 if (stat (mask, &file_stat) == -1)
14926 {
14927 maskcnt = 1;
14928
14929 masks[maskcnt - 1] = mystrdup (mask);
14930 }
14931 else
14932 {
14933 uint is_file = S_ISREG (file_stat.st_mode);
14934
14935 if (is_file == 1)
14936 {
14937 FILE *mask_fp;
14938
14939 if ((mask_fp = fopen (mask, "r")) == NULL)
14940 {
14941 log_error ("ERROR: %s: %s", mask, strerror (errno));
14942
14943 return (-1);
14944 }
14945
14946 char line_buf[BUFSIZ];
14947
14948 uint masks_avail = 1;
14949
14950 while (!feof (mask_fp))
14951 {
14952 memset (line_buf, 0, BUFSIZ);
14953
14954 int line_len = fgetl (mask_fp, line_buf);
14955
14956 if (line_len == 0) continue;
14957
14958 if (line_buf[0] == '#') continue;
14959
14960 if (masks_avail == maskcnt)
14961 {
14962 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14963
14964 masks_avail += INCR_MASKS;
14965 }
14966
14967 masks[maskcnt] = mystrdup (line_buf);
14968
14969 maskcnt++;
14970 }
14971
14972 fclose (mask_fp);
14973
14974 mask_from_file = 1;
14975 }
14976 else
14977 {
14978 maskcnt = 1;
14979
14980 masks[maskcnt - 1] = mystrdup (mask);
14981 }
14982 }
14983
14984 // base
14985
14986 int wls_left = myargc - (optind + 2);
14987
14988 for (int i = 0; i < wls_left; i++)
14989 {
14990 char *filename = myargv[optind + 1 + i];
14991
14992 struct stat file_stat;
14993
14994 if (stat (filename, &file_stat) == -1)
14995 {
14996 log_error ("ERROR: %s: %s", filename, strerror (errno));
14997
14998 return (-1);
14999 }
15000
15001 uint is_dir = S_ISDIR (file_stat.st_mode);
15002
15003 if (is_dir == 0)
15004 {
15005 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15006
15007 dictcnt++;
15008
15009 dictfiles[dictcnt - 1] = filename;
15010 }
15011 else
15012 {
15013 // do not allow --keyspace w/ a directory
15014
15015 if (keyspace == 1)
15016 {
15017 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15018
15019 return (-1);
15020 }
15021
15022 char **dictionary_files = NULL;
15023
15024 dictionary_files = scan_directory (filename);
15025
15026 if (dictionary_files != NULL)
15027 {
15028 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15029
15030 for (int d = 0; dictionary_files[d] != NULL; d++)
15031 {
15032 char *l1_filename = dictionary_files[d];
15033
15034 struct stat l1_stat;
15035
15036 if (stat (l1_filename, &l1_stat) == -1)
15037 {
15038 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15039
15040 return (-1);
15041 }
15042
15043 if (S_ISREG (l1_stat.st_mode))
15044 {
15045 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15046
15047 dictcnt++;
15048
15049 dictfiles[dictcnt - 1] = strdup (l1_filename);
15050 }
15051 }
15052 }
15053
15054 local_free (dictionary_files);
15055 }
15056 }
15057
15058 if (dictcnt < 1)
15059 {
15060 log_error ("ERROR: No usable dictionary file found.");
15061
15062 return (-1);
15063 }
15064
15065 if (increment)
15066 {
15067 maskcnt = 0;
15068
15069 uint mask_min = increment_min; // we can't reject smaller masks here
15070 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15071
15072 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15073 {
15074 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15075
15076 if (cur_mask == NULL) break;
15077
15078 masks[maskcnt] = cur_mask;
15079
15080 maskcnt++;
15081
15082 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15083 }
15084 }
15085 }
15086 else if (attack_mode == ATTACK_MODE_HYBRID2)
15087 {
15088 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15089
15090 // display
15091
15092 char *mask = myargv[optind + 1 + 0];
15093
15094 maskcnt = 0;
15095
15096 masks = (char **) mymalloc (1 * sizeof (char *));
15097
15098 // mod
15099
15100 struct stat file_stat;
15101
15102 if (stat (mask, &file_stat) == -1)
15103 {
15104 maskcnt = 1;
15105
15106 masks[maskcnt - 1] = mystrdup (mask);
15107 }
15108 else
15109 {
15110 uint is_file = S_ISREG (file_stat.st_mode);
15111
15112 if (is_file == 1)
15113 {
15114 FILE *mask_fp;
15115
15116 if ((mask_fp = fopen (mask, "r")) == NULL)
15117 {
15118 log_error ("ERROR: %s: %s", mask, strerror (errno));
15119
15120 return (-1);
15121 }
15122
15123 char line_buf[BUFSIZ];
15124
15125 uint masks_avail = 1;
15126
15127 while (!feof (mask_fp))
15128 {
15129 memset (line_buf, 0, BUFSIZ);
15130
15131 int line_len = fgetl (mask_fp, line_buf);
15132
15133 if (line_len == 0) continue;
15134
15135 if (line_buf[0] == '#') continue;
15136
15137 if (masks_avail == maskcnt)
15138 {
15139 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15140
15141 masks_avail += INCR_MASKS;
15142 }
15143
15144 masks[maskcnt] = mystrdup (line_buf);
15145
15146 maskcnt++;
15147 }
15148
15149 fclose (mask_fp);
15150
15151 mask_from_file = 1;
15152 }
15153 else
15154 {
15155 maskcnt = 1;
15156
15157 masks[maskcnt - 1] = mystrdup (mask);
15158 }
15159 }
15160
15161 // base
15162
15163 int wls_left = myargc - (optind + 2);
15164
15165 for (int i = 0; i < wls_left; i++)
15166 {
15167 char *filename = myargv[optind + 2 + i];
15168
15169 struct stat file_stat;
15170
15171 if (stat (filename, &file_stat) == -1)
15172 {
15173 log_error ("ERROR: %s: %s", filename, strerror (errno));
15174
15175 return (-1);
15176 }
15177
15178 uint is_dir = S_ISDIR (file_stat.st_mode);
15179
15180 if (is_dir == 0)
15181 {
15182 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15183
15184 dictcnt++;
15185
15186 dictfiles[dictcnt - 1] = filename;
15187 }
15188 else
15189 {
15190 // do not allow --keyspace w/ a directory
15191
15192 if (keyspace == 1)
15193 {
15194 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15195
15196 return (-1);
15197 }
15198
15199 char **dictionary_files = NULL;
15200
15201 dictionary_files = scan_directory (filename);
15202
15203 if (dictionary_files != NULL)
15204 {
15205 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15206
15207 for (int d = 0; dictionary_files[d] != NULL; d++)
15208 {
15209 char *l1_filename = dictionary_files[d];
15210
15211 struct stat l1_stat;
15212
15213 if (stat (l1_filename, &l1_stat) == -1)
15214 {
15215 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15216
15217 return (-1);
15218 }
15219
15220 if (S_ISREG (l1_stat.st_mode))
15221 {
15222 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15223
15224 dictcnt++;
15225
15226 dictfiles[dictcnt - 1] = strdup (l1_filename);
15227 }
15228 }
15229 }
15230
15231 local_free (dictionary_files);
15232 }
15233 }
15234
15235 if (dictcnt < 1)
15236 {
15237 log_error ("ERROR: No usable dictionary file found.");
15238
15239 return (-1);
15240 }
15241
15242 if (increment)
15243 {
15244 maskcnt = 0;
15245
15246 uint mask_min = increment_min; // we can't reject smaller masks here
15247 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15248
15249 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15250 {
15251 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15252
15253 if (cur_mask == NULL) break;
15254
15255 masks[maskcnt] = cur_mask;
15256
15257 maskcnt++;
15258
15259 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15260 }
15261 }
15262 }
15263
15264 data.pw_min = pw_min;
15265 data.pw_max = pw_max;
15266
15267 /**
15268 * weak hash check
15269 */
15270
15271 if (weak_hash_threshold >= salts_cnt)
15272 {
15273 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15274
15275 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15276 {
15277 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15278 }
15279 }
15280
15281 // Display hack, guarantee that there is at least one \r before real start
15282
15283 if (data.quiet == 0) log_info_nn ("");
15284
15285 /**
15286 * status and monitor threads
15287 */
15288
15289 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15290
15291 hc_thread_t i_thread = 0;
15292
15293 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15294 {
15295 hc_thread_create (i_thread, thread_keypress, &benchmark);
15296 }
15297
15298 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15299
15300 uint ni_threads_cnt = 0;
15301
15302 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15303
15304 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15305
15306 ni_threads_cnt++;
15307
15308 /**
15309 * Outfile remove
15310 */
15311
15312 if (keyspace == 0)
15313 {
15314 if (outfile_check_timer != 0)
15315 {
15316 if (data.outfile_check_directory != NULL)
15317 {
15318 if ((hash_mode != 5200) &&
15319 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15320 (hash_mode != 9000))
15321 {
15322 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15323
15324 ni_threads_cnt++;
15325 }
15326 else
15327 {
15328 outfile_check_timer = 0;
15329 }
15330 }
15331 else
15332 {
15333 outfile_check_timer = 0;
15334 }
15335 }
15336 }
15337
15338 /**
15339 * Inform the user if we got some hashes remove because of the pot file remove feature
15340 */
15341
15342 if (data.quiet == 0)
15343 {
15344 if (potfile_remove_cracks > 0)
15345 {
15346 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15347 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15348 }
15349 }
15350
15351 data.outfile_check_timer = outfile_check_timer;
15352
15353 /**
15354 * main loop
15355 */
15356
15357 char **induction_dictionaries = NULL;
15358
15359 int induction_dictionaries_cnt = 0;
15360
15361 hcstat_table_t *root_table_buf = NULL;
15362 hcstat_table_t *markov_table_buf = NULL;
15363
15364 uint initial_restore_done = 0;
15365
15366 data.maskcnt = maskcnt;
15367
15368 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15369 {
15370 if (data.devices_status == STATUS_CRACKED) break;
15371
15372 data.devices_status = STATUS_INIT;
15373
15374 if (maskpos > rd->maskpos)
15375 {
15376 rd->dictpos = 0;
15377 }
15378
15379 rd->maskpos = maskpos;
15380 data.maskpos = maskpos;
15381
15382 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15383 {
15384 char *mask = masks[maskpos];
15385
15386 if (mask_from_file == 1)
15387 {
15388 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15389
15390 char *str_ptr;
15391 uint str_pos;
15392
15393 uint mask_offset = 0;
15394
15395 uint separator_cnt;
15396
15397 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15398 {
15399 str_ptr = strstr (mask + mask_offset, ",");
15400
15401 if (str_ptr == NULL) break;
15402
15403 str_pos = str_ptr - mask;
15404
15405 // escaped separator, i.e. "\,"
15406
15407 if (str_pos > 0)
15408 {
15409 if (mask[str_pos - 1] == '\\')
15410 {
15411 separator_cnt --;
15412
15413 mask_offset = str_pos + 1;
15414
15415 continue;
15416 }
15417 }
15418
15419 // reset the offset
15420
15421 mask_offset = 0;
15422
15423 mask[str_pos] = '\0';
15424
15425 switch (separator_cnt)
15426 {
15427 case 0:
15428 mp_reset_usr (mp_usr, 0);
15429
15430 custom_charset_1 = mask;
15431 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15432 break;
15433
15434 case 1:
15435 mp_reset_usr (mp_usr, 1);
15436
15437 custom_charset_2 = mask;
15438 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15439 break;
15440
15441 case 2:
15442 mp_reset_usr (mp_usr, 2);
15443
15444 custom_charset_3 = mask;
15445 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15446 break;
15447
15448 case 3:
15449 mp_reset_usr (mp_usr, 3);
15450
15451 custom_charset_4 = mask;
15452 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15453 break;
15454 }
15455
15456 mask = mask + str_pos + 1;
15457 }
15458 }
15459
15460 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15461 {
15462 if (maskpos > 0)
15463 {
15464 local_free (css_buf);
15465 local_free (data.root_css_buf);
15466 local_free (data.markov_css_buf);
15467
15468 local_free (masks[maskpos - 1]);
15469 }
15470
15471 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15472
15473 data.mask = mask;
15474 data.css_cnt = css_cnt;
15475 data.css_buf = css_buf;
15476
15477 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15478
15479 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15480
15481 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15482
15483 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15484 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15485
15486 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15487
15488 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15489
15490 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15491 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15492
15493 data.root_css_buf = root_css_buf;
15494 data.markov_css_buf = markov_css_buf;
15495
15496 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15497
15498 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15499
15500 local_free (root_table_buf);
15501 local_free (markov_table_buf);
15502
15503 // args
15504
15505 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15506 {
15507 hc_device_param_t *device_param = &data.devices_param[device_id];
15508
15509 device_param->kernel_params_mp[0] = &device_param->d_combs;
15510 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15511 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15512
15513 device_param->kernel_params_mp_buf64[3] = 0;
15514 device_param->kernel_params_mp_buf32[4] = css_cnt;
15515 device_param->kernel_params_mp_buf32[5] = 0;
15516 device_param->kernel_params_mp_buf32[6] = 0;
15517 device_param->kernel_params_mp_buf32[7] = 0;
15518
15519 if (attack_mode == ATTACK_MODE_HYBRID1)
15520 {
15521 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15522 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15523 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15524 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15525 }
15526 else if (attack_mode == ATTACK_MODE_HYBRID2)
15527 {
15528 device_param->kernel_params_mp_buf32[5] = 0;
15529 device_param->kernel_params_mp_buf32[6] = 0;
15530 device_param->kernel_params_mp_buf32[7] = 0;
15531 }
15532
15533 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15534 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15535 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15536
15537 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15538 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15539 }
15540 }
15541 else if (attack_mode == ATTACK_MODE_BF)
15542 {
15543 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15544
15545 if (increment)
15546 {
15547 for (uint i = 0; i < dictcnt; i++)
15548 {
15549 local_free (dictfiles[i]);
15550 }
15551
15552 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15553 {
15554 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15555
15556 if (l1_filename == NULL) break;
15557
15558 dictcnt++;
15559
15560 dictfiles[dictcnt - 1] = l1_filename;
15561 }
15562 }
15563 else
15564 {
15565 dictcnt++;
15566
15567 dictfiles[dictcnt - 1] = mask;
15568 }
15569
15570 if (dictcnt == 0)
15571 {
15572 log_error ("ERROR: Mask is too small");
15573
15574 return (-1);
15575 }
15576 }
15577 }
15578
15579 free (induction_dictionaries);
15580
15581 // induction_dictionaries_cnt = 0; // implied
15582
15583 if (attack_mode != ATTACK_MODE_BF)
15584 {
15585 if (keyspace == 0)
15586 {
15587 induction_dictionaries = scan_directory (induction_directory);
15588
15589 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15590 }
15591 }
15592
15593 if (induction_dictionaries_cnt)
15594 {
15595 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15596 }
15597
15598 /**
15599 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15600 */
15601 if (keyspace == 1)
15602 {
15603 if ((maskcnt > 1) || (dictcnt > 1))
15604 {
15605 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15606
15607 return (-1);
15608 }
15609 }
15610
15611 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15612 {
15613 char *subid = logfile_generate_subid ();
15614
15615 data.subid = subid;
15616
15617 logfile_sub_msg ("START");
15618
15619 data.devices_status = STATUS_INIT;
15620
15621 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15622 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15623 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15624
15625 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15626
15627 data.cpt_pos = 0;
15628
15629 data.cpt_start = time (NULL);
15630
15631 data.cpt_total = 0;
15632
15633 if (data.restore == 0)
15634 {
15635 rd->words_cur = skip;
15636
15637 skip = 0;
15638
15639 data.skip = 0;
15640 }
15641
15642 data.ms_paused = 0;
15643
15644 data.words_cur = rd->words_cur;
15645
15646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15647 {
15648 hc_device_param_t *device_param = &data.devices_param[device_id];
15649
15650 device_param->speed_pos = 0;
15651
15652 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15653 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15654 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15655
15656 device_param->kernel_power = device_param->kernel_power_user;
15657 device_param->kernel_blocks = device_param->kernel_blocks_user;
15658
15659 device_param->outerloop_pos = 0;
15660 device_param->outerloop_left = 0;
15661 device_param->innerloop_pos = 0;
15662 device_param->innerloop_left = 0;
15663
15664 // some more resets:
15665
15666 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15667
15668 memset (device_param->pws_buf, 0, device_param->size_pws);
15669
15670 device_param->pw_cnt = 0;
15671 device_param->pws_cnt = 0;
15672
15673 device_param->words_off = 0;
15674 device_param->words_done = 0;
15675 }
15676
15677 data.kernel_blocks_div = 0;
15678
15679 // figure out some workload
15680
15681 if (attack_mode == ATTACK_MODE_STRAIGHT)
15682 {
15683 if (data.wordlist_mode == WL_MODE_FILE)
15684 {
15685 char *dictfile = NULL;
15686
15687 if (induction_dictionaries_cnt)
15688 {
15689 dictfile = induction_dictionaries[0];
15690 }
15691 else
15692 {
15693 dictfile = dictfiles[dictpos];
15694 }
15695
15696 data.dictfile = dictfile;
15697
15698 logfile_sub_string (dictfile);
15699
15700 for (uint i = 0; i < rp_files_cnt; i++)
15701 {
15702 logfile_sub_var_string ("rulefile", rp_files[i]);
15703 }
15704
15705 FILE *fd2 = fopen (dictfile, "rb");
15706
15707 if (fd2 == NULL)
15708 {
15709 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15710
15711 return (-1);
15712 }
15713
15714 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15715
15716 fclose (fd2);
15717
15718 if (data.words_cnt == 0)
15719 {
15720 if (data.devices_status == STATUS_CRACKED) break;
15721 if (data.devices_status == STATUS_ABORTED) break;
15722
15723 dictpos++;
15724
15725 continue;
15726 }
15727 }
15728 }
15729 else if (attack_mode == ATTACK_MODE_COMBI)
15730 {
15731 char *dictfile = data.dictfile;
15732 char *dictfile2 = data.dictfile2;
15733
15734 logfile_sub_string (dictfile);
15735 logfile_sub_string (dictfile2);
15736
15737 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15738 {
15739 FILE *fd2 = fopen (dictfile, "rb");
15740
15741 if (fd2 == NULL)
15742 {
15743 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15744
15745 return (-1);
15746 }
15747
15748 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15749
15750 fclose (fd2);
15751 }
15752 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15753 {
15754 FILE *fd2 = fopen (dictfile2, "rb");
15755
15756 if (fd2 == NULL)
15757 {
15758 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15759
15760 return (-1);
15761 }
15762
15763 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15764
15765 fclose (fd2);
15766 }
15767
15768 if (data.words_cnt == 0)
15769 {
15770 if (data.devices_status == STATUS_CRACKED) break;
15771 if (data.devices_status == STATUS_ABORTED) break;
15772
15773 dictpos++;
15774
15775 continue;
15776 }
15777 }
15778 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15779 {
15780 char *dictfile = NULL;
15781
15782 if (induction_dictionaries_cnt)
15783 {
15784 dictfile = induction_dictionaries[0];
15785 }
15786 else
15787 {
15788 dictfile = dictfiles[dictpos];
15789 }
15790
15791 data.dictfile = dictfile;
15792
15793 char *mask = data.mask;
15794
15795 logfile_sub_string (dictfile);
15796 logfile_sub_string (mask);
15797
15798 FILE *fd2 = fopen (dictfile, "rb");
15799
15800 if (fd2 == NULL)
15801 {
15802 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15803
15804 return (-1);
15805 }
15806
15807 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15808
15809 fclose (fd2);
15810
15811 if (data.words_cnt == 0)
15812 {
15813 if (data.devices_status == STATUS_CRACKED) break;
15814 if (data.devices_status == STATUS_ABORTED) break;
15815
15816 dictpos++;
15817
15818 continue;
15819 }
15820 }
15821 else if (attack_mode == ATTACK_MODE_BF)
15822 {
15823 local_free (css_buf);
15824 local_free (data.root_css_buf);
15825 local_free (data.markov_css_buf);
15826
15827 char *mask = dictfiles[dictpos];
15828
15829 logfile_sub_string (mask);
15830
15831 // base
15832
15833 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15834
15835 if (opts_type & OPTS_TYPE_PT_UNICODE)
15836 {
15837 uint css_cnt_unicode = css_cnt * 2;
15838
15839 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15840
15841 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15842 {
15843 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15844
15845 css_buf_unicode[j + 1].cs_buf[0] = 0;
15846 css_buf_unicode[j + 1].cs_len = 1;
15847 }
15848
15849 free (css_buf);
15850
15851 css_buf = css_buf_unicode;
15852 css_cnt = css_cnt_unicode;
15853 }
15854
15855 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15856
15857 uint mask_min = pw_min;
15858 uint mask_max = pw_max;
15859
15860 if (opts_type & OPTS_TYPE_PT_UNICODE)
15861 {
15862 mask_min *= 2;
15863 mask_max *= 2;
15864 }
15865
15866 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15867 {
15868 if (css_cnt < mask_min)
15869 {
15870 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15871 }
15872
15873 if (css_cnt > mask_max)
15874 {
15875 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15876 }
15877
15878 // skip to next mask
15879
15880 dictpos++;
15881
15882 rd->dictpos = dictpos;
15883
15884 logfile_sub_msg ("STOP");
15885
15886 continue;
15887 }
15888
15889 uint save_css_cnt = css_cnt;
15890
15891 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15892 {
15893 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15894 {
15895 uint salt_len = (uint) data.salts_buf[0].salt_len;
15896 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15897
15898 uint css_cnt_salt = css_cnt + salt_len;
15899
15900 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15901
15902 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15903
15904 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15905 {
15906 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15907 css_buf_salt[j].cs_len = 1;
15908 }
15909
15910 free (css_buf);
15911
15912 css_buf = css_buf_salt;
15913 css_cnt = css_cnt_salt;
15914 }
15915 }
15916
15917 data.mask = mask;
15918 data.css_cnt = css_cnt;
15919 data.css_buf = css_buf;
15920
15921 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15922
15923 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15924
15925 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15926
15927 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15928
15929 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15930 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15931
15932 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15933
15934 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15935
15936 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15937 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15938
15939 data.root_css_buf = root_css_buf;
15940 data.markov_css_buf = markov_css_buf;
15941
15942 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15943
15944 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15945
15946 local_free (root_table_buf);
15947 local_free (markov_table_buf);
15948
15949 // copy + args
15950
15951 uint css_cnt_l = css_cnt;
15952 uint css_cnt_r;
15953
15954 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15955 {
15956 if (save_css_cnt < 6)
15957 {
15958 css_cnt_r = 1;
15959 }
15960 else if (save_css_cnt == 6)
15961 {
15962 css_cnt_r = 2;
15963 }
15964 else
15965 {
15966 if (opts_type & OPTS_TYPE_PT_UNICODE)
15967 {
15968 if (save_css_cnt == 8 || save_css_cnt == 10)
15969 {
15970 css_cnt_r = 2;
15971 }
15972 else
15973 {
15974 css_cnt_r = 4;
15975 }
15976 }
15977 else
15978 {
15979 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15980 {
15981 css_cnt_r = 3;
15982 }
15983 else
15984 {
15985 css_cnt_r = 4;
15986 }
15987 }
15988 }
15989 }
15990 else
15991 {
15992 css_cnt_r = 1;
15993
15994 /* unfinished code?
15995 int sum = css_buf[css_cnt_r - 1].cs_len;
15996
15997 for (uint i = 1; i < 4 && i < css_cnt; i++)
15998 {
15999 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16000
16001 css_cnt_r++;
16002
16003 sum *= css_buf[css_cnt_r - 1].cs_len;
16004 }
16005 */
16006 }
16007
16008 css_cnt_l -= css_cnt_r;
16009
16010 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16011
16012 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16013 {
16014 hc_device_param_t *device_param = &data.devices_param[device_id];
16015
16016 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16017 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16018 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16019
16020 device_param->kernel_params_mp_l_buf64[3] = 0;
16021 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16022 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16023 device_param->kernel_params_mp_l_buf32[6] = 0;
16024 device_param->kernel_params_mp_l_buf32[7] = 0;
16025 device_param->kernel_params_mp_l_buf32[8] = 0;
16026
16027 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16028 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16029 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16030 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16031
16032 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16033 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16034 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16035
16036 device_param->kernel_params_mp_r_buf64[3] = 0;
16037 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16038 device_param->kernel_params_mp_r_buf32[5] = 0;
16039 device_param->kernel_params_mp_r_buf32[6] = 0;
16040 device_param->kernel_params_mp_r_buf32[7] = 0;
16041
16042 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
16043 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
16044 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
16045
16046 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
16047 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
16048 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
16049
16050 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16051 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16052 }
16053 }
16054
16055 uint64_t words_base = data.words_cnt;
16056
16057 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16058 {
16059 if (data.kernel_rules_cnt)
16060 {
16061 words_base /= data.kernel_rules_cnt;
16062 }
16063 }
16064 else if (data.attack_kern == ATTACK_KERN_COMBI)
16065 {
16066 if (data.combs_cnt)
16067 {
16068 words_base /= data.combs_cnt;
16069 }
16070 }
16071 else if (data.attack_kern == ATTACK_KERN_BF)
16072 {
16073 if (data.bfs_cnt)
16074 {
16075 words_base /= data.bfs_cnt;
16076 }
16077 }
16078
16079 data.words_base = words_base;
16080
16081 if (keyspace == 1)
16082 {
16083 log_info ("%llu", (unsigned long long int) words_base);
16084
16085 return (0);
16086 }
16087
16088 if (data.words_cur > data.words_base)
16089 {
16090 log_error ("ERROR: restore value greater keyspace");
16091
16092 return (-1);
16093 }
16094
16095 if (data.words_cur)
16096 {
16097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16098 {
16099 for (uint i = 0; i < data.salts_cnt; i++)
16100 {
16101 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16102 }
16103 }
16104 else if (data.attack_kern == ATTACK_KERN_COMBI)
16105 {
16106 for (uint i = 0; i < data.salts_cnt; i++)
16107 {
16108 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16109 }
16110 }
16111 else if (data.attack_kern == ATTACK_KERN_BF)
16112 {
16113 for (uint i = 0; i < data.salts_cnt; i++)
16114 {
16115 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16116 }
16117 }
16118 }
16119
16120 /*
16121 * Inform user about possible slow speeds
16122 */
16123
16124 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16125 {
16126 if (data.words_base < kernel_blocks_all)
16127 {
16128 if (quiet == 0)
16129 {
16130 log_info ("");
16131 log_info ("ATTENTION!");
16132 log_info (" The wordlist or mask you are using is too small.");
16133 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16134 log_info (" The cracking speed will drop.");
16135 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16136 log_info ("");
16137 }
16138 }
16139 }
16140
16141 /*
16142 * Update loopback file
16143 */
16144
16145 if (loopback == 1)
16146 {
16147 time_t now;
16148
16149 time (&now);
16150
16151 uint random_num = get_random_num (0, 9999);
16152
16153 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16154
16155 data.loopback_file = loopback_file;
16156 }
16157
16158 /*
16159 * Update dictionary statistic
16160 */
16161
16162 if (keyspace == 0)
16163 {
16164 dictstat_fp = fopen (dictstat, "wb");
16165
16166 if (dictstat_fp)
16167 {
16168 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16169
16170 fclose (dictstat_fp);
16171 }
16172 }
16173
16174 data.devices_status = STATUS_RUNNING;
16175
16176 if (initial_restore_done == 0)
16177 {
16178 if (data.restore_disable == 0) cycle_restore ();
16179
16180 initial_restore_done = 1;
16181 }
16182
16183 hc_timer_set (&data.timer_running);
16184
16185 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16186 {
16187 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16188 {
16189 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16190 if (quiet == 0) fflush (stdout);
16191 }
16192 }
16193 else if (wordlist_mode == WL_MODE_STDIN)
16194 {
16195 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16196 if (data.quiet == 0) log_info ("");
16197 }
16198
16199 time_t runtime_start;
16200
16201 time (&runtime_start);
16202
16203 data.runtime_start = runtime_start;
16204
16205 /**
16206 * create cracker threads
16207 */
16208
16209 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16210
16211 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16212 {
16213 hc_device_param_t *device_param = &devices_param[device_id];
16214
16215 device_param->device_id = device_id;
16216
16217 if (wordlist_mode == WL_MODE_STDIN)
16218 {
16219 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16220 }
16221 else
16222 {
16223 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16224 }
16225 }
16226
16227 // wait for crack threads to exit
16228
16229 hc_thread_wait (devices_cnt, c_threads);
16230
16231 local_free (c_threads);
16232
16233 data.restore = 0;
16234
16235 // finalize task
16236
16237 logfile_sub_var_uint ("status-after-work", data.devices_status);
16238
16239 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16240
16241 if (data.devices_status == STATUS_CRACKED) break;
16242 if (data.devices_status == STATUS_ABORTED) break;
16243
16244 if (data.devices_status == STATUS_BYPASS)
16245 {
16246 data.devices_status = STATUS_RUNNING;
16247 }
16248
16249 if (induction_dictionaries_cnt)
16250 {
16251 unlink (induction_dictionaries[0]);
16252 }
16253
16254 free (induction_dictionaries);
16255
16256 if (attack_mode != ATTACK_MODE_BF)
16257 {
16258 induction_dictionaries = scan_directory (induction_directory);
16259
16260 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16261 }
16262
16263 if (benchmark == 0)
16264 {
16265 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16266 {
16267 if (quiet == 0) clear_prompt ();
16268
16269 if (quiet == 0) log_info ("");
16270
16271 if (status == 1)
16272 {
16273 status_display ();
16274 }
16275 else
16276 {
16277 if (quiet == 0) status_display ();
16278 }
16279
16280 if (quiet == 0) log_info ("");
16281 }
16282 }
16283
16284 if (attack_mode == ATTACK_MODE_BF)
16285 {
16286 dictpos++;
16287
16288 rd->dictpos = dictpos;
16289 }
16290 else
16291 {
16292 if (induction_dictionaries_cnt)
16293 {
16294 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16295 }
16296 else
16297 {
16298 dictpos++;
16299
16300 rd->dictpos = dictpos;
16301 }
16302 }
16303
16304 time_t runtime_stop;
16305
16306 time (&runtime_stop);
16307
16308 data.runtime_stop = runtime_stop;
16309
16310 logfile_sub_uint (runtime_start);
16311 logfile_sub_uint (runtime_stop);
16312
16313 logfile_sub_msg ("STOP");
16314
16315 global_free (subid);
16316 }
16317
16318 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16319
16320 if (data.devices_status == STATUS_CRACKED) break;
16321 if (data.devices_status == STATUS_ABORTED) break;
16322 if (data.devices_status == STATUS_QUIT) break;
16323
16324 if (data.devices_status == STATUS_BYPASS)
16325 {
16326 data.devices_status = STATUS_RUNNING;
16327 }
16328 }
16329
16330 // 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
16331
16332 if (attack_mode == ATTACK_MODE_STRAIGHT)
16333 {
16334 if (data.wordlist_mode == WL_MODE_FILE)
16335 {
16336 if (data.dictfile == NULL)
16337 {
16338 if (dictfiles != NULL)
16339 {
16340 data.dictfile = dictfiles[0];
16341
16342 hc_timer_set (&data.timer_running);
16343 }
16344 }
16345 }
16346 }
16347 // NOTE: combi is okay because it is already set beforehand
16348 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16349 {
16350 if (data.dictfile == NULL)
16351 {
16352 if (dictfiles != NULL)
16353 {
16354 hc_timer_set (&data.timer_running);
16355
16356 data.dictfile = dictfiles[0];
16357 }
16358 }
16359 }
16360 else if (attack_mode == ATTACK_MODE_BF)
16361 {
16362 if (data.mask == NULL)
16363 {
16364 hc_timer_set (&data.timer_running);
16365
16366 data.mask = masks[0];
16367 }
16368 }
16369
16370 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16371 {
16372 data.devices_status = STATUS_EXHAUSTED;
16373 }
16374
16375 // if cracked / aborted remove last induction dictionary
16376
16377 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16378 {
16379 struct stat induct_stat;
16380
16381 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16382 {
16383 unlink (induction_dictionaries[file_pos]);
16384 }
16385 }
16386
16387 // wait for non-interactive threads
16388
16389 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16390 {
16391 hc_thread_wait (1, &ni_threads[thread_idx]);
16392 }
16393
16394 local_free (ni_threads);
16395
16396 // wait for interactive threads
16397
16398 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16399 {
16400 hc_thread_wait (1, &i_thread);
16401 }
16402
16403 // we dont need restore file anymore
16404 if (data.restore_disable == 0)
16405 {
16406 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16407 {
16408 unlink (eff_restore_file);
16409 unlink (new_restore_file);
16410 }
16411 else
16412 {
16413 cycle_restore ();
16414 }
16415 }
16416
16417 // finally save left hashes
16418
16419 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16420 {
16421 save_hash ();
16422 }
16423
16424 /**
16425 * Clean up
16426 */
16427
16428 if (benchmark == 1)
16429 {
16430 status_benchmark ();
16431
16432 log_info ("");
16433 }
16434 else
16435 {
16436 if (quiet == 0) clear_prompt ();
16437
16438 if (quiet == 0) log_info ("");
16439
16440 if (status == 1)
16441 {
16442 status_display ();
16443 }
16444 else
16445 {
16446 if (quiet == 0) status_display ();
16447 }
16448
16449 if (quiet == 0) log_info ("");
16450 }
16451
16452 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16453 {
16454 hc_device_param_t *device_param = &data.devices_param[device_id];
16455
16456 local_free (device_param->result);
16457
16458 local_free (device_param->pw_caches);
16459
16460 local_free (device_param->combs_buf);
16461
16462 local_free (device_param->hooks_buf);
16463
16464 local_free (device_param->device_name);
16465
16466 local_free (device_param->device_name_chksum);
16467
16468 local_free (device_param->device_version);
16469
16470 local_free (device_param->driver_version);
16471
16472 if (device_param->pws_buf) myfree (device_param->pws_buf);
16473 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16474 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16475 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16476 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16477 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16478 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16479 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16480 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16481 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16482 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16483 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16484 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16485 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16486 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16487 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16488 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16489 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16490 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16491 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16492 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16493 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16494 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16495 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16496 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16497 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16498 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16499 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16500 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16501
16502 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16503 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16504 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16505 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16506 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16507 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16508 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16509 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16510 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16511 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16512 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16513 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16514
16515 if (device_param->program) hc_clReleaseProgram (device_param->program);
16516 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16517 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16518 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16519
16520 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16521 if (device_param->context) hc_clReleaseContext (device_param->context);
16522 }
16523
16524 // reset default fan speed
16525
16526 if (gpu_temp_disable == 0)
16527 {
16528 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16529 {
16530 hc_thread_mutex_lock (mux_adl);
16531
16532 for (uint i = 0; i < data.devices_cnt; i++)
16533 {
16534 if (data.hm_device[i].fan_supported == 1)
16535 {
16536 int fanspeed = temp_retain_fanspeed_value[i];
16537
16538 if (fanspeed == -1) continue;
16539
16540 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16541
16542 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16543 }
16544 }
16545
16546 hc_thread_mutex_unlock (mux_adl);
16547 }
16548 }
16549
16550 // reset power tuning
16551
16552 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16553 {
16554 hc_thread_mutex_lock (mux_adl);
16555
16556 for (uint i = 0; i < data.devices_cnt; i++)
16557 {
16558 if (data.hm_device[i].od_version == 6)
16559 {
16560 // check powertune capabilities first, if not available then skip device
16561
16562 int powertune_supported = 0;
16563
16564 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16565 {
16566 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16567
16568 return (-1);
16569 }
16570
16571 if (powertune_supported != 0)
16572 {
16573 // powercontrol settings
16574
16575 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16576 {
16577 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16578
16579 return (-1);
16580 }
16581
16582 // clocks
16583
16584 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16585
16586 performance_state->iNumberOfPerformanceLevels = 2;
16587
16588 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16589 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16590 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16591 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16592
16593 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16594 {
16595 log_info ("ERROR: Failed to restore ADL performance state");
16596
16597 return (-1);
16598 }
16599
16600 local_free (performance_state);
16601 }
16602 }
16603 }
16604
16605 hc_thread_mutex_unlock (mux_adl);
16606 }
16607
16608 if (gpu_temp_disable == 0)
16609 {
16610 if (vendor_id == VENDOR_ID_NV)
16611 {
16612 #ifdef LINUX
16613 hc_NVML_nvmlShutdown (data.hm_dll);
16614 #endif
16615
16616 #ifdef WIN
16617 NvAPI_Unload ();
16618 #endif
16619 }
16620
16621 if (vendor_id == VENDOR_ID_AMD)
16622 {
16623 hc_ADL_Main_Control_Destroy (data.hm_dll);
16624
16625 hm_close (data.hm_dll);
16626 }
16627
16628 #ifdef LINUX
16629 if (vendor_id == VENDOR_ID_NV)
16630 {
16631 hm_close (data.hm_dll);
16632 }
16633 #endif
16634 }
16635
16636 // free memory
16637
16638 local_free (masks);
16639
16640 local_free (dictstat_base);
16641
16642 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16643 {
16644 pot_t *pot_ptr = &pot[pot_pos];
16645
16646 hash_t *hash = &pot_ptr->hash;
16647
16648 local_free (hash->digest);
16649
16650 if (isSalted)
16651 {
16652 local_free (hash->salt);
16653 }
16654 }
16655
16656 local_free (pot);
16657
16658 local_free (all_kernel_rules_cnt);
16659 local_free (all_kernel_rules_buf);
16660
16661 local_free (wl_data->buf);
16662 local_free (wl_data);
16663
16664 local_free (bitmap_s1_a);
16665 local_free (bitmap_s1_b);
16666 local_free (bitmap_s1_c);
16667 local_free (bitmap_s1_d);
16668 local_free (bitmap_s2_a);
16669 local_free (bitmap_s2_b);
16670 local_free (bitmap_s2_c);
16671 local_free (bitmap_s2_d);
16672
16673 local_free (temp_retain_fanspeed_value);
16674 local_free (od_clock_mem_status);
16675 local_free (od_power_control_status);
16676
16677 global_free (devices_param);
16678
16679 global_free (kernel_rules_buf);
16680
16681 global_free (root_css_buf);
16682 global_free (markov_css_buf);
16683
16684 global_free (digests_buf);
16685 global_free (digests_shown);
16686 global_free (digests_shown_tmp);
16687
16688 global_free (salts_buf);
16689 global_free (salts_shown);
16690
16691 global_free (esalts_buf);
16692
16693 global_free (words_progress_done);
16694 global_free (words_progress_rejected);
16695 global_free (words_progress_restored);
16696
16697 if (pot_fp) fclose (pot_fp);
16698
16699 if (data.devices_status == STATUS_QUIT) break;
16700 }
16701
16702 // destroy others mutex
16703
16704 hc_thread_mutex_delete (mux_dispatcher);
16705 hc_thread_mutex_delete (mux_counter);
16706 hc_thread_mutex_delete (mux_display);
16707 hc_thread_mutex_delete (mux_adl);
16708
16709 // free memory
16710
16711 local_free (eff_restore_file);
16712 local_free (new_restore_file);
16713
16714 local_free (rd);
16715
16716 // loopback
16717
16718 local_free (loopback_file);
16719
16720 if (loopback == 1) unlink (loopback_file);
16721
16722 // induction directory
16723
16724 if (induction_dir == NULL)
16725 {
16726 if (attack_mode != ATTACK_MODE_BF)
16727 {
16728 if (rmdir (induction_directory) == -1)
16729 {
16730 if (errno == ENOENT)
16731 {
16732 // good, we can ignore
16733 }
16734 else if (errno == ENOTEMPTY)
16735 {
16736 // good, we can ignore
16737 }
16738 else
16739 {
16740 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16741
16742 return (-1);
16743 }
16744 }
16745
16746 local_free (induction_directory);
16747 }
16748 }
16749
16750 // outfile-check directory
16751
16752 if (outfile_check_dir == NULL)
16753 {
16754 if (rmdir (outfile_check_directory) == -1)
16755 {
16756 if (errno == ENOENT)
16757 {
16758 // good, we can ignore
16759 }
16760 else if (errno == ENOTEMPTY)
16761 {
16762 // good, we can ignore
16763 }
16764 else
16765 {
16766 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16767
16768 return (-1);
16769 }
16770 }
16771
16772 local_free (outfile_check_directory);
16773 }
16774
16775 time_t proc_stop;
16776
16777 time (&proc_stop);
16778
16779 logfile_top_uint (proc_start);
16780 logfile_top_uint (proc_stop);
16781
16782 logfile_top_msg ("STOP");
16783
16784 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16785 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16786
16787 if (data.devices_status == STATUS_ABORTED) return 2;
16788 if (data.devices_status == STATUS_QUIT) return 2;
16789 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16790 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16791 if (data.devices_status == STATUS_CRACKED) return 0;
16792
16793 return -1;
16794 }
Hashcat additions to support pwdhash