projects / hashcat.git / blob
? search:


2bdc17ceaae1659eba9ed89fbbcbb5378c8efc59
[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_gpu_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.01";
13 const uint VERSION_BIN = 201;
14 const uint RESTORE_MIN = 201;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 // comment-out for kernel source mode
22
23 //#define BINARY_KERNEL
24
25 #define USAGE 0
26 #define VERSION 0
27 #define QUIET 0
28 #define MARKOV_THRESHOLD 0
29 #define MARKOV_DISABLE 0
30 #define MARKOV_CLASSIC 0
31 #define BENCHMARK 0
32 #define BENCHMARK_MODE 1
33 #define RESTORE 0
34 #define RESTORE_TIMER 60
35 #define RESTORE_DISABLE 0
36 #define STATUS 0
37 #define STATUS_TIMER 10
38 #define STATUS_AUTOMAT 0
39 #define LOOPBACK 0
40 #define WEAK_HASH_THRESHOLD 100
41 #define SHOW 0
42 #define LEFT 0
43 #define USERNAME 0
44 #define REMOVE 0
45 #define REMOVE_TIMER 60
46 #define SKIP 0
47 #define LIMIT 0
48 #define KEYSPACE 0
49 #define POTFILE_DISABLE 0
50 #define DEBUG_MODE 0
51 #define RP_GEN 0
52 #define RP_GEN_FUNC_MIN 1
53 #define RP_GEN_FUNC_MAX 4
54 #define RP_GEN_SEED 0
55 #define RULE_BUF_L ":"
56 #define RULE_BUF_R ":"
57 #define FORCE 0
58 #define RUNTIME 0
59 #define HEX_CHARSET 0
60 #define HEX_SALT 0
61 #define HEX_WORDLIST 0
62 #define OUTFILE_FORMAT 3
63 #define OUTFILE_AUTOHEX 1
64 #define OUTFILE_CHECK_TIMER 5
65 #define ATTACK_MODE 0
66 #define HASH_MODE 0
67 #define SEGMENT_SIZE 32
68 #define INCREMENT 0
69 #define INCREMENT_MIN 1
70 #define INCREMENT_MAX PW_MAX
71 #define SEPARATOR ':'
72 #define BITMAP_MIN 16
73 #define BITMAP_MAX 24
74 #define GPU_TEMP_DISABLE 0
75 #define GPU_TEMP_ABORT 90
76 #define GPU_TEMP_RETAIN 80
77 #define WORKLOAD_PROFILE 2
78 #define GPU_ACCEL 0
79 #define GPU_LOOPS 0
80 #define GPU_RULES 1024
81 #define GPU_COMBS 1024
82 #define GPU_BFS 1024
83 #define GPU_THREADS 64
84 #define POWERTUNE_ENABLE 0
85 #define LOGFILE_DISABLE 0
86 #define SCRYPT_TMTO 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_ON_CPU 10
123 #define ATTACK_EXEC_ON_GPU 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 900,
154 0,
155 5100,
156 100,
157 1400,
158 10800,
159 1700,
160 5000,
161 10100,
162 6000,
163 6100,
164 6900,
165 11700,
166 11800,
167 400,
168 8900,
169 11900,
170 12000,
171 10900,
172 12100,
173 23,
174 2500,
175 5300,
176 5400,
177 5500,
178 5600,
179 7300,
180 7500,
181 8300,
182 11100,
183 11200,
184 11400,
185 121,
186 2611,
187 2711,
188 2811,
189 8400,
190 11,
191 2612,
192 7900,
193 21,
194 11000,
195 124,
196 10000,
197 3711,
198 7600,
199 12,
200 131,
201 132,
202 1731,
203 200,
204 300,
205 3100,
206 112,
207 12300,
208 8000,
209 141,
210 1441,
211 1600,
212 12600,
213 1421,
214 101,
215 111,
216 1711,
217 3000,
218 1000,
219 1100,
220 2100,
221 12800,
222 1500,
223 12400,
224 500,
225 3200,
226 7400,
227 1800,
228 122,
229 1722,
230 7100,
231 6300,
232 6700,
233 6400,
234 6500,
235 2400,
236 2410,
237 5700,
238 9200,
239 9300,
240 22,
241 501,
242 5800,
243 8100,
244 8500,
245 7200,
246 9900,
247 7700,
248 7800,
249 10300,
250 8600,
251 8700,
252 9100,
253 133,
254 11600,
255 12500,
256 6211,
257 6221,
258 6231,
259 6241,
260 8800,
261 12200,
262 9700,
263 9710,
264 9800,
265 9810,
266 9400,
267 9500,
268 9600,
269 10400,
270 10410,
271 10500,
272 10600,
273 10700,
274 9000,
275 5200,
276 6800,
277 6600,
278 8200,
279 11300,
280 12700
281 };
282
283 /**
284 * types
285 */
286
287 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
288
289 /**
290 * globals
291 */
292
293 static unsigned int full01 = 0x01010101;
294 static unsigned int full80 = 0x80808080;
295
296 int SUPPRESS_OUTPUT = 0;
297
298 hc_thread_mutex_t mux_adl;
299 hc_thread_mutex_t mux_counter;
300 hc_thread_mutex_t mux_dispatcher;
301 hc_thread_mutex_t mux_display;
302
303 hc_global_data_t data;
304
305 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
306
307 const char *USAGE_MINI[] =
308 {
309 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
310 "",
311 "Try --help for more help.",
312 NULL
313 };
314
315 const char *USAGE_BIG[] =
316 {
317 "%s, advanced password recovery",
318 "",
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "=======",
322 "Options",
323 "=======",
324 "",
325 "* General:",
326 "",
327 " -m, --hash-type=NUM Hash-type, see references below",
328 " -a, --attack-mode=NUM Attack-mode, see references below",
329 " -V, --version Print version",
330 " -h, --help Print help",
331 " --quiet Suppress output",
332 "",
333 "* Benchmark:",
334 "",
335 " -b, --benchmark Run benchmark",
336 " --benchmark-mode=NUM Benchmark-mode, see references below",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
387 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
388 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
389 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
390 " -d, --gpu-devices=STR Devices to use, separate with comma",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* Outfile Formats:",
445 "",
446 " 1 = hash[:salt]",
447 " 2 = plain",
448 " 3 = hash[:salt]:plain",
449 " 4 = hex_plain",
450 " 5 = hash[:salt]:hex_plain",
451 " 6 = plain:hex_plain",
452 " 7 = hash[:salt]:plain:hex_plain",
453 " 8 = crackpos",
454 " 9 = hash[:salt]:crackpos",
455 " 10 = plain:crackpos",
456 " 11 = hash[:salt]:plain:crackpos",
457 " 12 = hex_plain:crackpos",
458 " 13 = hash[:salt]:hex_plain:crackpos",
459 " 14 = plain:hex_plain:crackpos",
460 " 15 = hash[:salt]:plain:hex_plain:crackpos",
461 "",
462 "* Debug mode output formats (for hybrid mode only, by using rules):",
463 "",
464 " 1 = save finding rule",
465 " 2 = save original word",
466 " 3 = save original word and finding rule",
467 " 4 = save original word, finding rule and modified plain",
468 "",
469 "* Built-in charsets:",
470 "",
471 " ?l = abcdefghijklmnopqrstuvwxyz",
472 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
473 " ?d = 0123456789",
474 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
475 " ?a = ?l?u?d?s",
476 " ?b = 0x00 - 0xff",
477 "",
478 "* Attack modes:",
479 "",
480 " 0 = Straight",
481 " 1 = Combination",
482 " 3 = Brute-force",
483 " 6 = Hybrid dict + mask",
484 " 7 = Hybrid mask + dict",
485 "",
486 "* Hash types:",
487 "",
488 "[[ Roll-your-own: Raw Hashes ]]",
489 "",
490 " 900 = MD4",
491 " 0 = MD5",
492 " 5100 = Half MD5",
493 " 100 = SHA1",
494 " 10800 = SHA-384",
495 " 1400 = SHA-256",
496 " 1700 = SHA-512",
497 " 5000 = SHA-3(Keccak)",
498 " 10100 = SipHash",
499 " 6000 = RipeMD160",
500 " 6100 = Whirlpool",
501 " 6900 = GOST R 34.11-94",
502 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
503 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
504 "",
505 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
506 "",
507 " 10 = md5($pass.$salt)",
508 " 20 = md5($salt.$pass)",
509 " 30 = md5(unicode($pass).$salt)",
510 " 40 = md5($salt.unicode($pass))",
511 " 3800 = md5($salt.$pass.$salt)",
512 " 3710 = md5($salt.md5($pass))",
513 " 2600 = md5(md5($pass)",
514 " 4300 = md5(strtoupper(md5($pass)))",
515 " 4400 = md5(sha1($pass))",
516 " 110 = sha1($pass.$salt)",
517 " 120 = sha1($salt.$pass)",
518 " 130 = sha1(unicode($pass).$salt)",
519 " 140 = sha1($salt.unicode($pass))",
520 " 4500 = sha1(sha1($pass)",
521 " 4700 = sha1(md5($pass))",
522 " 4900 = sha1($salt.$pass.$salt)",
523 " 1410 = sha256($pass.$salt)",
524 " 1420 = sha256($salt.$pass)",
525 " 1430 = sha256(unicode($pass).$salt)",
526 " 1440 = sha256($salt.unicode($pass))",
527 " 1710 = sha512($pass.$salt)",
528 " 1720 = sha512($salt.$pass)",
529 " 1730 = sha512(unicode($pass).$salt)",
530 " 1740 = sha512($salt.unicode($pass))",
531 "",
532 "[[ Roll-your-own: Authenticated Hashes ]]",
533 "",
534 " 50 = HMAC-MD5 (key = $pass)",
535 " 60 = HMAC-MD5 (key = $salt)",
536 " 150 = HMAC-SHA1 (key = $pass)",
537 " 160 = HMAC-SHA1 (key = $salt)",
538 " 1450 = HMAC-SHA256 (key = $pass)",
539 " 1460 = HMAC-SHA256 (key = $salt)",
540 " 1750 = HMAC-SHA512 (key = $pass)",
541 " 1760 = HMAC-SHA512 (key = $salt)",
542 "",
543 "[[ Generic KDF ]]",
544 "",
545 " 400 = phpass",
546 " 8900 = scrypt",
547 " 11900 = PBKDF2-HMAC-MD5",
548 " 12000 = PBKDF2-HMAC-SHA1",
549 " 10900 = PBKDF2-HMAC-SHA256",
550 " 12100 = PBKDF2-HMAC-SHA512",
551 "",
552 "[[ Network protocols, Challenge-Response ]]",
553 "",
554 " 23 = Skype",
555 " 2500 = WPA/WPA2",
556 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
557 " 5300 = IKE-PSK MD5",
558 " 5400 = IKE-PSK SHA1",
559 " 5500 = NetNTLMv1",
560 " 5500 = NetNTLMv1 + ESS",
561 " 5600 = NetNTLMv2",
562 " 7300 = IPMI2 RAKP HMAC-SHA1",
563 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
564 " 8300 = DNSSEC (NSEC3)",
565 " 10200 = Cram MD5",
566 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
567 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
568 " 11400 = SIP digest authentication (MD5)",
569 "",
570 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
571 "",
572 " 121 = SMF (Simple Machines Forum)",
573 " 400 = phpBB3",
574 " 2611 = vBulletin < v3.8.5",
575 " 2711 = vBulletin > v3.8.5",
576 " 2811 = MyBB",
577 " 2811 = IPB (Invison Power Board)",
578 " 8400 = WBB3 (Woltlab Burning Board)",
579 " 11 = Joomla < 2.5.18",
580 " 400 = Joomla > 2.5.18",
581 " 400 = Wordpress",
582 " 2612 = PHPS",
583 " 7900 = Drupal7",
584 " 21 = osCommerce",
585 " 21 = xt:Commerce",
586 " 11000 = PrestaShop",
587 " 124 = Django (SHA-1)",
588 " 10000 = Django (PBKDF2-SHA256)",
589 " 3711 = Mediawiki B type",
590 " 7600 = Redmine",
591 "",
592 "[[ Database Server ]]",
593 "",
594 " 12 = PostgreSQL",
595 " 131 = MSSQL(2000)",
596 " 132 = MSSQL(2005)",
597 " 1731 = MSSQL(2012)",
598 " 1731 = MSSQL(2014)",
599 " 200 = MySQL323",
600 " 300 = MySQL4.1/MySQL5",
601 " 3100 = Oracle H: Type (Oracle 7+)",
602 " 112 = Oracle S: Type (Oracle 11+)",
603 " 12300 = Oracle T: Type (Oracle 12+)",
604 " 8000 = Sybase ASE",
605 "",
606 "[[ HTTP, SMTP, LDAP Server]]",
607 "",
608 " 141 = EPiServer 6.x < v4",
609 " 1441 = EPiServer 6.x > v4",
610 " 1600 = Apache $apr1$",
611 " 12600 = ColdFusion 10+",
612 " 1421 = hMailServer",
613 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
614 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
615 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
616 "",
617 "[[ Checksums ]]",
618 "",
619 " 11500 = CRC32",
620 "",
621 "[[ Operating-Systems ]]",
622 "",
623 " 3000 = LM",
624 " 1000 = NTLM",
625 " 1100 = Domain Cached Credentials (DCC), MS Cache",
626 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
627 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
628 " 1500 = descrypt, DES(Unix), Traditional DES",
629 " 12400 = BSDiCrypt, Extended DES",
630 " 500 = md5crypt $1$, MD5(Unix)",
631 " 3200 = bcrypt $2*$, Blowfish(Unix)",
632 " 7400 = sha256crypt $5$, SHA256(Unix)",
633 " 1800 = sha512crypt $6$, SHA512(Unix)",
634 " 122 = OSX v10.4",
635 " 122 = OSX v10.5",
636 " 122 = OSX v10.6",
637 " 1722 = OSX v10.7",
638 " 7100 = OSX v10.8",
639 " 7100 = OSX v10.9",
640 " 7100 = OSX v10.10",
641 " 6300 = AIX {smd5}",
642 " 6700 = AIX {ssha1}",
643 " 6400 = AIX {ssha256}",
644 " 6500 = AIX {ssha512}",
645 " 2400 = Cisco-PIX",
646 " 2410 = Cisco-ASA",
647 " 500 = Cisco-IOS $1$",
648 " 5700 = Cisco-IOS $4$",
649 " 9200 = Cisco-IOS $8$",
650 " 9300 = Cisco-IOS $9$",
651 " 22 = Juniper Netscreen/SSG (ScreenOS)",
652 " 501 = Juniper IVE",
653 " 5800 = Android PIN",
654 " 8100 = Citrix Netscaler",
655 " 8500 = RACF",
656 " 7200 = GRUB 2",
657 " 9900 = Radmin2",
658 "",
659 "[[ Enterprise Application Software (EAS) ]]",
660 "",
661 " 7700 = SAP CODVN B (BCODE)",
662 " 7800 = SAP CODVN F/G (PASSCODE)",
663 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
664 " 8600 = Lotus Notes/Domino 5",
665 " 8700 = Lotus Notes/Domino 6",
666 " 9100 = Lotus Notes/Domino 8",
667 " 133 = PeopleSoft",
668 "",
669 "[[ Archives ]]",
670 "",
671 " 11600 = 7-Zip",
672 " 12500 = RAR3-hp",
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 " 12200 = eCryptfs",
686 "",
687 "[[ Documents ]]",
688 "",
689 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
690 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
691 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
692 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
693 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
694 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
695 " 9400 = MS Office 2007",
696 " 9500 = MS Office 2010",
697 " 9600 = MS Office 2013",
698 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
699 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
700 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
701 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
702 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
703 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
704 "",
705 "[[ Password Managers ]]",
706 "",
707 " 9000 = Password Safe v2",
708 " 5200 = Password Safe v3",
709 " 6800 = Lastpass",
710 " 6600 = 1Password, agilekeychain",
711 " 8200 = 1Password, cloudkeychain",
712 " 11300 = Bitcoin/Litecoin wallet.dat",
713 " 12700 = Blockchain, My Wallet",
714 "",
715 NULL
716 };
717
718 /**
719 * oclHashcat specific functions
720 */
721
722 void status_display_automat ()
723 {
724 FILE *out = stdout;
725
726 fprintf (out, "STATUS\t%u\t", data.devices_status);
727
728 /**
729 * speed new
730 */
731
732 fprintf (out, "SPEED\t");
733
734 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
735 {
736 hc_device_param_t *device_param = &data.devices_param[device_id];
737
738 uint64_t speed_cnt = 0;
739 float speed_ms = 0;
740
741 for (int i = 0; i < SPEED_CACHE; i++)
742 {
743 float rec_ms;
744
745 hc_timer_get (device_param->speed_rec[i], rec_ms);
746
747 if (rec_ms > SPEED_MAXAGE) continue;
748
749 speed_cnt += device_param->speed_cnt[i];
750 speed_ms += device_param->speed_ms[i];
751 }
752
753 speed_cnt /= SPEED_CACHE;
754 speed_ms /= SPEED_CACHE;
755
756 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
757 }
758
759 /**
760 * words_cur
761 */
762
763 uint64_t words_cur = get_lowest_words_done ();
764
765 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
766
767 /**
768 * counter
769 */
770
771 uint salts_left = data.salts_cnt - data.salts_done;
772
773 if (salts_left == 0) salts_left = 1;
774
775 uint64_t progress_total = data.words_cnt * salts_left;
776
777 uint64_t all_done = 0;
778 uint64_t all_rejected = 0;
779 uint64_t all_restored = 0;
780
781 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
782 {
783 if (salts_left > 1)
784 {
785 // otherwise the final cracked status shows 0/XXX progress
786
787 if (data.salts_shown[salt_pos] == 1) continue;
788 }
789
790 all_done += data.words_progress_done[salt_pos];
791 all_rejected += data.words_progress_rejected[salt_pos];
792 all_restored += data.words_progress_restored[salt_pos];
793 }
794
795 uint64_t progress_cur = all_restored + all_done + all_rejected;
796 uint64_t progress_end = progress_total;
797
798 uint64_t progress_skip = 0;
799
800 if (data.skip)
801 {
802 progress_skip = MIN (data.skip, data.words_base) * salts_left;
803
804 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
805 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
806 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
807 }
808
809 if (data.limit)
810 {
811 progress_end = MIN (data.limit, data.words_base) * salts_left;
812
813 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
814 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
815 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
816 }
817
818 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
819 uint64_t progress_end_relative_skip = progress_end - progress_skip;
820
821 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
822
823 /**
824 * cracks
825 */
826
827 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
828 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
829
830 /**
831 * temperature
832 */
833
834 if (data.gpu_temp_disable == 0)
835 {
836 fprintf (out, "TEMP\t");
837
838 hc_thread_mutex_lock (mux_adl);
839
840 for (uint i = 0; i < data.devices_cnt; i++)
841 {
842 int temp = hm_get_temperature_with_device_id (i);
843
844 fprintf (out, "%d\t", temp);
845 }
846
847 hc_thread_mutex_unlock (mux_adl);
848 }
849
850 #ifdef _WIN
851 fputc ('\r', out);
852 fputc ('\n', out);
853 #endif
854
855 #ifdef _POSIX
856 fputc ('\n', out);
857 #endif
858
859 fflush (out);
860 }
861
862 void status_display ()
863 {
864 if (data.devices_status == STATUS_INIT) return;
865 if (data.devices_status == STATUS_STARTING) return;
866 if (data.devices_status == STATUS_BYPASS) return;
867
868 if (data.status_automat == 1)
869 {
870 status_display_automat ();
871
872 return;
873 }
874
875 char tmp_buf[1000];
876
877 uint tmp_len = 0;
878
879 log_info ("Session.Name...: %s", data.session);
880
881 char *status_type = strstatus (data.devices_status);
882
883 uint hash_mode = data.hash_mode;
884
885 char *hash_type = strhashtype (hash_mode); // not a bug
886
887 log_info ("Status.........: %s", status_type);
888
889 /**
890 * show rules
891 */
892
893 if (data.rp_files_cnt)
894 {
895 uint i;
896
897 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
898 {
899 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
900 }
901
902 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
903
904 log_info ("Rules.Type.....: %s", tmp_buf);
905
906 tmp_len = 0;
907 }
908
909 if (data.rp_gen)
910 {
911 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
912
913 if (data.rp_gen_seed)
914 {
915 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
916 }
917 }
918
919 /**
920 * show input
921 */
922
923 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
924 {
925 if (data.wordlist_mode == WL_MODE_FILE)
926 {
927 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
928 }
929 else if (data.wordlist_mode == WL_MODE_STDIN)
930 {
931 log_info ("Input.Mode.....: Pipe");
932 }
933 }
934 else if (data.attack_mode == ATTACK_MODE_COMBI)
935 {
936 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
937 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
938 }
939 else if (data.attack_mode == ATTACK_MODE_BF)
940 {
941 char *mask = data.mask;
942
943 if (mask != NULL)
944 {
945 uint mask_len = data.css_cnt;
946
947 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
948
949 if (mask_len > 0)
950 {
951 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
952 {
953 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
954 {
955 mask_len -= data.salts_buf[0].salt_len;
956 }
957 }
958
959 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
960
961 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
962 }
963
964 if (data.maskcnt > 1)
965 {
966 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
967
968 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
969 }
970
971 log_info ("Input.Mode.....: %s", tmp_buf);
972 }
973
974 tmp_len = 0;
975 }
976 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
977 {
978 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
979 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
980 }
981 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
982 {
983 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
984 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
985 }
986
987 if (data.digests_cnt == 1)
988 {
989 if (data.hash_mode == 2500)
990 {
991 wpa_t *wpa = (wpa_t *) data.esalts_buf;
992
993 uint pke[25];
994
995 char *pke_ptr = (char *) pke;
996
997 for (uint i = 0; i < 25; i++)
998 {
999 pke[i] = byte_swap_32 (wpa->pke[i]);
1000 }
1001
1002 char mac1[6];
1003 char mac2[6];
1004
1005 memcpy (mac1, pke_ptr + 23, 6);
1006 memcpy (mac2, pke_ptr + 29, 6);
1007
1008 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1009 (char *) data.salts_buf[0].salt_buf,
1010 mac1[0] & 0xff,
1011 mac1[1] & 0xff,
1012 mac1[2] & 0xff,
1013 mac1[3] & 0xff,
1014 mac1[4] & 0xff,
1015 mac1[5] & 0xff,
1016 mac2[0] & 0xff,
1017 mac2[1] & 0xff,
1018 mac2[2] & 0xff,
1019 mac2[3] & 0xff,
1020 mac2[4] & 0xff,
1021 mac2[5] & 0xff);
1022 }
1023 else if (data.hash_mode == 5200)
1024 {
1025 log_info ("Hash.Target....: File (%s)", data.hashfile);
1026 }
1027 else if (data.hash_mode == 9000)
1028 {
1029 log_info ("Hash.Target....: File (%s)", data.hashfile);
1030 }
1031 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1032 {
1033 log_info ("Hash.Target....: File (%s)", data.hashfile);
1034 }
1035 else
1036 {
1037 char out_buf[4096];
1038
1039 ascii_digest (out_buf, 0, 0);
1040
1041 // limit length
1042 if (strlen (out_buf) > 40)
1043 {
1044 out_buf[41] = '.';
1045 out_buf[42] = '.';
1046 out_buf[43] = '.';
1047 out_buf[44] = 0;
1048 }
1049
1050 log_info ("Hash.Target....: %s", out_buf);
1051 }
1052 }
1053 else
1054 {
1055 if (data.hash_mode == 3000)
1056 {
1057 char out_buf1[4096];
1058 char out_buf2[4096];
1059
1060 ascii_digest (out_buf1, 0, 0);
1061 ascii_digest (out_buf2, 0, 1);
1062
1063 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1064 }
1065 else
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 }
1070
1071 log_info ("Hash.Type......: %s", hash_type);
1072
1073 /**
1074 * speed new
1075 */
1076
1077 uint64_t speed_cnt[DEVICES_MAX];
1078 float speed_ms[DEVICES_MAX];
1079
1080 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1081 {
1082 hc_device_param_t *device_param = &data.devices_param[device_id];
1083
1084 // we need to clear values (set to 0) because in case the gpu does
1085 // not get new candidates it idles around but speed display would
1086 // show it as working.
1087 // if we instantly set it to 0 after reading it happens that the
1088 // speed can be shown as zero if the users refreshs to fast.
1089 // therefore, we add a timestamp when a stat was recorded and if its
1090 // to old we will not use it
1091
1092 speed_cnt[device_id] = 0;
1093 speed_ms[device_id] = 0;
1094
1095 for (int i = 0; i < SPEED_CACHE; i++)
1096 {
1097 float rec_ms;
1098
1099 hc_timer_get (device_param->speed_rec[i], rec_ms);
1100
1101 if (rec_ms > SPEED_MAXAGE) continue;
1102
1103 speed_cnt[device_id] += device_param->speed_cnt[i];
1104 speed_ms[device_id] += device_param->speed_ms[i];
1105 }
1106
1107 speed_cnt[device_id] /= SPEED_CACHE;
1108 speed_ms[device_id] /= SPEED_CACHE;
1109 }
1110
1111 float hashes_all_ms = 0;
1112
1113 float hashes_dev_ms[DEVICES_MAX];
1114
1115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1116 {
1117 hashes_dev_ms[device_id] = 0;
1118
1119 if (speed_ms[device_id])
1120 {
1121 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1122
1123 hashes_all_ms += hashes_dev_ms[device_id];
1124 }
1125 }
1126
1127 /**
1128 * timers
1129 */
1130
1131 float ms_running = 0;
1132
1133 hc_timer_get (data.timer_running, ms_running);
1134
1135 float ms_paused = data.ms_paused;
1136
1137 if (data.devices_status == STATUS_PAUSED)
1138 {
1139 float ms_paused_tmp = 0;
1140
1141 hc_timer_get (data.timer_paused, ms_paused_tmp);
1142
1143 ms_paused += ms_paused_tmp;
1144 }
1145
1146 #ifdef WIN
1147
1148 __time64_t sec_run = ms_running / 1000;
1149
1150 #else
1151
1152 time_t sec_run = ms_running / 1000;
1153
1154 #endif
1155
1156 if (sec_run)
1157 {
1158 char display_run[32];
1159
1160 struct tm tm_run;
1161
1162 struct tm *tmp;
1163
1164 #ifdef WIN
1165
1166 tmp = _gmtime64 (&sec_run);
1167
1168 #else
1169
1170 tmp = gmtime (&sec_run);
1171
1172 #endif
1173
1174 if (tmp != NULL)
1175 {
1176 memcpy (&tm_run, tmp, sizeof (struct tm));
1177
1178 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1179
1180 char *start = ctime (&data.proc_start);
1181
1182 size_t start_len = strlen (start);
1183
1184 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1185 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1186
1187 log_info ("Time.Started...: %s (%s)", start, display_run);
1188 }
1189 }
1190 else
1191 {
1192 log_info ("Time.Started...: 0 secs");
1193 }
1194
1195 /**
1196 * counters
1197 */
1198
1199 uint salts_left = data.salts_cnt - data.salts_done;
1200
1201 if (salts_left == 0) salts_left = 1;
1202
1203 uint64_t progress_total = data.words_cnt * salts_left;
1204
1205 uint64_t all_done = 0;
1206 uint64_t all_rejected = 0;
1207 uint64_t all_restored = 0;
1208
1209 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1210 {
1211 if (salts_left > 1)
1212 {
1213 // otherwise the final cracked status shows 0/XXX progress
1214
1215 if (data.salts_shown[salt_pos] == 1) continue;
1216 }
1217
1218 all_done += data.words_progress_done[salt_pos];
1219 all_rejected += data.words_progress_rejected[salt_pos];
1220 all_restored += data.words_progress_restored[salt_pos];
1221 }
1222
1223 uint64_t progress_cur = all_restored + all_done + all_rejected;
1224 uint64_t progress_end = progress_total;
1225
1226 uint64_t progress_skip = 0;
1227
1228 if (data.skip)
1229 {
1230 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1231
1232 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1233 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1235 }
1236
1237 if (data.limit)
1238 {
1239 progress_end = MIN (data.limit, data.words_base) * salts_left;
1240
1241 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1244 }
1245
1246 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1247 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1248
1249 float speed_ms_real = ms_running - ms_paused;
1250 uint64_t speed_plains_real = all_done;
1251
1252 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1253 {
1254 if (data.devices_status != STATUS_CRACKED)
1255 {
1256 uint64_t words_per_ms = 0;
1257
1258 if (speed_plains_real && speed_ms_real)
1259 {
1260 words_per_ms = speed_plains_real / speed_ms_real;
1261 }
1262
1263 #ifdef WIN
1264 __time64_t sec_etc = 0;
1265 #else
1266 time_t sec_etc = 0;
1267 #endif
1268
1269 if (words_per_ms)
1270 {
1271 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1272
1273 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1274
1275 sec_etc = ms_left / 1000;
1276 }
1277
1278 if (sec_etc == 0)
1279 {
1280 log_info ("Time.Estimated.: 0 secs");
1281 }
1282 else if ((uint64_t) sec_etc > ETC_MAX)
1283 {
1284 log_info ("Time.Estimated.: > 10 Years");
1285 }
1286 else
1287 {
1288 char display_etc[32];
1289
1290 struct tm tm_etc;
1291
1292 struct tm *tmp;
1293
1294 #ifdef WIN
1295
1296 tmp = _gmtime64 (&sec_etc);
1297
1298 #else
1299
1300 tmp = gmtime (&sec_etc);
1301
1302 #endif
1303
1304 if (tmp != NULL)
1305 {
1306 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1307
1308 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1309
1310 time_t now;
1311
1312 time (&now);
1313
1314 now += sec_etc;
1315
1316 char *etc = ctime (&now);
1317
1318 size_t etc_len = strlen (etc);
1319
1320 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1321 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1322
1323 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1324 }
1325 }
1326 }
1327 }
1328
1329 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1330 {
1331 char display_dev_cur[16];
1332
1333 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1334
1335 strncpy (display_dev_cur, "0.00", 4);
1336
1337 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1338
1339 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1340 }
1341
1342 char display_all_cur[16];
1343
1344 memset (display_all_cur, 0, sizeof (display_all_cur));
1345
1346 strncpy (display_all_cur, "0.00", 4);
1347
1348 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1349
1350 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1351
1352 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1353 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1354
1355 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);
1356
1357 // crack-per-time
1358
1359 if (data.digests_cnt > 100)
1360 {
1361 time_t now = time (NULL);
1362
1363 int cpt_cur_min = 0;
1364 int cpt_cur_hour = 0;
1365 int cpt_cur_day = 0;
1366
1367 for (int i = 0; i < CPT_BUF; i++)
1368 {
1369 const uint cracked = data.cpt_buf[i].cracked;
1370 const time_t timestamp = data.cpt_buf[i].timestamp;
1371
1372 if ((timestamp + 60) > now)
1373 {
1374 cpt_cur_min += cracked;
1375 }
1376
1377 if ((timestamp + 3600) > now)
1378 {
1379 cpt_cur_hour += cracked;
1380 }
1381
1382 if ((timestamp + 86400) > now)
1383 {
1384 cpt_cur_day += cracked;
1385 }
1386 }
1387
1388 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1389 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1390 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1391
1392 if ((data.cpt_start + 86400) < now)
1393 {
1394 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1395 cpt_cur_min,
1396 cpt_cur_hour,
1397 cpt_cur_day,
1398 cpt_avg_min,
1399 cpt_avg_hour,
1400 cpt_avg_day);
1401 }
1402 else if ((data.cpt_start + 3600) < now)
1403 {
1404 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1405 cpt_cur_min,
1406 cpt_cur_hour,
1407 cpt_avg_min,
1408 cpt_avg_hour,
1409 cpt_avg_day);
1410 }
1411 else if ((data.cpt_start + 60) < now)
1412 {
1413 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1414 cpt_cur_min,
1415 cpt_avg_min,
1416 cpt_avg_hour,
1417 cpt_avg_day);
1418 }
1419 else
1420 {
1421 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1422 cpt_avg_min,
1423 cpt_avg_hour,
1424 cpt_avg_day);
1425 }
1426 }
1427
1428 // Restore point
1429
1430 uint64_t restore_point = get_lowest_words_done ();
1431
1432 uint64_t restore_total = data.words_base;
1433
1434 float percent_restore = 0;
1435
1436 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1437
1438 if (progress_end_relative_skip)
1439 {
1440 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1441 {
1442 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1443 float percent_rejected = 0.0;
1444
1445 if (progress_cur)
1446 {
1447 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1448 }
1449
1450 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);
1451 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1452
1453 if (data.restore_disable == 0)
1454 {
1455 if (percent_finished != 1)
1456 {
1457 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1458 }
1459 }
1460 }
1461 }
1462 else
1463 {
1464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1465 {
1466 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1467 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468
1469 if (data.restore_disable == 0)
1470 {
1471 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1472 }
1473 }
1474 else
1475 {
1476 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1477 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1478
1479 // --restore not allowed if stdin is used -- really? why?
1480
1481 //if (data.restore_disable == 0)
1482 //{
1483 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1484 //}
1485 }
1486 }
1487
1488 if (data.gpu_temp_disable == 0)
1489 {
1490 hc_thread_mutex_lock (mux_adl);
1491
1492 for (uint i = 0; i < data.devices_cnt; i++)
1493 {
1494 if (data.hm_device[i].fan_supported == 1)
1495 {
1496 const int temperature = hm_get_temperature_with_device_id (i);
1497 const int utilization = hm_get_utilization_with_device_id (i);
1498 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1499
1500 if (data.vendor_id == VENDOR_ID_AMD)
1501 {
1502 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1503 }
1504
1505 if (data.vendor_id == VENDOR_ID_NV)
1506 {
1507 #ifdef LINUX
1508 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1509 #else
1510 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1511 #endif
1512 }
1513 }
1514 else
1515 {
1516 const int temperature = hm_get_temperature_with_device_id (i);
1517 const int utilization = hm_get_utilization_with_device_id (i);
1518
1519 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1520 }
1521 }
1522
1523 hc_thread_mutex_unlock (mux_adl);
1524 }
1525 }
1526
1527 static void status_benchmark ()
1528 {
1529 if (data.devices_status == STATUS_INIT) return;
1530 if (data.devices_status == STATUS_STARTING) return;
1531
1532 if (data.words_cnt == 0) return;
1533
1534 uint64_t speed_cnt[DEVICES_MAX];
1535 float speed_ms[DEVICES_MAX];
1536
1537 uint device_id;
1538
1539 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1540 {
1541 hc_device_param_t *device_param = &data.devices_param[device_id];
1542
1543 speed_cnt[device_id] = 0;
1544 speed_ms[device_id] = 0;
1545
1546 for (int i = 0; i < SPEED_CACHE; i++)
1547 {
1548 speed_cnt[device_id] += device_param->speed_cnt[i];
1549 speed_ms[device_id] += device_param->speed_ms[i];
1550 }
1551
1552 speed_cnt[device_id] /= SPEED_CACHE;
1553 speed_ms[device_id] /= SPEED_CACHE;
1554 }
1555
1556 float hashes_all_ms = 0;
1557
1558 float hashes_dev_ms[DEVICES_MAX];
1559
1560 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1561 {
1562 hashes_dev_ms[device_id] = 0;
1563
1564 if (speed_ms[device_id])
1565 {
1566 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1567
1568 hashes_all_ms += hashes_dev_ms[device_id];
1569 }
1570 }
1571
1572 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1573 {
1574 char display_dev_cur[16];
1575
1576 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1577
1578 strncpy (display_dev_cur, "0.00", 4);
1579
1580 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1581
1582 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1583 }
1584
1585 char display_all_cur[16];
1586
1587 memset (display_all_cur, 0, sizeof (display_all_cur));
1588
1589 strncpy (display_all_cur, "0.00", 4);
1590
1591 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1592
1593 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1594 }
1595
1596 /**
1597 * oclHashcat -only- functions
1598 */
1599
1600 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1601 {
1602 if (attack_exec == ATTACK_EXEC_ON_GPU)
1603 {
1604 if (attack_kern == ATTACK_KERN_STRAIGHT)
1605 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1606 else if (attack_kern == ATTACK_KERN_COMBI)
1607 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1608 else if (attack_kern == ATTACK_KERN_BF)
1609 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1610 }
1611 else
1612 snprintf (kernel_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1613 }
1614
1615 static uint convert_from_hex (char *line_buf, const uint line_len)
1616 {
1617 if (line_len & 1) return (line_len); // not in hex
1618
1619 if (data.hex_wordlist == 1)
1620 {
1621 uint i;
1622 uint j;
1623
1624 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1625 {
1626 line_buf[i] = hex_to_char (&line_buf[j]);
1627 }
1628
1629 memset (line_buf + i, 0, line_len - i);
1630
1631 return (i);
1632 }
1633 else if (line_len >= 6) // $HEX[] = 6
1634 {
1635 if (line_buf[0] != '$') return (line_len);
1636 if (line_buf[1] != 'H') return (line_len);
1637 if (line_buf[2] != 'E') return (line_len);
1638 if (line_buf[3] != 'X') return (line_len);
1639 if (line_buf[4] != '[') return (line_len);
1640 if (line_buf[line_len - 1] != ']') return (line_len);
1641
1642 uint i;
1643 uint j;
1644
1645 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1646 {
1647 line_buf[i] = hex_to_char (&line_buf[j]);
1648 }
1649
1650 memset (line_buf + i, 0, line_len - i);
1651
1652 return (i);
1653 }
1654
1655 return (line_len);
1656 }
1657
1658 static uint count_lines (FILE *fd)
1659 {
1660 uint cnt = 0;
1661
1662 char *buf = (char *) mymalloc (BUFSIZ);
1663
1664 size_t nread_tmp = 0;
1665
1666 char *ptr = buf;
1667
1668 while (!feof (fd))
1669 {
1670 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1671 nread_tmp = nread;
1672
1673 if (nread < 1) continue;
1674
1675 ptr = buf;
1676
1677 do
1678 {
1679 if (*ptr++ == '\n') cnt++;
1680
1681 } while (nread--);
1682 }
1683
1684 // special case (if last line did not contain a newline char ... at the very end of the file)
1685
1686 if (nread_tmp > 3)
1687 {
1688 ptr -= 2;
1689
1690 if (*ptr != '\n')
1691 {
1692 ptr--;
1693
1694 if (*ptr != '\n') // needed ? different on windows systems?
1695 {
1696 cnt++;
1697 }
1698 }
1699 }
1700
1701 myfree (buf);
1702
1703 return cnt;
1704 }
1705
1706 static void clear_prompt ()
1707 {
1708 fputc ('\r', stdout);
1709
1710 for (size_t i = 0; i < strlen (PROMPT); i++)
1711 {
1712 fputc (' ', stdout);
1713 }
1714
1715 fputc ('\r', stdout);
1716
1717 fflush (stdout);
1718 }
1719
1720 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1721 {
1722 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1723 }
1724
1725 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1726 {
1727 char *outfile = data.outfile;
1728 uint quiet = data.quiet;
1729 FILE *pot_fp = data.pot_fp;
1730 uint loopback = data.loopback;
1731 uint debug_mode = data.debug_mode;
1732 char *debug_file = data.debug_file;
1733
1734 char debug_rule_buf[BLOCK_SIZE];
1735 int debug_rule_len = 0; // -1 error
1736 uint debug_plain_len = 0;
1737
1738 unsigned char debug_plain_ptr[BLOCK_SIZE];
1739
1740 // hash
1741
1742 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1743
1744 ascii_digest (out_buf, salt_pos, digest_pos);
1745
1746 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1747
1748 // plain
1749
1750 plain_t plain;
1751
1752 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1753
1754 uint gidvid = plain.gidvid;
1755 uint il_pos = plain.il_pos;
1756
1757 uint64_t crackpos = device_param->words_off;
1758
1759 uint plain_buf[16];
1760
1761 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1762 unsigned int plain_len = 0;
1763
1764 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1765 {
1766 uint64_t gidd = gidvid;
1767 uint64_t gidm = 0;
1768
1769 pw_t pw;
1770
1771 gidd_to_pw_t (device_param, gidd, &pw);
1772
1773 for (int i = 0, j = gidm; i < 16; i++, j++)
1774 {
1775 plain_buf[i] = pw.hi1[0][j];
1776 }
1777
1778 plain_len = pw.pw_len;
1779
1780 const uint off = device_param->innerloop_pos + il_pos;
1781
1782 if (debug_mode > 0)
1783 {
1784 debug_rule_len = 0;
1785
1786 // save rule
1787 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1788 {
1789 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1790
1791 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1792 }
1793
1794 // save plain
1795 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1796 {
1797 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1798
1799 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1800
1801 debug_plain_len = plain_len;
1802 }
1803 }
1804
1805 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1806
1807 crackpos += gidvid;
1808 crackpos *= data.gpu_rules_cnt;
1809 crackpos += device_param->innerloop_pos + il_pos;
1810
1811 if (plain_len > data.pw_max) plain_len = data.pw_max;
1812 }
1813 else if (data.attack_mode == ATTACK_MODE_COMBI)
1814 {
1815 uint64_t gidd = gidvid;
1816 uint64_t gidm = 0;
1817
1818 pw_t pw;
1819
1820 gidd_to_pw_t (device_param, gidd, &pw);
1821
1822 for (int i = 0, j = gidm; i < 16; i++, j++)
1823 {
1824 plain_buf[i] = pw.hi1[0][j];
1825 }
1826
1827 plain_len = pw.pw_len;
1828
1829 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1830 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1831
1832 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1833 {
1834 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1835 }
1836 else
1837 {
1838 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1839
1840 memcpy (plain_ptr, comb_buf, comb_len);
1841 }
1842
1843 plain_len += comb_len;
1844
1845 crackpos += gidvid;
1846 crackpos *= data.combs_cnt;
1847 crackpos += device_param->innerloop_pos + il_pos;
1848
1849 if (data.pw_max != PW_DICTMAX1)
1850 {
1851 if (plain_len > data.pw_max) plain_len = data.pw_max;
1852 }
1853 }
1854 else if (data.attack_mode == ATTACK_MODE_BF)
1855 {
1856 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1857 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1858
1859 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1860 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1861
1862 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1863 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1864
1865 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1866 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1867
1868 plain_len = data.css_cnt;
1869
1870 crackpos += gidvid;
1871 crackpos *= data.bfs_cnt;
1872 crackpos += device_param->innerloop_pos + il_pos;
1873 }
1874 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1875 {
1876 uint64_t gidd = gidvid;
1877 uint64_t gidm = 0;
1878
1879 pw_t pw;
1880
1881 gidd_to_pw_t (device_param, gidd, &pw);
1882
1883 for (int i = 0, j = gidm; i < 16; i++, j++)
1884 {
1885 plain_buf[i] = pw.hi1[0][j];
1886 }
1887
1888 plain_len = pw.pw_len;
1889
1890 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1891
1892 uint start = 0;
1893 uint stop = device_param->kernel_params_mp_buf32[4];
1894
1895 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1896
1897 plain_len += start + stop;
1898
1899 crackpos += gidvid;
1900 crackpos *= data.combs_cnt;
1901 crackpos += device_param->innerloop_pos + il_pos;
1902
1903 if (data.pw_max != PW_DICTMAX1)
1904 {
1905 if (plain_len > data.pw_max) plain_len = data.pw_max;
1906 }
1907 }
1908 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1909 {
1910 uint64_t gidd = gidvid;
1911 uint64_t gidm = 0;
1912
1913 pw_t pw;
1914
1915 gidd_to_pw_t (device_param, gidd, &pw);
1916
1917 for (int i = 0, j = gidm; i < 16; i++, j++)
1918 {
1919 plain_buf[i] = pw.hi1[0][j];
1920 }
1921
1922 plain_len = pw.pw_len;
1923
1924 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1925
1926 uint start = 0;
1927 uint stop = device_param->kernel_params_mp_buf32[4];
1928
1929 memmove (plain_ptr + stop, plain_ptr, plain_len);
1930
1931 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1932
1933 plain_len += start + stop;
1934
1935 crackpos += gidvid;
1936 crackpos *= data.combs_cnt;
1937 crackpos += device_param->innerloop_pos + il_pos;
1938
1939 if (data.pw_max != PW_DICTMAX1)
1940 {
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 }
1944
1945 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1946 {
1947 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1948 {
1949 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1950 {
1951 plain_len = plain_len - data.salts_buf[0].salt_len;
1952 }
1953 }
1954
1955 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
1956 {
1957 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
1958 {
1959 plain_ptr[j] = plain_ptr[i];
1960 }
1961
1962 plain_len = plain_len / 2;
1963 }
1964 }
1965
1966 // if enabled, update also the potfile
1967
1968 if (pot_fp)
1969 {
1970 fprintf (pot_fp, "%s:", out_buf);
1971
1972 format_plain (pot_fp, plain_ptr, plain_len, 1);
1973
1974 fputc ('\n', pot_fp);
1975
1976 fflush (pot_fp);
1977 }
1978
1979 // outfile
1980
1981 FILE *out_fp = NULL;
1982
1983 if (outfile != NULL)
1984 {
1985 if ((out_fp = fopen (outfile, "ab")) == NULL)
1986 {
1987 log_error ("ERROR: %s: %s", outfile, strerror (errno));
1988
1989 out_fp = stdout;
1990 }
1991 }
1992 else
1993 {
1994 out_fp = stdout;
1995
1996 if (quiet == 0) clear_prompt ();
1997 }
1998
1999 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2000
2001 if (outfile != NULL)
2002 {
2003 if (out_fp != stdout)
2004 {
2005 fclose (out_fp);
2006 }
2007 }
2008 else
2009 {
2010 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2011 {
2012 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2013 {
2014 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2015 if (quiet == 0) fflush (stdout);
2016 }
2017 }
2018 }
2019
2020 // loopback
2021
2022 if (loopback)
2023 {
2024 char *loopback_file = data.loopback_file;
2025
2026 FILE *fb_fp = NULL;
2027
2028 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2029 {
2030 format_plain (fb_fp, plain_ptr, plain_len, 1);
2031
2032 fputc ('\n', fb_fp);
2033
2034 fclose (fb_fp);
2035 }
2036 }
2037
2038 // (rule) debug mode
2039
2040 // the next check implies that:
2041 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2042 // - debug_mode > 0
2043
2044 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2045 {
2046 if (debug_rule_len < 0) debug_rule_len = 0;
2047
2048 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2049
2050 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2051
2052 if ((quiet == 0) && (debug_file == NULL))
2053 {
2054 fprintf (stdout, "%s", PROMPT);
2055 fflush (stdout);
2056 }
2057 }
2058 }
2059
2060 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2061 {
2062 salt_t *salt_buf = &data.salts_buf[salt_pos];
2063
2064 int found = 0;
2065
2066 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2067
2068 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2069
2070 if (found == 1)
2071 {
2072 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2073
2074 log_info_nn ("");
2075
2076 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);
2077
2078 uint cpt_cracked = 0;
2079
2080 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2081 {
2082 uint idx = salt_buf->digests_offset + digest_pos;
2083
2084 if (data.digests_shown_tmp[idx] == 0) continue;
2085
2086 if (data.digests_shown[idx] == 1) continue;
2087
2088 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2089 {
2090 data.digests_shown[idx] = 1;
2091
2092 data.digests_done++;
2093
2094 cpt_cracked++;
2095
2096 salt_buf->digests_done++;
2097
2098 if (salt_buf->digests_done == salt_buf->digests_cnt)
2099 {
2100 data.salts_shown[salt_pos] = 1;
2101
2102 data.salts_done++;
2103 }
2104 }
2105
2106 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2107
2108 check_hash (device_param, salt_pos, digest_pos);
2109 }
2110
2111 if (cpt_cracked > 0)
2112 {
2113 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2114 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2115
2116 data.cpt_pos++;
2117
2118 data.cpt_total += cpt_cracked;
2119
2120 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2121 }
2122
2123 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2124 {
2125 // we need to reset cracked state on the gpu
2126 // otherwise host thinks again and again the hash was cracked
2127 // and returns invalid password each time
2128
2129 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2130
2131 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);
2132 }
2133
2134 memset (device_param->result, 0, device_param->size_results);
2135
2136 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2137 }
2138 }
2139
2140 static void save_hash ()
2141 {
2142 char *hashfile = data.hashfile;
2143
2144 char new_hashfile[256];
2145 char old_hashfile[256];
2146
2147 memset (new_hashfile, 0, sizeof (new_hashfile));
2148 memset (old_hashfile, 0, sizeof (old_hashfile));
2149
2150 snprintf (new_hashfile, 255, "%s.new", hashfile);
2151 snprintf (old_hashfile, 255, "%s.old", hashfile);
2152
2153 unlink (new_hashfile);
2154
2155 char separator = data.separator;
2156
2157 FILE *fp = fopen (new_hashfile, "wb");
2158
2159 if (fp == NULL)
2160 {
2161 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2162
2163 exit (-1);
2164 }
2165
2166 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2167 {
2168 if (data.salts_shown[salt_pos] == 1) continue;
2169
2170 salt_t *salt_buf = &data.salts_buf[salt_pos];
2171
2172 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2173 {
2174 uint idx = salt_buf->digests_offset + digest_pos;
2175
2176 if (data.digests_shown[idx] == 1) continue;
2177
2178 if (data.hash_mode != 2500)
2179 {
2180 char out_buf[4096];
2181
2182 memset (out_buf, 0, sizeof (out_buf));
2183
2184 if (data.username == 1)
2185 {
2186 user_t *user = data.hash_info[idx]->user;
2187
2188 uint i;
2189
2190 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2191
2192 fputc (separator, fp);
2193 }
2194
2195 ascii_digest (out_buf, salt_pos, digest_pos);
2196
2197 fputs (out_buf, fp);
2198
2199 log_out (fp, "");
2200 }
2201 else
2202 {
2203 hccap_t hccap;
2204
2205 to_hccap_t (&hccap, salt_pos, digest_pos);
2206
2207 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2208 }
2209 }
2210 }
2211
2212 fflush (fp);
2213
2214 fclose (fp);
2215
2216 unlink (old_hashfile);
2217
2218 if (rename (hashfile, old_hashfile) != 0)
2219 {
2220 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2221
2222 exit (-1);
2223 }
2224
2225 unlink (hashfile);
2226
2227 if (rename (new_hashfile, hashfile) != 0)
2228 {
2229 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2230
2231 exit (-1);
2232 }
2233
2234 unlink (old_hashfile);
2235 }
2236
2237 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2238 {
2239 // function called only in case gpu_blocks_all > words_left)
2240
2241 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2242
2243 gpu_blocks_div += gpu_blocks_div / 100;
2244
2245 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2246
2247 while (gpu_blocks_new < total_left)
2248 {
2249 gpu_blocks_div += gpu_blocks_div / 100;
2250
2251 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2252 }
2253
2254 if (data.quiet == 0)
2255 {
2256 clear_prompt ();
2257
2258 log_info ("");
2259
2260 log_info ("INFO: approaching final keyspace, workload adjusted");
2261
2262 log_info ("");
2263
2264 fprintf (stdout, "%s", PROMPT);
2265
2266 fflush (stdout);
2267 }
2268
2269 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2270
2271 return gpu_blocks_div;
2272 }
2273
2274 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2275 {
2276 uint num_elements = num;
2277
2278 device_param->kernel_params_buf32[30] = data.combs_mode;
2279 device_param->kernel_params_buf32[31] = num;
2280
2281 uint gpu_threads = device_param->gpu_threads;
2282
2283 while (num_elements % gpu_threads) num_elements++;
2284
2285 cl_kernel kernel = NULL;
2286
2287 switch (kern_run)
2288 {
2289 case KERN_RUN_1: kernel = device_param->kernel1; break;
2290 case KERN_RUN_12: kernel = device_param->kernel12; break;
2291 case KERN_RUN_2: kernel = device_param->kernel2; break;
2292 case KERN_RUN_23: kernel = device_param->kernel23; break;
2293 case KERN_RUN_3: kernel = device_param->kernel3; break;
2294 }
2295
2296 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2297 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2298 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2299 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2300 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2301 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2302 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2303 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2304 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2305 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2306 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2307
2308 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2309 {
2310 const size_t global_work_size[3] = { num_elements, 32, 1 };
2311 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2312
2313 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2314 }
2315 else
2316 {
2317 const size_t global_work_size[3] = { num_elements, 1, 1 };
2318 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2319
2320 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2321 }
2322
2323 hc_clFlush (device_param->command_queue);
2324
2325 hc_clFinish (device_param->command_queue);
2326 }
2327
2328 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2329 {
2330 uint num_elements = num;
2331
2332 switch (kern_run)
2333 {
2334 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2335 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2336 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2337 }
2338
2339 // causes problems with special threads like in bcrypt
2340 // const uint gpu_threads = device_param->gpu_threads;
2341
2342 const uint gpu_threads = GPU_THREADS;
2343
2344 while (num_elements % gpu_threads) num_elements++;
2345
2346 cl_kernel kernel = NULL;
2347
2348 switch (kern_run)
2349 {
2350 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2351 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2352 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2353 }
2354
2355 switch (kern_run)
2356 {
2357 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2358 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2359 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2360 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2361 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2362 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2363 break;
2364 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2365 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2366 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2367 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2368 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2369 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2370 break;
2371 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2372 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2373 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2374 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2375 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2376 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2377 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2378 break;
2379 }
2380
2381 const size_t global_work_size[3] = { num_elements, 1, 1 };
2382 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2383
2384 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2385
2386 hc_clFlush (device_param->command_queue);
2387
2388 hc_clFinish (device_param->command_queue);
2389 }
2390
2391 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2392 {
2393 uint num_elements = num;
2394
2395 uint gpu_threads = device_param->gpu_threads;
2396
2397 while (num_elements % gpu_threads) num_elements++;
2398
2399 cl_kernel kernel = device_param->kernel_tb;
2400
2401 const size_t global_work_size[3] = { num_elements, 1, 1 };
2402 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2403
2404 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2405
2406 hc_clFlush (device_param->command_queue);
2407
2408 hc_clFinish (device_param->command_queue);
2409 }
2410
2411 static void run_kernel_tm (hc_device_param_t *device_param)
2412 {
2413 const uint num_elements = 1024; // fixed
2414
2415 const uint gpu_threads = 32;
2416
2417 cl_kernel kernel = device_param->kernel_tm;
2418
2419 const size_t global_work_size[3] = { num_elements, 1, 1 };
2420 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2421
2422 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2423
2424 hc_clFlush (device_param->command_queue);
2425
2426 hc_clFinish (device_param->command_queue);
2427 }
2428
2429 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2430 {
2431 uint num_elements = num;
2432
2433 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2434 device_param->kernel_params_amp_buf32[6] = num_elements;
2435
2436 // causes problems with special threads like in bcrypt
2437 // const uint gpu_threads = device_param->gpu_threads;
2438
2439 const uint gpu_threads = GPU_THREADS;
2440
2441 while (num_elements % gpu_threads) num_elements++;
2442
2443 cl_kernel kernel = device_param->kernel_amp;
2444
2445 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2446 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2447
2448 const size_t global_work_size[3] = { num_elements, 1, 1 };
2449 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2450
2451 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2452
2453 hc_clFlush (device_param->command_queue);
2454
2455 hc_clFinish (device_param->command_queue);
2456 }
2457
2458 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2459 {
2460 // not supported with Nvidia
2461 // hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2462
2463 char *tmp = (char *) mymalloc (size);
2464
2465 memset (tmp, 0, size);
2466
2467 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, 0, size, tmp, 0, NULL, NULL);
2468
2469 free (tmp);
2470 }
2471
2472 static int run_rule_engine (const int rule_len, const char *rule_buf)
2473 {
2474 if (rule_len == 0)
2475 {
2476 return 0;
2477 }
2478 else if (rule_len == 1)
2479 {
2480 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2481 }
2482
2483 return 1;
2484 }
2485
2486 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2487 {
2488 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2489 {
2490 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);
2491 }
2492 else if (data.attack_kern == ATTACK_KERN_COMBI)
2493 {
2494 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);
2495 }
2496 else if (data.attack_kern == ATTACK_KERN_BF)
2497 {
2498 const uint64_t off = device_param->words_off;
2499
2500 device_param->kernel_params_mp_l_buf64[3] = off;
2501
2502 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2503 }
2504 }
2505
2506 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2507 {
2508 const uint gpu_loops = data.gpu_loops;
2509
2510 // init speed timer
2511
2512 uint speed_pos = device_param->speed_pos;
2513
2514 #ifdef _POSIX
2515 if (device_param->timer_speed.tv_sec == 0)
2516 {
2517 hc_timer_set (&device_param->timer_speed);
2518 }
2519 #endif
2520
2521 #ifdef _WIN
2522 if (device_param->timer_speed.QuadPart == 0)
2523 {
2524 hc_timer_set (&device_param->timer_speed);
2525 }
2526 #endif
2527
2528 // find higest password length, this is for optimization stuff
2529
2530 uint highest_pw_len = 0;
2531
2532 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2533 {
2534 }
2535 else if (data.attack_kern == ATTACK_KERN_COMBI)
2536 {
2537 }
2538 else if (data.attack_kern == ATTACK_KERN_BF)
2539 {
2540 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2541 + device_param->kernel_params_mp_l_buf32[5];
2542 }
2543
2544 // bitslice optimization stuff
2545
2546 if (data.attack_mode == ATTACK_MODE_BF)
2547 {
2548 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2549 {
2550 run_kernel_tb (device_param, pws_cnt);
2551 }
2552 }
2553
2554 // iteration type
2555
2556 uint innerloop_step = 0;
2557 uint innerloop_cnt = 0;
2558
2559 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2560 else innerloop_step = 1;
2561
2562 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2563 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2564 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2565
2566 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2567
2568 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2569 {
2570 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2571
2572 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2573
2574 if (data.devices_status == STATUS_CRACKED) break;
2575 if (data.devices_status == STATUS_ABORTED) break;
2576 if (data.devices_status == STATUS_QUIT) break;
2577 if (data.devices_status == STATUS_BYPASS) break;
2578
2579 if (data.salts_shown[salt_pos] == 1) continue;
2580
2581 salt_t *salt_buf = &data.salts_buf[salt_pos];
2582
2583 device_param->kernel_params_buf32[24] = salt_pos;
2584 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2585 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2586
2587 FILE *combs_fp = device_param->combs_fp;
2588
2589 if (data.attack_mode == ATTACK_MODE_COMBI)
2590 {
2591 rewind (combs_fp);
2592 }
2593
2594 // innerloops
2595
2596 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2597 {
2598 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2599
2600 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2601
2602 if (data.devices_status == STATUS_CRACKED) break;
2603 if (data.devices_status == STATUS_ABORTED) break;
2604 if (data.devices_status == STATUS_QUIT) break;
2605 if (data.devices_status == STATUS_BYPASS) break;
2606
2607 uint innerloop_left = innerloop_cnt - innerloop_pos;
2608
2609 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2610
2611 device_param->innerloop_pos = innerloop_pos;
2612 device_param->innerloop_left = innerloop_left;
2613
2614 device_param->kernel_params_buf32[27] = innerloop_left;
2615
2616 if (innerloop_left == 0) continue;
2617
2618 // initialize amplifiers
2619
2620 if (data.attack_mode == ATTACK_MODE_COMBI)
2621 {
2622 char line_buf[BUFSIZ];
2623
2624 uint i = 0;
2625
2626 while (i < innerloop_left)
2627 {
2628 if (feof (combs_fp)) break;
2629
2630 int line_len = fgetl (combs_fp, line_buf);
2631
2632 if (line_len >= PW_MAX1) continue;
2633
2634 line_len = convert_from_hex (line_buf, line_len);
2635
2636 char *line_buf_new = line_buf;
2637
2638 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2639 {
2640 char rule_buf_out[BLOCK_SIZE];
2641
2642 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2643
2644 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2645
2646 if (rule_len_out < 0)
2647 {
2648 data.words_progress_rejected[salt_pos] += pw_cnt;
2649
2650 continue;
2651 }
2652
2653 line_len = rule_len_out;
2654
2655 line_buf_new = rule_buf_out;
2656 }
2657
2658 line_len = MIN (line_len, PW_DICTMAX);
2659
2660 char *ptr = (char *) device_param->combs_buf[i].i;
2661
2662 memcpy (ptr, line_buf_new, line_len);
2663
2664 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2665
2666 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2667 {
2668 uppercase (ptr, line_len);
2669 }
2670
2671 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2672 {
2673 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2674 {
2675 ptr[line_len] = 0x80;
2676 }
2677
2678 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2679 {
2680 ptr[line_len] = 0x01;
2681 }
2682 }
2683
2684 device_param->combs_buf[i].pw_len = line_len;
2685
2686 i++;
2687 }
2688
2689 for (uint j = i; j < innerloop_left; j++)
2690 {
2691 device_param->combs_buf[j].i[0] = 0;
2692 device_param->combs_buf[j].i[1] = 0;
2693 device_param->combs_buf[j].i[2] = 0;
2694 device_param->combs_buf[j].i[3] = 0;
2695 device_param->combs_buf[j].i[4] = 0;
2696 device_param->combs_buf[j].i[5] = 0;
2697 device_param->combs_buf[j].i[6] = 0;
2698 device_param->combs_buf[j].i[7] = 0;
2699
2700 device_param->combs_buf[j].pw_len = 0;
2701 }
2702
2703 innerloop_left = i;
2704 }
2705 else if (data.attack_mode == ATTACK_MODE_BF)
2706 {
2707 uint64_t off = innerloop_pos;
2708
2709 device_param->kernel_params_mp_r_buf64[3] = off;
2710
2711 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2712 }
2713 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2714 {
2715 uint64_t off = innerloop_pos;
2716
2717 device_param->kernel_params_mp_buf64[3] = off;
2718
2719 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2720 }
2721 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2722 {
2723 uint64_t off = innerloop_pos;
2724
2725 device_param->kernel_params_mp_buf64[3] = off;
2726
2727 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2728 }
2729
2730 // copy amplifiers
2731
2732 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2733 {
2734 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (gpu_rule_t), 0, innerloop_left * sizeof (gpu_rule_t), 0, NULL, NULL);
2735 }
2736 else if (data.attack_mode == ATTACK_MODE_COMBI)
2737 {
2738 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);
2739 }
2740 else if (data.attack_mode == ATTACK_MODE_BF)
2741 {
2742 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);
2743 }
2744 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2745 {
2746 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);
2747 }
2748 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2749 {
2750 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);
2751 }
2752
2753 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2754 {
2755 if (data.attack_mode == ATTACK_MODE_BF)
2756 {
2757 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2758 {
2759 const uint size_tm = 32 * sizeof (bs_word_t);
2760
2761 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2762
2763 run_kernel_tm (device_param);
2764
2765 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2766 }
2767 }
2768
2769 if (highest_pw_len < 16)
2770 {
2771 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2772 }
2773 else if (highest_pw_len < 32)
2774 {
2775 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2776 }
2777 else
2778 {
2779 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2780 }
2781 }
2782 else
2783 {
2784 run_kernel_amp (device_param, pws_cnt);
2785
2786 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2787
2788 if (data.opts_type & OPTS_TYPE_HOOK12)
2789 {
2790 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2791 }
2792
2793 uint iter = salt_buf->salt_iter;
2794
2795 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2796 {
2797 uint loop_left = iter - loop_pos;
2798
2799 loop_left = MIN (loop_left, gpu_loops);
2800
2801 device_param->kernel_params_buf32[25] = loop_pos;
2802 device_param->kernel_params_buf32[26] = loop_left;
2803
2804 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2805
2806 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2807
2808 if (data.devices_status == STATUS_CRACKED) break;
2809 if (data.devices_status == STATUS_ABORTED) break;
2810 if (data.devices_status == STATUS_QUIT) break;
2811 }
2812
2813 if (data.opts_type & OPTS_TYPE_HOOK23)
2814 {
2815 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2816
2817 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2818
2819 // do something with data
2820
2821 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2822 }
2823
2824 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2825 }
2826
2827 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2828
2829 if (data.devices_status == STATUS_CRACKED) break;
2830 if (data.devices_status == STATUS_ABORTED) break;
2831 if (data.devices_status == STATUS_QUIT) break;
2832
2833 /**
2834 * result
2835 */
2836
2837 hc_thread_mutex_lock (mux_display);
2838
2839 check_cracked (device_param, salt_pos);
2840
2841 hc_thread_mutex_unlock (mux_display);
2842
2843 /**
2844 * progress
2845 */
2846
2847 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2848
2849 hc_thread_mutex_lock (mux_counter);
2850
2851 data.words_progress_done[salt_pos] += perf_sum_all;
2852
2853 hc_thread_mutex_unlock (mux_counter);
2854
2855 /**
2856 * speed
2857 */
2858
2859 float speed_ms;
2860
2861 hc_timer_get (device_param->timer_speed, speed_ms);
2862
2863 hc_timer_set (&device_param->timer_speed);
2864
2865 hc_thread_mutex_lock (mux_display);
2866
2867 device_param->speed_cnt[speed_pos] = perf_sum_all;
2868
2869 device_param->speed_ms[speed_pos] = speed_ms;
2870
2871 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2872
2873 hc_thread_mutex_unlock (mux_display);
2874
2875 speed_pos++;
2876
2877 if (speed_pos == SPEED_CACHE)
2878 {
2879 speed_pos = 0;
2880 }
2881 }
2882 }
2883
2884 device_param->speed_pos = speed_pos;
2885 }
2886
2887 static void load_segment (wl_data_t *wl_data, FILE *fd)
2888 {
2889 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2890
2891 wl_data->pos = 0;
2892
2893 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2894
2895 wl_data->buf[wl_data->cnt] = 0;
2896
2897 if (wl_data->cnt == 0) return;
2898
2899 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2900
2901 while (!feof (fd))
2902 {
2903 if (wl_data->cnt == wl_data->avail)
2904 {
2905 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2906
2907 wl_data->avail += wl_data->incr;
2908 }
2909
2910 const int c = fgetc (fd);
2911
2912 if (c == EOF) break;
2913
2914 wl_data->buf[wl_data->cnt] = (char) c;
2915
2916 wl_data->cnt++;
2917
2918 if (c == '\n') break;
2919 }
2920
2921 // ensure stream ends with a newline
2922
2923 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2924 {
2925 wl_data->cnt++;
2926
2927 wl_data->buf[wl_data->cnt - 1] = '\n';
2928 }
2929
2930 return;
2931 }
2932
2933 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2934 {
2935 char *ptr = buf;
2936
2937 for (uint32_t i = 0; i < sz; i++, ptr++)
2938 {
2939 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2940
2941 if (i == 7)
2942 {
2943 *off = i;
2944 *len = i;
2945
2946 return;
2947 }
2948
2949 if (*ptr != '\n') continue;
2950
2951 *off = i + 1;
2952
2953 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2954
2955 *len = i;
2956
2957 return;
2958 }
2959
2960 *off = sz;
2961 *len = sz;
2962 }
2963
2964 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2965 {
2966 char *ptr = buf;
2967
2968 for (uint32_t i = 0; i < sz; i++, ptr++)
2969 {
2970 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2971
2972 if (*ptr != '\n') continue;
2973
2974 *off = i + 1;
2975
2976 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2977
2978 *len = i;
2979
2980 return;
2981 }
2982
2983 *off = sz;
2984 *len = sz;
2985 }
2986
2987 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2988 {
2989 char *ptr = buf;
2990
2991 for (uint32_t i = 0; i < sz; i++, ptr++)
2992 {
2993 if (*ptr != '\n') continue;
2994
2995 *off = i + 1;
2996
2997 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2998
2999 *len = i;
3000
3001 return;
3002 }
3003
3004 *off = sz;
3005 *len = sz;
3006 }
3007
3008 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3009 {
3010 while (wl_data->pos < wl_data->cnt)
3011 {
3012 uint off;
3013 uint len;
3014
3015 char *ptr = wl_data->buf + wl_data->pos;
3016
3017 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3018
3019 wl_data->pos += off;
3020
3021 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3022 {
3023 char rule_buf_out[BLOCK_SIZE];
3024
3025 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3026
3027 int rule_len_out = -1;
3028
3029 if (len < BLOCK_SIZE)
3030 {
3031 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3032 }
3033
3034 if (rule_len_out < 0)
3035 {
3036 continue;
3037 }
3038
3039 if (rule_len_out > PW_MAX)
3040 {
3041 continue;
3042 }
3043 }
3044 else
3045 {
3046 if (len > PW_MAX)
3047 {
3048 continue;
3049 }
3050 }
3051
3052 *out_buf = ptr;
3053 *out_len = len;
3054
3055 return;
3056 }
3057
3058 if (feof (fd))
3059 {
3060 fprintf (stderr, "bug!!\n");
3061
3062 return;
3063 }
3064
3065 load_segment (wl_data, fd);
3066
3067 get_next_word (wl_data, fd, out_buf, out_len);
3068 }
3069
3070 #ifdef _POSIX
3071 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3072 #endif
3073
3074 #ifdef _WIN
3075 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3076 #endif
3077 {
3078 hc_signal (NULL);
3079
3080 dictstat_t d;
3081
3082 d.cnt = 0;
3083
3084 #ifdef _POSIX
3085 fstat (fileno (fd), &d.stat);
3086 #endif
3087
3088 #ifdef _WIN
3089 _fstat64 (fileno (fd), &d.stat);
3090 #endif
3091
3092 d.stat.st_mode = 0;
3093 d.stat.st_nlink = 0;
3094 d.stat.st_uid = 0;
3095 d.stat.st_gid = 0;
3096 d.stat.st_rdev = 0;
3097 d.stat.st_atime = 0;
3098
3099 #ifdef _POSIX
3100 d.stat.st_blksize = 0;
3101 d.stat.st_blocks = 0;
3102 #endif
3103
3104 if (d.stat.st_size == 0) return 0;
3105
3106 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3107
3108 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3109 {
3110 if (d_cache)
3111 {
3112 uint64_t cnt = d_cache->cnt;
3113
3114 uint64_t keyspace = cnt;
3115
3116 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3117 {
3118 keyspace *= data.gpu_rules_cnt;
3119 }
3120 else if (data.attack_kern == ATTACK_KERN_COMBI)
3121 {
3122 keyspace *= data.combs_cnt;
3123 }
3124
3125 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);
3126 if (data.quiet == 0) log_info ("");
3127
3128 hc_signal (sigHandler_default);
3129
3130 return (keyspace);
3131 }
3132 }
3133
3134 time_t now = 0;
3135 time_t prev = 0;
3136
3137 uint64_t comp = 0;
3138 uint64_t cnt = 0;
3139 uint64_t cnt2 = 0;
3140
3141 while (!feof (fd))
3142 {
3143 load_segment (wl_data, fd);
3144
3145 comp += wl_data->cnt;
3146
3147 uint32_t i = 0;
3148
3149 while (i < wl_data->cnt)
3150 {
3151 uint32_t len;
3152 uint32_t off;
3153
3154 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3155
3156 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3157 {
3158 char rule_buf_out[BLOCK_SIZE];
3159
3160 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3161
3162 int rule_len_out = -1;
3163
3164 if (len < BLOCK_SIZE)
3165 {
3166 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3167 }
3168
3169 if (rule_len_out < 0)
3170 {
3171 len = PW_MAX1;
3172 }
3173 else
3174 {
3175 len = rule_len_out;
3176 }
3177 }
3178
3179 if (len < PW_MAX1)
3180 {
3181 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3182 {
3183 cnt += data.gpu_rules_cnt;
3184 }
3185 else if (data.attack_kern == ATTACK_KERN_COMBI)
3186 {
3187 cnt += data.combs_cnt;
3188 }
3189
3190 d.cnt++;
3191 }
3192
3193 i += off;
3194
3195 cnt2++;
3196 }
3197
3198 time (&now);
3199
3200 if ((now - prev) == 0) continue;
3201
3202 float percent = (float) comp / (float) d.stat.st_size;
3203
3204 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);
3205
3206 time (&prev);
3207 }
3208
3209 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);
3210 if (data.quiet == 0) log_info ("");
3211
3212 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3213
3214 hc_signal (sigHandler_default);
3215
3216 return (cnt);
3217 }
3218
3219 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3220 {
3221 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3222 }
3223
3224 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3225 {
3226 if (data.devices_status == STATUS_BYPASS) return 0;
3227
3228 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3229
3230 uint cache_cnt = pw_cache->cnt;
3231
3232 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3233
3234 memcpy (pw_hc1, pw_buf, pw_len);
3235
3236 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3237
3238 uint pws_cnt = device_param->pws_cnt;
3239
3240 cache_cnt++;
3241
3242 pw_t *pw = device_param->pws_buf + pws_cnt;
3243
3244 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3245
3246 pw->pw_len = pw_len;
3247
3248 pws_cnt++;
3249
3250 device_param->pws_cnt = pws_cnt;
3251 device_param->pw_cnt = pws_cnt * 1;
3252
3253 cache_cnt = 0;
3254
3255 pw_cache->cnt = cache_cnt;
3256
3257 return pws_cnt;
3258 }
3259
3260 static void *thread_monitor (void *p)
3261 {
3262 uint runtime_check = 0;
3263 uint remove_check = 0;
3264 uint status_check = 0;
3265 uint hwmon_check = 0;
3266 uint restore_check = 0;
3267
3268 uint restore_left = data.restore_timer;
3269 uint remove_left = data.remove_timer;
3270 uint status_left = data.status_timer;
3271
3272 // these variables are mainly used for fan control (AMD only)
3273
3274 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3275
3276 // temperature controller "loopback" values
3277
3278 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3279 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3280
3281 int temp_threshold = 1; // degrees celcius
3282
3283 int fan_speed_min = 15; // in percentage
3284 int fan_speed_max = 100;
3285
3286 time_t last_temp_check_time;
3287
3288 uint sleep_time = 1;
3289
3290 if (data.runtime)
3291 {
3292 runtime_check = 1;
3293 }
3294
3295 if (data.restore_timer)
3296 {
3297 restore_check = 1;
3298 }
3299
3300 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3301 {
3302 remove_check = 1;
3303 }
3304
3305 if (data.status == 1)
3306 {
3307 status_check = 1;
3308 }
3309
3310 if (data.gpu_temp_disable == 0)
3311 {
3312 time (&last_temp_check_time);
3313
3314 hwmon_check = 1;
3315 }
3316
3317 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3318 {
3319 return (p);
3320 }
3321
3322 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3323 {
3324 hc_sleep (sleep_time);
3325
3326 if (data.devices_status != STATUS_RUNNING) continue;
3327
3328 if (hwmon_check == 1)
3329 {
3330 hc_thread_mutex_lock (mux_adl);
3331
3332 time_t temp_check_time;
3333
3334 time (&temp_check_time);
3335
3336 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3337
3338 if (Ta == 0) Ta = 1;
3339
3340 for (uint i = 0; i < data.devices_cnt; i++)
3341 {
3342 const int temperature = hm_get_temperature_with_device_id (i);
3343
3344 if (temperature > (int) data.gpu_temp_abort)
3345 {
3346 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3347
3348 if (data.devices_status != STATUS_QUIT) myabort ();
3349
3350 break;
3351 }
3352
3353 const int gpu_temp_retain = data.gpu_temp_retain;
3354
3355 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3356 {
3357 if (data.hm_device[i].fan_supported == 1)
3358 {
3359 int temp_cur = temperature;
3360
3361 int temp_diff_new = gpu_temp_retain - temp_cur;
3362
3363 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3364
3365 // calculate Ta value (time difference in seconds between the last check and this check)
3366
3367 last_temp_check_time = temp_check_time;
3368
3369 float Kp = 1.8;
3370 float Ki = 0.005;
3371 float Kd = 6;
3372
3373 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3374
3375 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);
3376
3377 if (abs (fan_diff_required) >= temp_threshold)
3378 {
3379 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3380
3381 int fan_speed_level = fan_speed_cur;
3382
3383 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3384
3385 int fan_speed_new = fan_speed_level - fan_diff_required;
3386
3387 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3388 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3389
3390 if (fan_speed_new != fan_speed_cur)
3391 {
3392 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3393 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3394
3395 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3396 {
3397 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3398
3399 fan_speed_chgd[i] = 1;
3400 }
3401
3402 temp_diff_old[i] = temp_diff_new;
3403 }
3404 }
3405 }
3406 }
3407 }
3408
3409 hc_thread_mutex_unlock (mux_adl);
3410 }
3411
3412 if (restore_check == 1)
3413 {
3414 restore_left--;
3415
3416 if (restore_left == 0)
3417 {
3418 if (data.restore_disable == 0) cycle_restore ();
3419
3420 restore_left = data.restore_timer;
3421 }
3422 }
3423
3424 if ((runtime_check == 1) && (data.runtime_start > 0))
3425 {
3426 time_t runtime_cur;
3427
3428 time (&runtime_cur);
3429
3430 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3431
3432 if (runtime_left <= 0)
3433 {
3434 if (data.benchmark == 0)
3435 {
3436 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3437 }
3438
3439 if (data.devices_status != STATUS_QUIT) myabort ();
3440 }
3441 }
3442
3443 if (remove_check == 1)
3444 {
3445 remove_left--;
3446
3447 if (remove_left == 0)
3448 {
3449 if (data.digests_saved != data.digests_done)
3450 {
3451 data.digests_saved = data.digests_done;
3452
3453 save_hash ();
3454 }
3455
3456 remove_left = data.remove_timer;
3457 }
3458 }
3459
3460 if (status_check == 1)
3461 {
3462 status_left--;
3463
3464 if (status_left == 0)
3465 {
3466 hc_thread_mutex_lock (mux_display);
3467
3468 if (data.quiet == 0) clear_prompt ();
3469
3470 if (data.quiet == 0) log_info ("");
3471
3472 status_display ();
3473
3474 if (data.quiet == 0) log_info ("");
3475
3476 hc_thread_mutex_unlock (mux_display);
3477
3478 status_left = data.status_timer;
3479 }
3480 }
3481 }
3482
3483 myfree (fan_speed_chgd);
3484
3485 myfree (temp_diff_old);
3486 myfree (temp_diff_sum);
3487
3488 p = NULL;
3489
3490 return (p);
3491 }
3492
3493 static void *thread_outfile_remove (void *p)
3494 {
3495 // some hash-dependent constants
3496 char *outfile_dir = data.outfile_check_directory;
3497 uint dgst_size = data.dgst_size;
3498 uint isSalted = data.isSalted;
3499 uint esalt_size = data.esalt_size;
3500 uint hash_mode = data.hash_mode;
3501
3502 uint outfile_check_timer = data.outfile_check_timer;
3503
3504 char separator = data.separator;
3505
3506 // some hash-dependent functions
3507 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3508 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3509
3510 // buffers
3511 hash_t hash_buf;
3512
3513 memset (&hash_buf, 0, sizeof (hash_buf));
3514
3515 hash_buf.digest = mymalloc (dgst_size);
3516
3517 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3518
3519 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3520
3521 uint digest_buf[64];
3522
3523 outfile_data_t *out_info = NULL;
3524
3525 char **out_files = NULL;
3526
3527 time_t folder_mtime = 0;
3528
3529 int out_cnt = 0;
3530
3531 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3532
3533 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3534 {
3535 hc_sleep (1);
3536
3537 if (data.devices_status != STATUS_RUNNING) continue;
3538
3539 check_left--;
3540
3541 if (check_left == 0)
3542 {
3543 struct stat outfile_check_stat;
3544
3545 if (stat (outfile_dir, &outfile_check_stat) == 0)
3546 {
3547 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3548
3549 if (is_dir == 1)
3550 {
3551 if (outfile_check_stat.st_mtime > folder_mtime)
3552 {
3553 char **out_files_new = scan_directory (outfile_dir);
3554
3555 int out_cnt_new = count_dictionaries (out_files_new);
3556
3557 outfile_data_t *out_info_new = NULL;
3558
3559 if (out_cnt_new > 0)
3560 {
3561 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3562
3563 for (int i = 0; i < out_cnt_new; i++)
3564 {
3565 out_info_new[i].file_name = out_files_new[i];
3566
3567 // check if there are files that we have seen/checked before (and not changed)
3568
3569 for (int j = 0; j < out_cnt; j++)
3570 {
3571 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3572 {
3573 struct stat outfile_stat;
3574
3575 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3576 {
3577 if (outfile_stat.st_ctime == out_info[j].ctime)
3578 {
3579 out_info_new[i].ctime = out_info[j].ctime;
3580 out_info_new[i].seek = out_info[j].seek;
3581 }
3582 }
3583 }
3584 }
3585 }
3586 }
3587
3588 local_free (out_info);
3589 local_free (out_files);
3590
3591 out_files = out_files_new;
3592 out_cnt = out_cnt_new;
3593 out_info = out_info_new;
3594
3595 folder_mtime = outfile_check_stat.st_mtime;
3596 }
3597
3598 for (int j = 0; j < out_cnt; j++)
3599 {
3600 FILE *fp = fopen (out_info[j].file_name, "rb");
3601
3602 if (fp != NULL)
3603 {
3604 //hc_thread_mutex_lock (mux_display);
3605
3606 #ifdef _POSIX
3607 struct stat outfile_stat;
3608
3609 fstat (fileno (fp), &outfile_stat);
3610 #endif
3611
3612 #ifdef _WIN
3613 struct stat64 outfile_stat;
3614
3615 _fstat64 (fileno (fp), &outfile_stat);
3616 #endif
3617
3618 if (outfile_stat.st_ctime > out_info[j].ctime)
3619 {
3620 out_info[j].ctime = outfile_stat.st_ctime;
3621 out_info[j].seek = 0;
3622 }
3623
3624 fseek (fp, out_info[j].seek, SEEK_SET);
3625
3626 while (!feof (fp))
3627 {
3628 char line_buf[BUFSIZ];
3629
3630 memset (line_buf, 0, BUFSIZ);
3631
3632 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3633
3634 if (ptr == NULL) break;
3635
3636 int line_len = strlen (line_buf);
3637
3638 if (line_len <= 0) continue;
3639
3640 int iter = MAX_CUT_TRIES;
3641
3642 for (uint i = line_len - 1; i && iter; i--, line_len--)
3643 {
3644 if (line_buf[i] != separator) continue;
3645
3646 int parser_status = PARSER_OK;
3647
3648 if ((hash_mode != 2500) && (hash_mode != 6800))
3649 {
3650 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3651 }
3652
3653 uint found = 0;
3654
3655 if (parser_status == PARSER_OK)
3656 {
3657 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3658 {
3659 if (data.salts_shown[salt_pos] == 1) continue;
3660
3661 salt_t *salt_buf = &data.salts_buf[salt_pos];
3662
3663 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3664 {
3665 uint idx = salt_buf->digests_offset + digest_pos;
3666
3667 if (data.digests_shown[idx] == 1) continue;
3668
3669 uint cracked = 0;
3670
3671 if (hash_mode == 6800)
3672 {
3673 if (i == salt_buf->salt_len)
3674 {
3675 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3676 }
3677 }
3678 else if (hash_mode == 2500)
3679 {
3680 // BSSID : MAC1 : MAC2 (:plain)
3681 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3682 {
3683 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3684
3685 if (!cracked) continue;
3686
3687 // now compare MAC1 and MAC2 too, since we have this additional info
3688 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3689 char *mac2_pos = mac1_pos + 12 + 1;
3690
3691 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3692 wpa_t *wpa = &wpas[salt_pos];
3693
3694 uint pke[25];
3695
3696 char *pke_ptr = (char *) pke;
3697
3698 for (uint i = 0; i < 25; i++)
3699 {
3700 pke[i] = byte_swap_32 (wpa->pke[i]);
3701 }
3702
3703 unsigned char mac1[6];
3704 unsigned char mac2[6];
3705
3706 memcpy (mac1, pke_ptr + 23, 6);
3707 memcpy (mac2, pke_ptr + 29, 6);
3708
3709 // compare hex string(s) vs binary MAC address(es)
3710
3711 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3712 {
3713 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3714 {
3715 cracked = 0;
3716 break;
3717 }
3718 }
3719
3720 // early skip ;)
3721 if (!cracked) continue;
3722
3723 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3724 {
3725 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3726 {
3727 cracked = 0;
3728 break;
3729 }
3730 }
3731 }
3732 }
3733 else
3734 {
3735 char *digests_buf_ptr = (char *) data.digests_buf;
3736
3737 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3738
3739 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3740 }
3741
3742 if (cracked == 1)
3743 {
3744 found = 1;
3745
3746 data.digests_shown[idx] = 1;
3747
3748 data.digests_done++;
3749
3750 salt_buf->digests_done++;
3751
3752 if (salt_buf->digests_done == salt_buf->digests_cnt)
3753 {
3754 data.salts_shown[salt_pos] = 1;
3755
3756 data.salts_done++;
3757
3758 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3759 }
3760 }
3761 }
3762
3763 if (data.devices_status == STATUS_CRACKED) break;
3764 }
3765 }
3766
3767 if (found) break;
3768
3769 if (data.devices_status == STATUS_CRACKED) break;
3770
3771 iter--;
3772 }
3773
3774 if (data.devices_status == STATUS_CRACKED) break;
3775 }
3776
3777 out_info[j].seek = ftell (fp);
3778
3779 //hc_thread_mutex_unlock (mux_display);
3780
3781 fclose (fp);
3782 }
3783 }
3784 }
3785 }
3786
3787 check_left = outfile_check_timer;
3788 }
3789 }
3790
3791 if (esalt_size) local_free (hash_buf.esalt);
3792
3793 if (isSalted) local_free (hash_buf.salt);
3794
3795 local_free (hash_buf.digest);
3796
3797 local_free (out_info);
3798
3799 local_free (out_files);
3800
3801 p = NULL;
3802
3803 return (p);
3804 }
3805
3806 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3807 {
3808 hc_thread_mutex_lock (mux_dispatcher);
3809
3810 const uint64_t words_cur = data.words_cur;
3811 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3812
3813 device_param->words_off = words_cur;
3814
3815 const uint64_t words_left = words_base - words_cur;
3816
3817 if (data.gpu_blocks_all > words_left)
3818 {
3819 if (data.gpu_blocks_div == 0)
3820 {
3821 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3822 }
3823 }
3824
3825 if (data.gpu_blocks_div)
3826 {
3827 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3828 {
3829 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3830 const uint32_t gpu_power_new = gpu_blocks_new;
3831
3832 if (gpu_blocks_new < device_param->gpu_blocks)
3833 {
3834 device_param->gpu_blocks = gpu_blocks_new;
3835 device_param->gpu_power = gpu_power_new;
3836 }
3837 }
3838 }
3839
3840 const uint gpu_blocks = device_param->gpu_blocks;
3841
3842 uint work = MIN (words_left, gpu_blocks);
3843
3844 work = MIN (work, max);
3845
3846 data.words_cur += work;
3847
3848 hc_thread_mutex_unlock (mux_dispatcher);
3849
3850 return work;
3851 }
3852
3853 static void *thread_calc_stdin (void *p)
3854 {
3855 hc_device_param_t *device_param = (hc_device_param_t *) p;
3856
3857 const uint attack_kern = data.attack_kern;
3858
3859 const uint gpu_blocks = device_param->gpu_blocks;
3860
3861 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3862 {
3863 hc_thread_mutex_lock (mux_dispatcher);
3864
3865 if (feof (stdin) != 0)
3866 {
3867 hc_thread_mutex_unlock (mux_dispatcher);
3868
3869 break;
3870 }
3871
3872 uint words_cur = 0;
3873
3874 while (words_cur < gpu_blocks)
3875 {
3876 char buf[BUFSIZ];
3877
3878 char *line_buf = fgets (buf, sizeof (buf), stdin);
3879
3880 if (line_buf == NULL) break;
3881
3882 uint line_len = in_superchop (line_buf);
3883
3884 line_len = convert_from_hex (line_buf, line_len);
3885
3886 // post-process rule engine
3887
3888 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3889 {
3890 char rule_buf_out[BLOCK_SIZE];
3891
3892 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3893
3894 int rule_len_out = -1;
3895
3896 if (line_len < BLOCK_SIZE)
3897 {
3898 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3899 }
3900
3901 if (rule_len_out < 0) continue;
3902
3903 line_buf = rule_buf_out;
3904 line_len = rule_len_out;
3905 }
3906
3907 if (line_len > PW_MAX)
3908 {
3909 continue;
3910 }
3911
3912 if (attack_kern == ATTACK_KERN_STRAIGHT)
3913 {
3914 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3915 {
3916 hc_thread_mutex_lock (mux_counter);
3917
3918 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3919 {
3920 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3921 }
3922
3923 hc_thread_mutex_unlock (mux_counter);
3924
3925 continue;
3926 }
3927 }
3928 else if (attack_kern == ATTACK_KERN_COMBI)
3929 {
3930 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
3931 // since we still need to combine the plains
3932
3933 if (line_len > data.pw_max)
3934 {
3935 hc_thread_mutex_lock (mux_counter);
3936
3937 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3938 {
3939 data.words_progress_rejected[salt_pos] += data.combs_cnt;
3940 }
3941
3942 hc_thread_mutex_unlock (mux_counter);
3943
3944 continue;
3945 }
3946 }
3947
3948 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
3949
3950 words_cur++;
3951
3952 if (data.devices_status == STATUS_CRACKED) break;
3953 if (data.devices_status == STATUS_ABORTED) break;
3954 if (data.devices_status == STATUS_QUIT) break;
3955 if (data.devices_status == STATUS_BYPASS) break;
3956 }
3957
3958 hc_thread_mutex_unlock (mux_dispatcher);
3959
3960 if (data.devices_status == STATUS_CRACKED) break;
3961 if (data.devices_status == STATUS_ABORTED) break;
3962 if (data.devices_status == STATUS_QUIT) break;
3963 if (data.devices_status == STATUS_BYPASS) break;
3964
3965 // we need 2 flushing because we have two independant caches and it can occur
3966 // that one buffer is already at threshold plus for that length also exists
3967 // more data in the 2nd buffer so it would overflow
3968
3969 // flush session 1
3970
3971 {
3972 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
3973 {
3974 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
3975
3976 const uint pw_cache_cnt = pw_cache->cnt;
3977
3978 if (pw_cache_cnt == 0) continue;
3979
3980 pw_cache->cnt = 0;
3981
3982 uint pws_cnt = device_param->pws_cnt;
3983
3984 pw_t *pw = device_param->pws_buf + pws_cnt;
3985
3986 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3987
3988 pw->pw_len = pw_len;
3989
3990 uint pw_cnt = device_param->pw_cnt;
3991
3992 pw_cnt += pw_cache_cnt;
3993
3994 device_param->pw_cnt = pw_cnt;
3995
3996 pws_cnt++;
3997
3998 device_param->pws_cnt = pws_cnt;
3999
4000 if (pws_cnt == device_param->gpu_power_user) break;
4001 }
4002
4003 const uint pw_cnt = device_param->pw_cnt;
4004 const uint pws_cnt = device_param->pws_cnt;
4005
4006 if (pws_cnt)
4007 {
4008 run_copy (device_param, pws_cnt);
4009
4010 run_cracker (device_param, pw_cnt, pws_cnt);
4011
4012 device_param->pw_cnt = 0;
4013 device_param->pws_cnt = 0;
4014 }
4015 }
4016
4017 // flush session 2
4018
4019 {
4020 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4021 {
4022 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4023
4024 const uint pw_cache_cnt = pw_cache->cnt;
4025
4026 if (pw_cache_cnt == 0) continue;
4027
4028 pw_cache->cnt = 0;
4029
4030 uint pws_cnt = device_param->pws_cnt;
4031
4032 pw_t *pw = device_param->pws_buf + pws_cnt;
4033
4034 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4035
4036 pw->pw_len = pw_len;
4037
4038 uint pw_cnt = device_param->pw_cnt;
4039
4040 pw_cnt += pw_cache_cnt;
4041
4042 device_param->pw_cnt = pw_cnt;
4043
4044 pws_cnt++;
4045
4046 device_param->pws_cnt = pws_cnt;
4047 }
4048
4049 const uint pw_cnt = device_param->pw_cnt;
4050 const uint pws_cnt = device_param->pws_cnt;
4051
4052 if (pws_cnt)
4053 {
4054 run_copy (device_param, pws_cnt);
4055
4056 run_cracker (device_param, pw_cnt, pws_cnt);
4057
4058 device_param->pw_cnt = 0;
4059 device_param->pws_cnt = 0;
4060 }
4061 }
4062 }
4063
4064 return NULL;
4065 }
4066
4067 static void *thread_calc (void *p)
4068 {
4069 hc_device_param_t *device_param = (hc_device_param_t *) p;
4070
4071 const uint attack_mode = data.attack_mode;
4072 const uint attack_kern = data.attack_kern;
4073
4074 if (attack_mode == ATTACK_MODE_BF)
4075 {
4076 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4077 {
4078 const uint work = get_work (device_param, -1);
4079
4080 if (work == 0) break;
4081
4082 const uint64_t words_off = device_param->words_off;
4083 const uint64_t words_fin = words_off + work;
4084
4085 const uint pw_cnt = work;
4086 const uint pws_cnt = work;
4087
4088 device_param->pw_cnt = pw_cnt;
4089 device_param->pws_cnt = pws_cnt;
4090
4091 if (pws_cnt)
4092 {
4093 run_copy (device_param, pws_cnt);
4094
4095 run_cracker (device_param, pw_cnt, pws_cnt);
4096
4097 device_param->pw_cnt = 0;
4098 device_param->pws_cnt = 0;
4099 }
4100
4101 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4102
4103 if (data.devices_status == STATUS_CRACKED) break;
4104 if (data.devices_status == STATUS_ABORTED) break;
4105 if (data.devices_status == STATUS_QUIT) break;
4106 if (data.devices_status == STATUS_BYPASS) break;
4107
4108 device_param->words_done = words_fin;
4109 }
4110 }
4111 else
4112 {
4113 const uint segment_size = data.segment_size;
4114
4115 char *dictfile = data.dictfile;
4116
4117 if (attack_mode == ATTACK_MODE_COMBI)
4118 {
4119 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4120 {
4121 dictfile = data.dictfile2;
4122 }
4123 }
4124
4125 FILE *fd = fopen (dictfile, "rb");
4126
4127 if (fd == NULL)
4128 {
4129 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4130
4131 return NULL;
4132 }
4133
4134 if (attack_mode == ATTACK_MODE_COMBI)
4135 {
4136 const uint combs_mode = data.combs_mode;
4137
4138 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4139 {
4140 const char *dictfilec = data.dictfile2;
4141
4142 FILE *combs_fp = fopen (dictfilec, "rb");
4143
4144 if (combs_fp == NULL)
4145 {
4146 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4147
4148 fclose (fd);
4149
4150 return NULL;
4151 }
4152
4153 device_param->combs_fp = combs_fp;
4154 }
4155 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4156 {
4157 const char *dictfilec = data.dictfile;
4158
4159 FILE *combs_fp = fopen (dictfilec, "rb");
4160
4161 if (combs_fp == NULL)
4162 {
4163 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4164
4165 fclose (fd);
4166
4167 return NULL;
4168 }
4169
4170 device_param->combs_fp = combs_fp;
4171 }
4172 }
4173
4174 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4175
4176 wl_data->buf = (char *) mymalloc (segment_size);
4177 wl_data->avail = segment_size;
4178 wl_data->incr = segment_size;
4179 wl_data->cnt = 0;
4180 wl_data->pos = 0;
4181
4182 uint64_t words_cur = 0;
4183
4184 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4185 {
4186 uint64_t words_off = 0;
4187 uint64_t words_fin = 0;
4188
4189 uint64_t max = -1;
4190
4191 while (max)
4192 {
4193 const uint work = get_work (device_param, max);
4194
4195 if (work == 0) break;
4196
4197 words_off = device_param->words_off;
4198 words_fin = words_off + work;
4199
4200 char *line_buf;
4201 uint line_len;
4202
4203 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4204
4205 max = 0;
4206
4207 for ( ; words_cur < words_fin; words_cur++)
4208 {
4209 get_next_word (wl_data, fd, &line_buf, &line_len);
4210
4211 line_len = convert_from_hex (line_buf, line_len);
4212
4213 // post-process rule engine
4214
4215 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4216 {
4217 char rule_buf_out[BLOCK_SIZE];
4218
4219 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4220
4221 int rule_len_out = -1;
4222
4223 if (line_len < BLOCK_SIZE)
4224 {
4225 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4226 }
4227
4228 if (rule_len_out < 0) continue;
4229
4230 line_buf = rule_buf_out;
4231 line_len = rule_len_out;
4232 }
4233
4234 if (attack_kern == ATTACK_KERN_STRAIGHT)
4235 {
4236 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4237 {
4238 max++;
4239
4240 hc_thread_mutex_lock (mux_counter);
4241
4242 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4243 {
4244 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4245 }
4246
4247 hc_thread_mutex_unlock (mux_counter);
4248
4249 continue;
4250 }
4251 }
4252 else if (attack_kern == ATTACK_KERN_COMBI)
4253 {
4254 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4255 // since we still need to combine the plains
4256
4257 if (line_len > data.pw_max)
4258 {
4259 max++;
4260
4261 hc_thread_mutex_lock (mux_counter);
4262
4263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4264 {
4265 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4266 }
4267
4268 hc_thread_mutex_unlock (mux_counter);
4269
4270 continue;
4271 }
4272 }
4273
4274 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4275
4276 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4277
4278 if (data.devices_status == STATUS_CRACKED) break;
4279 if (data.devices_status == STATUS_ABORTED) break;
4280 if (data.devices_status == STATUS_QUIT) break;
4281 if (data.devices_status == STATUS_BYPASS) break;
4282 }
4283
4284 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4285
4286 if (data.devices_status == STATUS_CRACKED) break;
4287 if (data.devices_status == STATUS_ABORTED) break;
4288 if (data.devices_status == STATUS_QUIT) break;
4289 if (data.devices_status == STATUS_BYPASS) break;
4290 }
4291
4292 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4293
4294 if (data.devices_status == STATUS_CRACKED) break;
4295 if (data.devices_status == STATUS_ABORTED) break;
4296 if (data.devices_status == STATUS_QUIT) break;
4297 if (data.devices_status == STATUS_BYPASS) break;
4298
4299 // we need 2 flushing because we have two independant caches and it can occur
4300 // that one buffer is already at threshold plus for that length also exists
4301 // more data in the 2nd buffer so it would overflow
4302
4303 //
4304 // flush session 1
4305 //
4306
4307 {
4308 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4309 {
4310 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4311
4312 const uint pw_cache_cnt = pw_cache->cnt;
4313
4314 if (pw_cache_cnt == 0) continue;
4315
4316 pw_cache->cnt = 0;
4317
4318 uint pws_cnt = device_param->pws_cnt;
4319
4320 pw_t *pw = device_param->pws_buf + pws_cnt;
4321
4322 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4323
4324 pw->pw_len = pw_len;
4325
4326 uint pw_cnt = device_param->pw_cnt;
4327
4328 pw_cnt += pw_cache_cnt;
4329
4330 device_param->pw_cnt = pw_cnt;
4331
4332 pws_cnt++;
4333
4334 device_param->pws_cnt = pws_cnt;
4335
4336 if (pws_cnt == device_param->gpu_power_user) break;
4337 }
4338
4339 const uint pw_cnt = device_param->pw_cnt;
4340 const uint pws_cnt = device_param->pws_cnt;
4341
4342 if (pws_cnt)
4343 {
4344 run_copy (device_param, pws_cnt);
4345
4346 run_cracker (device_param, pw_cnt, pws_cnt);
4347
4348 device_param->pw_cnt = 0;
4349 device_param->pws_cnt = 0;
4350 }
4351
4352 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4353
4354 if (data.devices_status == STATUS_CRACKED) break;
4355 if (data.devices_status == STATUS_ABORTED) break;
4356 if (data.devices_status == STATUS_QUIT) break;
4357 if (data.devices_status == STATUS_BYPASS) break;
4358 }
4359
4360 //
4361 // flush session 2
4362 //
4363
4364 {
4365 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4366 {
4367 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4368
4369 const uint pw_cache_cnt = pw_cache->cnt;
4370
4371 if (pw_cache_cnt == 0) continue;
4372
4373 pw_cache->cnt = 0;
4374
4375 uint pws_cnt = device_param->pws_cnt;
4376
4377 pw_t *pw = device_param->pws_buf + pws_cnt;
4378
4379 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4380
4381 pw->pw_len = pw_len;
4382
4383 uint pw_cnt = device_param->pw_cnt;
4384
4385 pw_cnt += pw_cache_cnt;
4386
4387 device_param->pw_cnt = pw_cnt;
4388
4389 pws_cnt++;
4390
4391 device_param->pws_cnt = pws_cnt;
4392 }
4393
4394 const uint pw_cnt = device_param->pw_cnt;
4395 const uint pws_cnt = device_param->pws_cnt;
4396
4397 if (pws_cnt)
4398 {
4399 run_copy (device_param, pws_cnt);
4400
4401 run_cracker (device_param, pw_cnt, pws_cnt);
4402
4403 device_param->pw_cnt = 0;
4404 device_param->pws_cnt = 0;
4405 }
4406
4407 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4408
4409 if (data.devices_status == STATUS_CRACKED) break;
4410 if (data.devices_status == STATUS_ABORTED) break;
4411 if (data.devices_status == STATUS_QUIT) break;
4412 if (data.devices_status == STATUS_BYPASS) break;
4413 }
4414
4415 if (words_fin == 0) break;
4416
4417 device_param->words_done = words_fin;
4418 }
4419
4420 if (attack_mode == ATTACK_MODE_COMBI)
4421 {
4422 fclose (device_param->combs_fp);
4423 }
4424
4425 free (wl_data->buf);
4426 free (wl_data);
4427
4428 fclose (fd);
4429 }
4430
4431 return NULL;
4432 }
4433
4434 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4435 {
4436 salt_t *salt_buf = &data.salts_buf[salt_pos];
4437
4438 device_param->kernel_params_buf32[24] = salt_pos;
4439 device_param->kernel_params_buf32[27] = 1;
4440 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4441 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4442 device_param->kernel_params_buf32[30] = 0;
4443 device_param->kernel_params_buf32[31] = 1;
4444
4445 char *dictfile_old = data.dictfile;
4446 char *dictfile2_old = data.dictfile2;
4447 char *mask_old = data.mask;
4448
4449 const char *weak_hash_check = "weak-hash-check";
4450
4451 data.dictfile = (char *) weak_hash_check;
4452 data.dictfile2 = (char *) weak_hash_check;
4453 data.mask = (char *) weak_hash_check;
4454
4455 /**
4456 * run the kernel
4457 */
4458
4459 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4460 {
4461 run_kernel (KERN_RUN_1, device_param, 1);
4462 }
4463 else
4464 {
4465 run_kernel (KERN_RUN_1, device_param, 1);
4466
4467 const uint iter = salt_buf->salt_iter;
4468
4469 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4470 {
4471 uint loop_left = iter - loop_pos;
4472
4473 loop_left = MIN (loop_left, gpu_loops);
4474
4475 device_param->kernel_params_buf32[25] = loop_pos;
4476 device_param->kernel_params_buf32[26] = loop_left;
4477
4478 run_kernel (KERN_RUN_2, device_param, 1);
4479 }
4480
4481 run_kernel (KERN_RUN_3, device_param, 1);
4482 }
4483
4484 /**
4485 * result
4486 */
4487
4488 check_cracked (device_param, salt_pos);
4489
4490 /**
4491 * cleanup
4492 */
4493
4494 device_param->kernel_params_buf32[24] = 0;
4495 device_param->kernel_params_buf32[25] = 0;
4496 device_param->kernel_params_buf32[26] = 0;
4497 device_param->kernel_params_buf32[27] = 0;
4498 device_param->kernel_params_buf32[28] = 0;
4499 device_param->kernel_params_buf32[29] = 0;
4500 device_param->kernel_params_buf32[30] = 0;
4501 device_param->kernel_params_buf32[31] = 0;
4502
4503 data.dictfile = dictfile_old;
4504 data.dictfile2 = dictfile2_old;
4505 data.mask = mask_old;
4506 }
4507
4508 // hlfmt hashcat
4509
4510 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4511 {
4512 if (data.username == 0)
4513 {
4514 *hashbuf_pos = line_buf;
4515 *hashbuf_len = line_len;
4516 }
4517 else
4518 {
4519 char *pos = line_buf;
4520 int len = line_len;
4521
4522 for (int i = 0; i < line_len; i++, pos++, len--)
4523 {
4524 if (line_buf[i] == data.separator)
4525 {
4526 pos++;
4527
4528 len--;
4529
4530 break;
4531 }
4532 }
4533
4534 *hashbuf_pos = pos;
4535 *hashbuf_len = len;
4536 }
4537 }
4538
4539 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4540 {
4541 char *pos = NULL;
4542 int len = 0;
4543
4544 int sep_cnt = 0;
4545
4546 for (int i = 0; i < line_len; i++)
4547 {
4548 if (line_buf[i] == data.separator)
4549 {
4550 sep_cnt++;
4551
4552 continue;
4553 }
4554
4555 if (sep_cnt == 0)
4556 {
4557 if (pos == NULL) pos = line_buf + i;
4558
4559 len++;
4560 }
4561 }
4562
4563 *userbuf_pos = pos;
4564 *userbuf_len = len;
4565 }
4566
4567 // hlfmt pwdump
4568
4569 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4570 {
4571 int sep_cnt = 0;
4572
4573 int sep2_len = 0;
4574 int sep3_len = 0;
4575
4576 for (int i = 0; i < line_len; i++)
4577 {
4578 if (line_buf[i] == ':')
4579 {
4580 sep_cnt++;
4581
4582 continue;
4583 }
4584
4585 if (sep_cnt == 2) sep2_len++;
4586 if (sep_cnt == 3) sep3_len++;
4587 }
4588
4589 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4590
4591 return 0;
4592 }
4593
4594 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4595 {
4596 char *pos = NULL;
4597 int len = 0;
4598
4599 int sep_cnt = 0;
4600
4601 for (int i = 0; i < line_len; i++)
4602 {
4603 if (line_buf[i] == ':')
4604 {
4605 sep_cnt++;
4606
4607 continue;
4608 }
4609
4610 if (data.hash_mode == 1000)
4611 {
4612 if (sep_cnt == 3)
4613 {
4614 if (pos == NULL) pos = line_buf + i;
4615
4616 len++;
4617 }
4618 }
4619 else if (data.hash_mode == 3000)
4620 {
4621 if (sep_cnt == 2)
4622 {
4623 if (pos == NULL) pos = line_buf + i;
4624
4625 len++;
4626 }
4627 }
4628 }
4629
4630 *hashbuf_pos = pos;
4631 *hashbuf_len = len;
4632 }
4633
4634 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4635 {
4636 char *pos = NULL;
4637 int len = 0;
4638
4639 int sep_cnt = 0;
4640
4641 for (int i = 0; i < line_len; i++)
4642 {
4643 if (line_buf[i] == ':')
4644 {
4645 sep_cnt++;
4646
4647 continue;
4648 }
4649
4650 if (sep_cnt == 0)
4651 {
4652 if (pos == NULL) pos = line_buf + i;
4653
4654 len++;
4655 }
4656 }
4657
4658 *userbuf_pos = pos;
4659 *userbuf_len = len;
4660 }
4661
4662 // hlfmt passwd
4663
4664 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4665 {
4666 int sep_cnt = 0;
4667
4668 char sep5_first = 0;
4669 char sep6_first = 0;
4670
4671 for (int i = 0; i < line_len; i++)
4672 {
4673 if (line_buf[i] == ':')
4674 {
4675 sep_cnt++;
4676
4677 continue;
4678 }
4679
4680 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4681 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4682 }
4683
4684 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4685
4686 return 0;
4687 }
4688
4689 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4690 {
4691 char *pos = NULL;
4692 int len = 0;
4693
4694 int sep_cnt = 0;
4695
4696 for (int i = 0; i < line_len; i++)
4697 {
4698 if (line_buf[i] == ':')
4699 {
4700 sep_cnt++;
4701
4702 continue;
4703 }
4704
4705 if (sep_cnt == 1)
4706 {
4707 if (pos == NULL) pos = line_buf + i;
4708
4709 len++;
4710 }
4711 }
4712
4713 *hashbuf_pos = pos;
4714 *hashbuf_len = len;
4715 }
4716
4717 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4718 {
4719 char *pos = NULL;
4720 int len = 0;
4721
4722 int sep_cnt = 0;
4723
4724 for (int i = 0; i < line_len; i++)
4725 {
4726 if (line_buf[i] == ':')
4727 {
4728 sep_cnt++;
4729
4730 continue;
4731 }
4732
4733 if (sep_cnt == 0)
4734 {
4735 if (pos == NULL) pos = line_buf + i;
4736
4737 len++;
4738 }
4739 }
4740
4741 *userbuf_pos = pos;
4742 *userbuf_len = len;
4743 }
4744
4745 // hlfmt shadow
4746
4747 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4748 {
4749 int sep_cnt = 0;
4750
4751 for (int i = 0; i < line_len; i++)
4752 {
4753 if (line_buf[i] == ':') sep_cnt++;
4754 }
4755
4756 if (sep_cnt == 8) return 1;
4757
4758 return 0;
4759 }
4760
4761 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4762 {
4763 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4764 }
4765
4766 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4767 {
4768 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4769 }
4770
4771 // hlfmt main
4772
4773 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4774 {
4775 switch (hashfile_format)
4776 {
4777 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4778 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4779 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4780 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4781 }
4782 }
4783
4784 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4785 {
4786 switch (hashfile_format)
4787 {
4788 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4789 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4790 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4791 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4792 }
4793 }
4794
4795 static uint hlfmt_detect (FILE *fp, uint max_check)
4796 {
4797 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4798
4799 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4800 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4801
4802 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4803
4804 uint num_check = 0;
4805
4806 while (!feof (fp))
4807 {
4808 char line_buf[BUFSIZ];
4809
4810 int line_len = fgetl (fp, line_buf);
4811
4812 if (line_len == 0) continue;
4813
4814 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4815 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4816 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4817
4818 if (num_check == max_check) break;
4819
4820 num_check++;
4821 }
4822
4823 uint hashlist_format = HLFMT_HASHCAT;
4824
4825 for (int i = 1; i < HLFMTS_CNT; i++)
4826 {
4827 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4828
4829 hashlist_format = i;
4830 }
4831
4832 free (formats_cnt);
4833
4834 return hashlist_format;
4835 }
4836
4837 /**
4838 * some further helper function
4839 */
4840
4841 // wrapper around mymalloc for ADL
4842
4843 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4844 {
4845 return mymalloc (iSize);
4846 }
4847
4848 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)
4849 {
4850 uint64_t collisions = 0;
4851
4852 const uint dgst_pos0 = data.dgst_pos0;
4853 const uint dgst_pos1 = data.dgst_pos1;
4854 const uint dgst_pos2 = data.dgst_pos2;
4855 const uint dgst_pos3 = data.dgst_pos3;
4856
4857 memset (bitmap_a, 0, bitmap_size);
4858 memset (bitmap_b, 0, bitmap_size);
4859 memset (bitmap_c, 0, bitmap_size);
4860 memset (bitmap_d, 0, bitmap_size);
4861
4862 for (uint i = 0; i < digests_cnt; i++)
4863 {
4864 uint *digest_ptr = (uint *) digests_buf_ptr;
4865
4866 digests_buf_ptr += dgst_size;
4867
4868 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4869 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4870 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4871 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4872
4873 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4874 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4875 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4876 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4877
4878 if (bitmap_a[idx0] & val0) collisions++;
4879 if (bitmap_b[idx1] & val1) collisions++;
4880 if (bitmap_c[idx2] & val2) collisions++;
4881 if (bitmap_d[idx3] & val3) collisions++;
4882
4883 bitmap_a[idx0] |= val0;
4884 bitmap_b[idx1] |= val1;
4885 bitmap_c[idx2] |= val2;
4886 bitmap_d[idx3] |= val3;
4887
4888 if (collisions >= collisions_max) return 0x7fffffff;
4889 }
4890
4891 return collisions;
4892 }
4893
4894 /**
4895 * main
4896 */
4897
4898 int main (int argc, char **argv)
4899 {
4900 /**
4901 * To help users a bit
4902 */
4903
4904 char *compute = getenv ("COMPUTE");
4905
4906 if (compute)
4907 {
4908 char display[100];
4909
4910 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4911
4912 putenv (display);
4913 }
4914 else
4915 {
4916 if (getenv ("DISPLAY") == NULL)
4917 putenv ((char *) "DISPLAY=:0");
4918 }
4919
4920 /*
4921 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4922 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4923
4924 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4925 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4926 */
4927
4928 /**
4929 * Real init
4930 */
4931
4932 memset (&data, 0, sizeof (hc_global_data_t));
4933
4934 time_t proc_start;
4935
4936 time (&proc_start);
4937
4938 data.proc_start = proc_start;
4939
4940 int myargc = argc;
4941 char **myargv = argv;
4942
4943 hc_thread_mutex_init (mux_dispatcher);
4944 hc_thread_mutex_init (mux_counter);
4945 hc_thread_mutex_init (mux_display);
4946 hc_thread_mutex_init (mux_adl);
4947
4948 /**
4949 * commandline parameters
4950 */
4951
4952 uint usage = USAGE;
4953 uint version = VERSION;
4954 uint quiet = QUIET;
4955 uint benchmark = BENCHMARK;
4956 uint benchmark_mode = BENCHMARK_MODE;
4957 uint show = SHOW;
4958 uint left = LEFT;
4959 uint username = USERNAME;
4960 uint remove = REMOVE;
4961 uint remove_timer = REMOVE_TIMER;
4962 uint64_t skip = SKIP;
4963 uint64_t limit = LIMIT;
4964 uint keyspace = KEYSPACE;
4965 uint potfile_disable = POTFILE_DISABLE;
4966 uint debug_mode = DEBUG_MODE;
4967 char *debug_file = NULL;
4968 char *induction_dir = NULL;
4969 char *outfile_check_dir = NULL;
4970 uint force = FORCE;
4971 uint runtime = RUNTIME;
4972 uint hash_mode = HASH_MODE;
4973 uint attack_mode = ATTACK_MODE;
4974 uint markov_disable = MARKOV_DISABLE;
4975 uint markov_classic = MARKOV_CLASSIC;
4976 uint markov_threshold = MARKOV_THRESHOLD;
4977 char *markov_hcstat = NULL;
4978 char *outfile = NULL;
4979 uint outfile_format = OUTFILE_FORMAT;
4980 uint outfile_autohex = OUTFILE_AUTOHEX;
4981 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
4982 uint restore = RESTORE;
4983 uint restore_timer = RESTORE_TIMER;
4984 uint restore_disable = RESTORE_DISABLE;
4985 uint status = STATUS;
4986 uint status_timer = STATUS_TIMER;
4987 uint status_automat = STATUS_AUTOMAT;
4988 uint loopback = LOOPBACK;
4989 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
4990 char *session = NULL;
4991 uint hex_charset = HEX_CHARSET;
4992 uint hex_salt = HEX_SALT;
4993 uint hex_wordlist = HEX_WORDLIST;
4994 uint rp_gen = RP_GEN;
4995 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
4996 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
4997 uint rp_gen_seed = RP_GEN_SEED;
4998 char *rule_buf_l = (char *) RULE_BUF_L;
4999 char *rule_buf_r = (char *) RULE_BUF_R;
5000 uint increment = INCREMENT;
5001 uint increment_min = INCREMENT_MIN;
5002 uint increment_max = INCREMENT_MAX;
5003 char *cpu_affinity = NULL;
5004 char *gpu_devices = NULL;
5005 char *truecrypt_keyfiles = NULL;
5006 uint workload_profile = WORKLOAD_PROFILE;
5007 uint gpu_accel = GPU_ACCEL;
5008 uint gpu_loops = GPU_LOOPS;
5009 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5010 uint gpu_temp_abort = GPU_TEMP_ABORT;
5011 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5012 uint powertune_enable = POWERTUNE_ENABLE;
5013 uint logfile_disable = LOGFILE_DISABLE;
5014 uint segment_size = SEGMENT_SIZE;
5015 uint scrypt_tmto = SCRYPT_TMTO;
5016 char separator = SEPARATOR;
5017 uint bitmap_min = BITMAP_MIN;
5018 uint bitmap_max = BITMAP_MAX;
5019 char *custom_charset_1 = NULL;
5020 char *custom_charset_2 = NULL;
5021 char *custom_charset_3 = NULL;
5022 char *custom_charset_4 = NULL;
5023
5024 #define IDX_HELP 'h'
5025 #define IDX_VERSION 'V'
5026 #define IDX_VERSION_LOWER 'v'
5027 #define IDX_QUIET 0xff02
5028 #define IDX_SHOW 0xff03
5029 #define IDX_LEFT 0xff04
5030 #define IDX_REMOVE 0xff05
5031 #define IDX_REMOVE_TIMER 0xff37
5032 #define IDX_SKIP 's'
5033 #define IDX_LIMIT 'l'
5034 #define IDX_KEYSPACE 0xff35
5035 #define IDX_POTFILE_DISABLE 0xff06
5036 #define IDX_DEBUG_MODE 0xff43
5037 #define IDX_DEBUG_FILE 0xff44
5038 #define IDX_INDUCTION_DIR 0xff46
5039 #define IDX_OUTFILE_CHECK_DIR 0xff47
5040 #define IDX_USERNAME 0xff07
5041 #define IDX_FORCE 0xff08
5042 #define IDX_RUNTIME 0xff09
5043 #define IDX_BENCHMARK 'b'
5044 #define IDX_BENCHMARK_MODE 0xff32
5045 #define IDX_HASH_MODE 'm'
5046 #define IDX_ATTACK_MODE 'a'
5047 #define IDX_RP_FILE 'r'
5048 #define IDX_RP_GEN 'g'
5049 #define IDX_RP_GEN_FUNC_MIN 0xff10
5050 #define IDX_RP_GEN_FUNC_MAX 0xff11
5051 #define IDX_RP_GEN_SEED 0xff34
5052 #define IDX_RULE_BUF_L 'j'
5053 #define IDX_RULE_BUF_R 'k'
5054 #define IDX_INCREMENT 'i'
5055 #define IDX_INCREMENT_MIN 0xff12
5056 #define IDX_INCREMENT_MAX 0xff13
5057 #define IDX_OUTFILE 'o'
5058 #define IDX_OUTFILE_FORMAT 0xff14
5059 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5060 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5061 #define IDX_RESTORE 0xff15
5062 #define IDX_RESTORE_DISABLE 0xff27
5063 #define IDX_STATUS 0xff17
5064 #define IDX_STATUS_TIMER 0xff18
5065 #define IDX_STATUS_AUTOMAT 0xff50
5066 #define IDX_LOOPBACK 0xff38
5067 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5068 #define IDX_SESSION 0xff19
5069 #define IDX_HEX_CHARSET 0xff20
5070 #define IDX_HEX_SALT 0xff21
5071 #define IDX_HEX_WORDLIST 0xff40
5072 #define IDX_MARKOV_DISABLE 0xff22
5073 #define IDX_MARKOV_CLASSIC 0xff23
5074 #define IDX_MARKOV_THRESHOLD 't'
5075 #define IDX_MARKOV_HCSTAT 0xff24
5076 #define IDX_CPU_AFFINITY 0xff25
5077 #define IDX_GPU_DEVICES 'd'
5078 #define IDX_WORKLOAD_PROFILE 'w'
5079 #define IDX_GPU_ACCEL 'n'
5080 #define IDX_GPU_LOOPS 'u'
5081 #define IDX_GPU_TEMP_DISABLE 0xff29
5082 #define IDX_GPU_TEMP_ABORT 0xff30
5083 #define IDX_GPU_TEMP_RETAIN 0xff31
5084 #define IDX_POWERTUNE_ENABLE 0xff41
5085 #define IDX_LOGFILE_DISABLE 0xff51
5086 #define IDX_TRUECRYPT_KEYFILES 0xff52
5087 #define IDX_SCRYPT_TMTO 0xff61
5088 #define IDX_SEGMENT_SIZE 'c'
5089 #define IDX_SEPARATOR 'p'
5090 #define IDX_BITMAP_MIN 0xff70
5091 #define IDX_BITMAP_MAX 0xff71
5092 #define IDX_CUSTOM_CHARSET_1 '1'
5093 #define IDX_CUSTOM_CHARSET_2 '2'
5094 #define IDX_CUSTOM_CHARSET_3 '3'
5095 #define IDX_CUSTOM_CHARSET_4 '4'
5096
5097 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5098
5099 struct option long_options[] =
5100 {
5101 {"help", no_argument, 0, IDX_HELP},
5102 {"version", no_argument, 0, IDX_VERSION},
5103 {"quiet", no_argument, 0, IDX_QUIET},
5104 {"show", no_argument, 0, IDX_SHOW},
5105 {"left", no_argument, 0, IDX_LEFT},
5106 {"username", no_argument, 0, IDX_USERNAME},
5107 {"remove", no_argument, 0, IDX_REMOVE},
5108 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5109 {"skip", required_argument, 0, IDX_SKIP},
5110 {"limit", required_argument, 0, IDX_LIMIT},
5111 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5112 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5113 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5114 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5115 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5116 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5117 {"force", no_argument, 0, IDX_FORCE},
5118 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5119 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5120 {"restore", no_argument, 0, IDX_RESTORE},
5121 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5122 {"status", no_argument, 0, IDX_STATUS},
5123 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5124 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5125 {"loopback", no_argument, 0, IDX_LOOPBACK},
5126 {"weak-hash-threshold",
5127 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5128 {"session", required_argument, 0, IDX_SESSION},
5129 {"runtime", required_argument, 0, IDX_RUNTIME},
5130 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5131 {"generate-rules-func-min",
5132 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5133 {"generate-rules-func-max",
5134 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5135 {"generate-rules-seed",
5136 required_argument, 0, IDX_RP_GEN_SEED},
5137 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5138 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5139 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5140 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5141 {"rules-file", required_argument, 0, IDX_RP_FILE},
5142 {"outfile", required_argument, 0, IDX_OUTFILE},
5143 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5144 {"outfile-autohex-disable",
5145 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5146 {"outfile-check-timer",
5147 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5148 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5149 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5150 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5151 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5152 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5153 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5154 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5155 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5156 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5157 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5158 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5159 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5160 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5161 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5162 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5163 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5164 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5165 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5166 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5167 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5168 // deprecated
5169 {"seperator", required_argument, 0, IDX_SEPARATOR},
5170 {"separator", required_argument, 0, IDX_SEPARATOR},
5171 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5172 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5173 {"increment", no_argument, 0, IDX_INCREMENT},
5174 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5175 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5176 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5177 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5178 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5179 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5180
5181 {0, 0, 0, 0}
5182 };
5183
5184 uint rp_files_cnt = 0;
5185
5186 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5187
5188 int option_index;
5189 int c;
5190
5191 optind = 1;
5192 optopt = 0;
5193 option_index = 0;
5194
5195 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5196 {
5197 switch (c)
5198 {
5199 case IDX_HELP: usage = 1; break;
5200 case IDX_VERSION:
5201 case IDX_VERSION_LOWER: version = 1; break;
5202 case IDX_RESTORE: restore = 1; break;
5203 case IDX_SESSION: session = optarg; break;
5204 case IDX_SHOW: show = 1; break;
5205 case IDX_LEFT: left = 1; break;
5206 case '?': return (-1);
5207 }
5208 }
5209
5210 if (optopt != 0)
5211 {
5212 log_error ("ERROR: Invalid argument specified");
5213
5214 return (-1);
5215 }
5216
5217 /**
5218 * exit functions
5219 */
5220
5221 if (version)
5222 {
5223 log_info (VERSION_TXT);
5224
5225 return (0);
5226 }
5227
5228 if (usage)
5229 {
5230 usage_big_print (PROGNAME);
5231
5232 return (0);
5233 }
5234
5235 /**
5236 * session
5237 */
5238
5239 if (session == NULL) session = (char *) PROGNAME;
5240
5241 size_t session_size = strlen (session) + 32;
5242
5243 data.session = session;
5244
5245 char *eff_restore_file = (char *) mymalloc (session_size);
5246 char *new_restore_file = (char *) mymalloc (session_size);
5247
5248 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5249 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5250
5251 data.eff_restore_file = eff_restore_file;
5252 data.new_restore_file = new_restore_file;
5253
5254 if (((show == 1) || (left == 1)) && (restore == 1))
5255 {
5256 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5257 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5258
5259 return (-1);
5260 }
5261
5262 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5263 if ((show == 1) || (left == 1))
5264 {
5265 restore_disable = 1;
5266
5267 restore = 0;
5268 }
5269
5270 data.restore_disable = restore_disable;
5271
5272 restore_data_t *rd = init_restore (argc, argv);
5273
5274 data.rd = rd;
5275
5276 /**
5277 * restore file
5278 */
5279
5280 if (restore == 1)
5281 {
5282 read_restore (eff_restore_file, rd);
5283
5284 if (rd->version_bin < RESTORE_MIN)
5285 {
5286 log_error ("ERROR: Incompatible restore-file version");
5287
5288 return (-1);
5289 }
5290
5291 myargc = rd->argc;
5292 myargv = rd->argv;
5293
5294 #ifdef _POSIX
5295 rd->pid = getpid ();
5296 #elif _WIN
5297 rd->pid = GetCurrentProcessId ();
5298 #endif
5299 }
5300
5301 uint hash_mode_chgd = 0;
5302 uint runtime_chgd = 0;
5303 uint gpu_loops_chgd = 0;
5304 uint gpu_accel_chgd = 0;
5305 uint attack_mode_chgd = 0;
5306 uint outfile_format_chgd = 0;
5307 uint rp_gen_seed_chgd = 0;
5308 uint remove_timer_chgd = 0;
5309 uint increment_min_chgd = 0;
5310 uint increment_max_chgd = 0;
5311 uint gpu_temp_abort_chgd = 0;
5312 uint gpu_temp_retain_chgd = 0;
5313
5314 optind = 1;
5315 optopt = 0;
5316 option_index = 0;
5317
5318 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5319 {
5320 switch (c)
5321 {
5322 //case IDX_HELP: usage = 1; break;
5323 //case IDX_VERSION: version = 1; break;
5324 //case IDX_RESTORE: restore = 1; break;
5325 case IDX_QUIET: quiet = 1; break;
5326 //case IDX_SHOW: show = 1; break;
5327 case IDX_SHOW: break;
5328 //case IDX_LEFT: left = 1; break;
5329 case IDX_LEFT: break;
5330 case IDX_USERNAME: username = 1; break;
5331 case IDX_REMOVE: remove = 1; break;
5332 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5333 remove_timer_chgd = 1; break;
5334 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5335 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5336 case IDX_DEBUG_FILE: debug_file = optarg; break;
5337 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5338 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5339 case IDX_FORCE: force = 1; break;
5340 case IDX_SKIP: skip = atoll (optarg); break;
5341 case IDX_LIMIT: limit = atoll (optarg); break;
5342 case IDX_KEYSPACE: keyspace = 1; break;
5343 case IDX_BENCHMARK: benchmark = 1; break;
5344 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5345 case IDX_RESTORE: break;
5346 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5347 case IDX_STATUS: status = 1; break;
5348 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5349 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5350 case IDX_LOOPBACK: loopback = 1; break;
5351 case IDX_WEAK_HASH_THRESHOLD:
5352 weak_hash_threshold = atoi (optarg); break;
5353 //case IDX_SESSION: session = optarg; break;
5354 case IDX_SESSION: break;
5355 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5356 hash_mode_chgd = 1; break;
5357 case IDX_RUNTIME: runtime = atoi (optarg);
5358 runtime_chgd = 1; break;
5359 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5360 attack_mode_chgd = 1; break;
5361 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5362 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5363 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5364 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5365 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5366 rp_gen_seed_chgd = 1; break;
5367 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5368 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5369 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5370 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5371 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5372 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5373 case IDX_OUTFILE: outfile = optarg; break;
5374 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5375 outfile_format_chgd = 1; break;
5376 case IDX_OUTFILE_AUTOHEX_DISABLE:
5377 outfile_autohex = 0; break;
5378 case IDX_OUTFILE_CHECK_TIMER:
5379 outfile_check_timer = atoi (optarg); break;
5380 case IDX_HEX_CHARSET: hex_charset = 1; break;
5381 case IDX_HEX_SALT: hex_salt = 1; break;
5382 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5383 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5384 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5385 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5386 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5387 gpu_accel_chgd = 1; break;
5388 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5389 gpu_loops_chgd = 1; break;
5390 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5391 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5392 gpu_temp_abort = atoi (optarg); break;
5393 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5394 gpu_temp_retain = atoi (optarg); break;
5395 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5396 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5397 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5398 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5399 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5400 case IDX_SEPARATOR: separator = optarg[0]; break;
5401 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5402 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5403 case IDX_INCREMENT: increment = 1; break;
5404 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5405 increment_min_chgd = 1; break;
5406 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5407 increment_max_chgd = 1; break;
5408 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5409 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5410 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5411 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5412
5413 default:
5414 log_error ("ERROR: Invalid argument specified");
5415 return (-1);
5416 }
5417 }
5418
5419 if (optopt != 0)
5420 {
5421 log_error ("ERROR: Invalid argument specified");
5422
5423 return (-1);
5424 }
5425
5426 /**
5427 * Inform user things getting started,
5428 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5429 * - we do not need to check algorithm_pos
5430 */
5431
5432 if (quiet == 0)
5433 {
5434 if (benchmark == 1)
5435 {
5436 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5437
5438 log_info ("");
5439 }
5440 else if (restore == 1)
5441 {
5442 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5443
5444 log_info ("");
5445 }
5446 else
5447 {
5448 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5449
5450 log_info ("");
5451 }
5452 }
5453
5454 /**
5455 * sanity check
5456 */
5457
5458 if (attack_mode > 7)
5459 {
5460 log_error ("ERROR: Invalid attack-mode specified");
5461
5462 return (-1);
5463 }
5464
5465 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5466 {
5467 log_error ("ERROR: Invalid runtime specified");
5468
5469 return (-1);
5470 }
5471
5472 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5473 {
5474 log_error ("ERROR: Invalid hash-type specified");
5475
5476 return (-1);
5477 }
5478
5479 // renamed hash modes
5480
5481 if (hash_mode_chgd)
5482 {
5483 int n = -1;
5484
5485 switch (hash_mode)
5486 {
5487 case 123: n = 124;
5488 break;
5489 }
5490
5491 if (n >= 0)
5492 {
5493 log_error ("Old -m specified, use -m %d instead", n);
5494
5495 return (-1);
5496 }
5497 }
5498
5499 if (username == 1)
5500 {
5501 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5502 {
5503 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5504
5505 return (-1);
5506 }
5507 }
5508
5509 if (outfile_format > 16)
5510 {
5511 log_error ("ERROR: Invalid outfile-format specified");
5512
5513 return (-1);
5514 }
5515
5516 if (left == 1)
5517 {
5518 if (outfile_format_chgd == 1)
5519 {
5520 if (outfile_format > 1)
5521 {
5522 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5523
5524 return (-1);
5525 }
5526 }
5527 else
5528 {
5529 outfile_format = OUTFILE_FMT_HASH;
5530 }
5531 }
5532
5533 if (show == 1)
5534 {
5535 if (outfile_format_chgd == 1)
5536 {
5537 if ((outfile_format > 7) && (outfile_format < 16))
5538 {
5539 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5540
5541 return (-1);
5542 }
5543 }
5544 }
5545
5546 if (increment_min < INCREMENT_MIN)
5547 {
5548 log_error ("ERROR: Invalid increment-min specified");
5549
5550 return (-1);
5551 }
5552
5553 if (increment_max > INCREMENT_MAX)
5554 {
5555 log_error ("ERROR: Invalid increment-max specified");
5556
5557 return (-1);
5558 }
5559
5560 if (increment_min > increment_max)
5561 {
5562 log_error ("ERROR: Invalid increment-min specified");
5563
5564 return (-1);
5565 }
5566
5567 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5568 {
5569 log_error ("ERROR: increment is not allowed in attack-mode 0");
5570
5571 return (-1);
5572 }
5573
5574 if ((increment == 0) && (increment_min_chgd == 1))
5575 {
5576 log_error ("ERROR: increment-min is only supported together with increment switch");
5577
5578 return (-1);
5579 }
5580
5581 if ((increment == 0) && (increment_max_chgd == 1))
5582 {
5583 log_error ("ERROR: increment-max is only supported together with increment switch");
5584
5585 return (-1);
5586 }
5587
5588 if (rp_files_cnt && rp_gen)
5589 {
5590 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5591
5592 return (-1);
5593 }
5594
5595 if (rp_files_cnt || rp_gen)
5596 {
5597 if (attack_mode != ATTACK_MODE_STRAIGHT)
5598 {
5599 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5600
5601 return (-1);
5602 }
5603 }
5604
5605 if (rp_gen_func_min > rp_gen_func_max)
5606 {
5607 log_error ("ERROR: Invalid rp-gen-func-min specified");
5608
5609 return (-1);
5610 }
5611
5612 if (gpu_accel_chgd == 1)
5613 {
5614 if (workload_profile != WORKLOAD_PROFILE)
5615 {
5616 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5617
5618 return (-1);
5619 }
5620
5621 if (gpu_accel < 1)
5622 {
5623 log_error ("ERROR: Invalid gpu-accel specified");
5624
5625 return (-1);
5626 }
5627
5628 if (gpu_accel > 800)
5629 {
5630 log_error ("ERROR: Invalid gpu-accel specified");
5631
5632 return (-1);
5633 }
5634 }
5635
5636 if (gpu_loops_chgd == 1)
5637 {
5638 if (workload_profile != WORKLOAD_PROFILE)
5639 {
5640 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5641
5642 return (-1);
5643 }
5644
5645 if (gpu_loops < 1)
5646 {
5647 log_error ("ERROR: Invalid gpu-loops specified");
5648
5649 return (-1);
5650 }
5651
5652 if (gpu_loops > 1024)
5653 {
5654 log_error ("ERROR: Invalid gpu-loops specified");
5655
5656 return (-1);
5657 }
5658 }
5659
5660 if (benchmark == 1)
5661 {
5662 if (workload_profile != WORKLOAD_PROFILE)
5663 {
5664 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5665
5666 return (-1);
5667 }
5668 }
5669
5670 if ((workload_profile < 1) || (workload_profile > 3))
5671 {
5672 log_error ("ERROR: workload-profile %i not available", workload_profile);
5673
5674 return (-1);
5675 }
5676
5677 if (show == 1 || left == 1)
5678 {
5679 attack_mode = ATTACK_MODE_NONE;
5680
5681 if (remove == 1)
5682 {
5683 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5684
5685 return (-1);
5686 }
5687
5688 if (potfile_disable == 1)
5689 {
5690 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5691
5692 return (-1);
5693 }
5694 }
5695
5696 uint attack_kern = ATTACK_KERN_NONE;
5697
5698 switch (attack_mode)
5699 {
5700 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5701 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5702 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5703 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5704 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5705 }
5706
5707 if (benchmark == 0)
5708 {
5709 if (keyspace == 1)
5710 {
5711 int num_additional_params = 1;
5712
5713 if (attack_kern == ATTACK_KERN_COMBI)
5714 {
5715 num_additional_params = 2;
5716 }
5717
5718 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5719
5720 if (keyspace_wordlist_specified == 0) optind--;
5721 }
5722
5723 if (attack_kern == ATTACK_KERN_NONE)
5724 {
5725 if ((optind + 1) != myargc)
5726 {
5727 usage_mini_print (myargv[0]);
5728
5729 return (-1);
5730 }
5731 }
5732 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5733 {
5734 if ((optind + 1) > myargc)
5735 {
5736 usage_mini_print (myargv[0]);
5737
5738 return (-1);
5739 }
5740 }
5741 else if (attack_kern == ATTACK_KERN_COMBI)
5742 {
5743 if ((optind + 3) != myargc)
5744 {
5745 usage_mini_print (myargv[0]);
5746
5747 return (-1);
5748 }
5749 }
5750 else if (attack_kern == ATTACK_KERN_BF)
5751 {
5752 if ((optind + 1) > myargc)
5753 {
5754 usage_mini_print (myargv[0]);
5755
5756 return (-1);
5757 }
5758 }
5759 else
5760 {
5761 usage_mini_print (myargv[0]);
5762
5763 return (-1);
5764 }
5765 }
5766 else
5767 {
5768 if (myargv[optind] != 0)
5769 {
5770 log_error ("ERROR: Invalid argument for benchmark mode specified");
5771
5772 return (-1);
5773 }
5774
5775 if (attack_mode_chgd == 1)
5776 {
5777 if (attack_mode != ATTACK_MODE_BF)
5778 {
5779 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5780
5781 return (-1);
5782 }
5783 }
5784
5785 if (benchmark_mode == 0)
5786 {
5787 // nothing to do
5788 }
5789 else if (benchmark_mode == 1)
5790 {
5791 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5792 {
5793 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5794
5795 return (-1);
5796 }
5797 }
5798 else
5799 {
5800 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5801
5802 return (-1);
5803 }
5804 }
5805
5806 if (skip != 0 && limit != 0)
5807 {
5808 limit += skip;
5809 }
5810
5811 if (keyspace == 1)
5812 {
5813 if (show == 1)
5814 {
5815 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5816
5817 return (-1);
5818 }
5819 else if (left == 1)
5820 {
5821 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5822
5823 return (-1);
5824 }
5825
5826 potfile_disable = 1;
5827
5828 restore_disable = 1;
5829
5830 restore = 0;
5831
5832 weak_hash_threshold = 0;
5833
5834 quiet = 1;
5835 }
5836
5837 if (remove_timer_chgd == 1)
5838 {
5839 if (remove == 0)
5840 {
5841 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5842
5843 return (-1);
5844 }
5845
5846 if (remove_timer < 1)
5847 {
5848 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5849
5850 return (-1);
5851 }
5852 }
5853
5854 if (loopback == 1)
5855 {
5856 if (attack_mode == ATTACK_MODE_BF)
5857 {
5858 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5859
5860 return (-1);
5861 }
5862 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5863 {
5864 if ((rp_files_cnt == 0) && (rp_gen == 0))
5865 {
5866 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5867
5868 return (-1);
5869 }
5870 }
5871 }
5872
5873 if (debug_mode > 0)
5874 {
5875 if (attack_mode != ATTACK_MODE_STRAIGHT)
5876 {
5877 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5878
5879 return (-1);
5880 }
5881
5882 if ((rp_files_cnt == 0) && (rp_gen == 0))
5883 {
5884 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5885
5886 return (-1);
5887 }
5888 }
5889
5890 if (debug_mode > 4)
5891 {
5892 log_error ("ERROR: Invalid debug-mode specified");
5893
5894 return (-1);
5895 }
5896
5897 if (debug_file != NULL)
5898 {
5899 if (debug_mode < 1)
5900 {
5901 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5902
5903 return (-1);
5904 }
5905 }
5906
5907 if (induction_dir != NULL)
5908 {
5909 if (attack_mode == ATTACK_MODE_BF)
5910 {
5911 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5912
5913 return (-1);
5914 }
5915 }
5916
5917 /**
5918 * induction directory
5919 */
5920
5921 char *induction_directory = NULL;
5922
5923 if (attack_mode != ATTACK_MODE_BF)
5924 {
5925 if (induction_dir == NULL)
5926 {
5927 induction_directory = (char *) mymalloc (session_size);
5928
5929 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
5930
5931 // create induction folder if it does not already exist
5932
5933 if (keyspace == 0)
5934 {
5935 if (rmdir (induction_directory) == -1)
5936 {
5937 if (errno == ENOENT)
5938 {
5939 // good, we can ignore
5940 }
5941 else if (errno == ENOTEMPTY)
5942 {
5943 char *induction_directory_mv = (char *) mymalloc (session_size);
5944
5945 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
5946
5947 if (rename (induction_directory, induction_directory_mv) != 0)
5948 {
5949 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
5950
5951 return (-1);
5952 }
5953 }
5954 else
5955 {
5956 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5957
5958 return (-1);
5959 }
5960 }
5961
5962 #ifdef _WIN
5963 #define mkdir(name,mode) mkdir (name)
5964 #endif
5965
5966 if (mkdir (induction_directory, 0700) == -1)
5967 {
5968 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5969
5970 return (-1);
5971 }
5972 }
5973 }
5974 else
5975 {
5976 induction_directory = induction_dir;
5977 }
5978 }
5979
5980 data.induction_directory = induction_directory;
5981
5982 /**
5983 * loopback
5984 */
5985
5986 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
5987
5988 char *loopback_file = (char *) mymalloc (loopback_size);
5989
5990 /**
5991 * outfile-check directory
5992 */
5993
5994 char *outfile_check_directory = NULL;
5995
5996 if (outfile_check_dir == NULL)
5997 {
5998 outfile_check_directory = (char *) mymalloc (session_size);
5999
6000 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
6001 }
6002 else
6003 {
6004 outfile_check_directory = outfile_check_dir;
6005 }
6006
6007 data.outfile_check_directory = outfile_check_directory;
6008
6009 if (keyspace == 0)
6010 {
6011 struct stat outfile_check_stat;
6012
6013 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6014 {
6015 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6016
6017 if (is_dir == 0)
6018 {
6019 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6020
6021 return (-1);
6022 }
6023 }
6024 else if (outfile_check_dir == NULL)
6025 {
6026 #ifdef _WIN
6027 #define mkdir(name,mode) mkdir (name)
6028 #endif
6029
6030 if (mkdir (outfile_check_directory, 0700) == -1)
6031 {
6032 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6033
6034 return (-1);
6035 }
6036 }
6037 }
6038
6039 /**
6040 * special other stuff
6041 */
6042
6043 if (hash_mode == 9710)
6044 {
6045 outfile_format = 5;
6046 outfile_format_chgd = 1;
6047 }
6048
6049 if (hash_mode == 9810)
6050 {
6051 outfile_format = 5;
6052 outfile_format_chgd = 1;
6053 }
6054
6055 if (hash_mode == 10410)
6056 {
6057 outfile_format = 5;
6058 outfile_format_chgd = 1;
6059 }
6060
6061 /**
6062 * store stuff
6063 */
6064
6065 data.hash_mode = hash_mode;
6066 data.restore = restore;
6067 data.restore_timer = restore_timer;
6068 data.restore_disable = restore_disable;
6069 data.status = status;
6070 data.status_timer = status_timer;
6071 data.status_automat = status_automat;
6072 data.loopback = loopback;
6073 data.runtime = runtime;
6074 data.remove = remove;
6075 data.remove_timer = remove_timer;
6076 data.debug_mode = debug_mode;
6077 data.debug_file = debug_file;
6078 data.username = username;
6079 data.quiet = quiet;
6080 data.outfile = outfile;
6081 data.outfile_format = outfile_format;
6082 data.outfile_autohex = outfile_autohex;
6083 data.hex_charset = hex_charset;
6084 data.hex_salt = hex_salt;
6085 data.hex_wordlist = hex_wordlist;
6086 data.separator = separator;
6087 data.rp_files = rp_files;
6088 data.rp_files_cnt = rp_files_cnt;
6089 data.rp_gen = rp_gen;
6090 data.rp_gen_seed = rp_gen_seed;
6091 data.force = force;
6092 data.benchmark = benchmark;
6093 data.skip = skip;
6094 data.limit = limit;
6095 data.powertune_enable = powertune_enable;
6096 data.logfile_disable = logfile_disable;
6097 data.truecrypt_keyfiles = truecrypt_keyfiles;
6098 data.scrypt_tmto = scrypt_tmto;
6099
6100 /**
6101 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6102 */
6103
6104 #ifdef LINUX
6105
6106 char *resolved_path = realpath (myargv[0], NULL);
6107
6108 char *install_dir = get_install_dir (resolved_path);
6109 char *profile_dir = NULL;
6110 char *session_dir = NULL;
6111
6112 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6113 {
6114 struct passwd *pw = getpwuid (getuid ());
6115
6116 const char *homedir = pw->pw_dir;
6117
6118 profile_dir = get_profile_dir (homedir);
6119 session_dir = get_session_dir (profile_dir, session);
6120 }
6121 else
6122 {
6123 profile_dir = install_dir;
6124 session_dir = install_dir;
6125 }
6126
6127 myfree (resolved_path);
6128
6129 #else
6130
6131 char *install_dir = get_install_dir (myargv[0]);
6132 char *profile_dir = install_dir;
6133 char *session_dir = install_dir;
6134
6135 #endif
6136
6137 data.install_dir = install_dir;
6138 data.profile_dir = profile_dir;
6139 data.session_dir = session_dir;
6140
6141 /**
6142 * cpu affinity
6143 */
6144
6145 if (cpu_affinity)
6146 {
6147 set_cpu_affinity (cpu_affinity);
6148 }
6149
6150 if (rp_gen_seed_chgd == 0)
6151 {
6152 srand (proc_start);
6153 }
6154 else
6155 {
6156 srand (rp_gen_seed);
6157 }
6158
6159 /**
6160 * logfile init
6161 */
6162
6163 if (logfile_disable == 0)
6164 {
6165 size_t logfile_size = strlen (session) + 32;
6166
6167 char *logfile = (char *) mymalloc (logfile_size);
6168
6169 snprintf (logfile, logfile_size - 1, "%s.log", session);
6170
6171 data.logfile = logfile;
6172
6173 char *topid = logfile_generate_topid ();
6174
6175 data.topid = topid;
6176 }
6177
6178 // logfile_append() checks for logfile_disable internally to make it easier from here
6179
6180 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6181 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6182 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6183 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6184 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6185 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6186 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6187 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6188 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6189 #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));
6190
6191 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6192 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6193 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6194 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6195 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6196 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6197 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6198 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6199
6200 logfile_top_msg ("START");
6201
6202 logfile_top_uint (attack_mode);
6203 logfile_top_uint (attack_kern);
6204 logfile_top_uint (benchmark);
6205 logfile_top_uint (benchmark_mode);
6206 logfile_top_uint (bitmap_min);
6207 logfile_top_uint (bitmap_max);
6208 logfile_top_uint (debug_mode);
6209 logfile_top_uint (force);
6210 logfile_top_uint (gpu_accel);
6211 logfile_top_uint (gpu_loops);
6212 logfile_top_uint (gpu_temp_abort);
6213 logfile_top_uint (gpu_temp_disable);
6214 logfile_top_uint (gpu_temp_retain);
6215 logfile_top_uint (hash_mode);
6216 logfile_top_uint (hex_charset);
6217 logfile_top_uint (hex_salt);
6218 logfile_top_uint (hex_wordlist);
6219 logfile_top_uint (increment);
6220 logfile_top_uint (increment_max);
6221 logfile_top_uint (increment_min);
6222 logfile_top_uint (keyspace);
6223 logfile_top_uint (left);
6224 logfile_top_uint (logfile_disable);
6225 logfile_top_uint (loopback);
6226 logfile_top_uint (markov_classic);
6227 logfile_top_uint (markov_disable);
6228 logfile_top_uint (markov_threshold);
6229 logfile_top_uint (outfile_autohex);
6230 logfile_top_uint (outfile_check_timer);
6231 logfile_top_uint (outfile_format);
6232 logfile_top_uint (potfile_disable);
6233 logfile_top_uint (powertune_enable);
6234 logfile_top_uint (scrypt_tmto);
6235 logfile_top_uint (quiet);
6236 logfile_top_uint (remove);
6237 logfile_top_uint (remove_timer);
6238 logfile_top_uint (restore);
6239 logfile_top_uint (restore_disable);
6240 logfile_top_uint (restore_timer);
6241 logfile_top_uint (rp_gen);
6242 logfile_top_uint (rp_gen_func_max);
6243 logfile_top_uint (rp_gen_func_min);
6244 logfile_top_uint (rp_gen_seed);
6245 logfile_top_uint (runtime);
6246 logfile_top_uint (segment_size);
6247 logfile_top_uint (show);
6248 logfile_top_uint (status);
6249 logfile_top_uint (status_automat);
6250 logfile_top_uint (status_timer);
6251 logfile_top_uint (usage);
6252 logfile_top_uint (username);
6253 logfile_top_uint (version);
6254 logfile_top_uint (weak_hash_threshold);
6255 logfile_top_uint (workload_profile);
6256 logfile_top_uint64 (limit);
6257 logfile_top_uint64 (skip);
6258 logfile_top_char (separator);
6259 logfile_top_string (cpu_affinity);
6260 logfile_top_string (custom_charset_1);
6261 logfile_top_string (custom_charset_2);
6262 logfile_top_string (custom_charset_3);
6263 logfile_top_string (custom_charset_4);
6264 logfile_top_string (debug_file);
6265 logfile_top_string (gpu_devices);
6266 logfile_top_string (induction_dir);
6267 logfile_top_string (markov_hcstat);
6268 logfile_top_string (outfile);
6269 logfile_top_string (outfile_check_dir);
6270 logfile_top_string (rule_buf_l);
6271 logfile_top_string (rule_buf_r);
6272 logfile_top_string (session);
6273 logfile_top_string (truecrypt_keyfiles);
6274
6275 /**
6276 * devices
6277 */
6278
6279 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6280
6281 /**
6282 * benchmark
6283 */
6284
6285 if (benchmark == 1)
6286 {
6287 /**
6288 * disable useless stuff for benchmark
6289 */
6290
6291 restore_timer = 0;
6292 status_timer = 0;
6293 restore_disable = 1;
6294 potfile_disable = 1;
6295 weak_hash_threshold = 0;
6296
6297 data.restore_timer = restore_timer;
6298 data.status_timer = status_timer;
6299 data.restore_disable = restore_disable;
6300
6301 if (benchmark_mode == 1)
6302 {
6303 markov_disable = 1;
6304 }
6305
6306 /**
6307 * force attack mode to be bruteforce
6308 */
6309
6310 attack_mode = ATTACK_MODE_BF;
6311 attack_kern = ATTACK_KERN_BF;
6312
6313 if (runtime_chgd == 0)
6314 {
6315 runtime = 4;
6316
6317 if (benchmark_mode == 1) runtime = 17;
6318
6319 data.runtime = runtime;
6320 }
6321 }
6322
6323 /**
6324 * config
6325 */
6326
6327 uint hash_type = 0;
6328 uint salt_type = 0;
6329 uint attack_exec = 0;
6330 uint opts_type = 0;
6331 uint kern_type = 0;
6332 uint dgst_size = 0;
6333 uint esalt_size = 0;
6334 uint opti_type = 0;
6335 uint dgst_pos0 = -1;
6336 uint dgst_pos1 = -1;
6337 uint dgst_pos2 = -1;
6338 uint dgst_pos3 = -1;
6339
6340 int (*parse_func) (char *, uint, hash_t *);
6341 int (*sort_by_digest) (const void *, const void *);
6342
6343 uint algorithm_pos = 0;
6344 uint algorithm_max = 1;
6345
6346 uint *algorithms = default_benchmark_algorithms;
6347
6348 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6349
6350 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6351 {
6352 /*
6353 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6354 * the following algos are skipped entirely
6355 */
6356
6357 if (algorithm_pos > 0)
6358 {
6359 local_free (rd);
6360
6361 rd = init_restore (argc, argv);
6362
6363 data.rd = rd;
6364 }
6365
6366 /**
6367 * update hash_mode in case of multihash benchmark
6368 */
6369
6370 if (benchmark == 1)
6371 {
6372 if (hash_mode_chgd == 0)
6373 {
6374 hash_mode = algorithms[algorithm_pos];
6375
6376 data.hash_mode = hash_mode;
6377 }
6378
6379 quiet = 1;
6380
6381 data.quiet = quiet;
6382 }
6383
6384 switch (hash_mode)
6385 {
6386 case 0: hash_type = HASH_TYPE_MD5;
6387 salt_type = SALT_TYPE_NONE;
6388 attack_exec = ATTACK_EXEC_ON_GPU;
6389 opts_type = OPTS_TYPE_PT_GENERATE_LE
6390 | OPTS_TYPE_PT_ADD80
6391 | OPTS_TYPE_PT_ADDBITS14;
6392 kern_type = KERN_TYPE_MD5;
6393 dgst_size = DGST_SIZE_4_4;
6394 parse_func = md5_parse_hash;
6395 sort_by_digest = sort_by_digest_4_4;
6396 opti_type = OPTI_TYPE_ZERO_BYTE
6397 | OPTI_TYPE_PRECOMPUTE_INIT
6398 | OPTI_TYPE_PRECOMPUTE_MERKLE
6399 | OPTI_TYPE_MEET_IN_MIDDLE
6400 | OPTI_TYPE_EARLY_SKIP
6401 | OPTI_TYPE_NOT_ITERATED
6402 | OPTI_TYPE_NOT_SALTED
6403 | OPTI_TYPE_RAW_HASH;
6404 dgst_pos0 = 0;
6405 dgst_pos1 = 3;
6406 dgst_pos2 = 2;
6407 dgst_pos3 = 1;
6408 break;
6409
6410 case 10: hash_type = HASH_TYPE_MD5;
6411 salt_type = SALT_TYPE_INTERN;
6412 attack_exec = ATTACK_EXEC_ON_GPU;
6413 opts_type = OPTS_TYPE_PT_GENERATE_LE
6414 | OPTS_TYPE_ST_ADD80
6415 | OPTS_TYPE_ST_ADDBITS14;
6416 kern_type = KERN_TYPE_MD5_PWSLT;
6417 dgst_size = DGST_SIZE_4_4;
6418 parse_func = md5s_parse_hash;
6419 sort_by_digest = sort_by_digest_4_4;
6420 opti_type = OPTI_TYPE_ZERO_BYTE
6421 | OPTI_TYPE_PRECOMPUTE_INIT
6422 | OPTI_TYPE_PRECOMPUTE_MERKLE
6423 | OPTI_TYPE_MEET_IN_MIDDLE
6424 | OPTI_TYPE_EARLY_SKIP
6425 | OPTI_TYPE_NOT_ITERATED
6426 | OPTI_TYPE_APPENDED_SALT
6427 | OPTI_TYPE_RAW_HASH;
6428 dgst_pos0 = 0;
6429 dgst_pos1 = 3;
6430 dgst_pos2 = 2;
6431 dgst_pos3 = 1;
6432 break;
6433
6434 case 11: hash_type = HASH_TYPE_MD5;
6435 salt_type = SALT_TYPE_INTERN;
6436 attack_exec = ATTACK_EXEC_ON_GPU;
6437 opts_type = OPTS_TYPE_PT_GENERATE_LE
6438 | OPTS_TYPE_ST_ADD80
6439 | OPTS_TYPE_ST_ADDBITS14;
6440 kern_type = KERN_TYPE_MD5_PWSLT;
6441 dgst_size = DGST_SIZE_4_4;
6442 parse_func = joomla_parse_hash;
6443 sort_by_digest = sort_by_digest_4_4;
6444 opti_type = OPTI_TYPE_ZERO_BYTE
6445 | OPTI_TYPE_PRECOMPUTE_INIT
6446 | OPTI_TYPE_PRECOMPUTE_MERKLE
6447 | OPTI_TYPE_MEET_IN_MIDDLE
6448 | OPTI_TYPE_EARLY_SKIP
6449 | OPTI_TYPE_NOT_ITERATED
6450 | OPTI_TYPE_APPENDED_SALT
6451 | OPTI_TYPE_RAW_HASH;
6452 dgst_pos0 = 0;
6453 dgst_pos1 = 3;
6454 dgst_pos2 = 2;
6455 dgst_pos3 = 1;
6456 break;
6457
6458 case 12: hash_type = HASH_TYPE_MD5;
6459 salt_type = SALT_TYPE_INTERN;
6460 attack_exec = ATTACK_EXEC_ON_GPU;
6461 opts_type = OPTS_TYPE_PT_GENERATE_LE
6462 | OPTS_TYPE_ST_ADD80
6463 | OPTS_TYPE_ST_ADDBITS14;
6464 kern_type = KERN_TYPE_MD5_PWSLT;
6465 dgst_size = DGST_SIZE_4_4;
6466 parse_func = postgresql_parse_hash;
6467 sort_by_digest = sort_by_digest_4_4;
6468 opti_type = OPTI_TYPE_ZERO_BYTE
6469 | OPTI_TYPE_PRECOMPUTE_INIT
6470 | OPTI_TYPE_PRECOMPUTE_MERKLE
6471 | OPTI_TYPE_MEET_IN_MIDDLE
6472 | OPTI_TYPE_EARLY_SKIP
6473 | OPTI_TYPE_NOT_ITERATED
6474 | OPTI_TYPE_APPENDED_SALT
6475 | OPTI_TYPE_RAW_HASH;
6476 dgst_pos0 = 0;
6477 dgst_pos1 = 3;
6478 dgst_pos2 = 2;
6479 dgst_pos3 = 1;
6480 break;
6481
6482 case 20: hash_type = HASH_TYPE_MD5;
6483 salt_type = SALT_TYPE_INTERN;
6484 attack_exec = ATTACK_EXEC_ON_GPU;
6485 opts_type = OPTS_TYPE_PT_GENERATE_LE
6486 | OPTS_TYPE_PT_ADD80
6487 | OPTS_TYPE_PT_ADDBITS14;
6488 kern_type = KERN_TYPE_MD5_SLTPW;
6489 dgst_size = DGST_SIZE_4_4;
6490 parse_func = md5s_parse_hash;
6491 sort_by_digest = sort_by_digest_4_4;
6492 opti_type = OPTI_TYPE_ZERO_BYTE
6493 | OPTI_TYPE_PRECOMPUTE_INIT
6494 | OPTI_TYPE_PRECOMPUTE_MERKLE
6495 | OPTI_TYPE_EARLY_SKIP
6496 | OPTI_TYPE_NOT_ITERATED
6497 | OPTI_TYPE_PREPENDED_SALT
6498 | OPTI_TYPE_RAW_HASH;
6499 dgst_pos0 = 0;
6500 dgst_pos1 = 3;
6501 dgst_pos2 = 2;
6502 dgst_pos3 = 1;
6503 break;
6504
6505 case 21: hash_type = HASH_TYPE_MD5;
6506 salt_type = SALT_TYPE_INTERN;
6507 attack_exec = ATTACK_EXEC_ON_GPU;
6508 opts_type = OPTS_TYPE_PT_GENERATE_LE
6509 | OPTS_TYPE_PT_ADD80
6510 | OPTS_TYPE_PT_ADDBITS14;
6511 kern_type = KERN_TYPE_MD5_SLTPW;
6512 dgst_size = DGST_SIZE_4_4;
6513 parse_func = osc_parse_hash;
6514 sort_by_digest = sort_by_digest_4_4;
6515 opti_type = OPTI_TYPE_ZERO_BYTE
6516 | OPTI_TYPE_PRECOMPUTE_INIT
6517 | OPTI_TYPE_PRECOMPUTE_MERKLE
6518 | OPTI_TYPE_EARLY_SKIP
6519 | OPTI_TYPE_NOT_ITERATED
6520 | OPTI_TYPE_PREPENDED_SALT
6521 | OPTI_TYPE_RAW_HASH;
6522 dgst_pos0 = 0;
6523 dgst_pos1 = 3;
6524 dgst_pos2 = 2;
6525 dgst_pos3 = 1;
6526 break;
6527
6528 case 22: hash_type = HASH_TYPE_MD5;
6529 salt_type = SALT_TYPE_EMBEDDED;
6530 attack_exec = ATTACK_EXEC_ON_GPU;
6531 opts_type = OPTS_TYPE_PT_GENERATE_LE
6532 | OPTS_TYPE_PT_ADD80
6533 | OPTS_TYPE_PT_ADDBITS14;
6534 kern_type = KERN_TYPE_MD5_SLTPW;
6535 dgst_size = DGST_SIZE_4_4;
6536 parse_func = netscreen_parse_hash;
6537 sort_by_digest = sort_by_digest_4_4;
6538 opti_type = OPTI_TYPE_ZERO_BYTE
6539 | OPTI_TYPE_PRECOMPUTE_INIT
6540 | OPTI_TYPE_PRECOMPUTE_MERKLE
6541 | OPTI_TYPE_EARLY_SKIP
6542 | OPTI_TYPE_NOT_ITERATED
6543 | OPTI_TYPE_PREPENDED_SALT
6544 | OPTI_TYPE_RAW_HASH;
6545 dgst_pos0 = 0;
6546 dgst_pos1 = 3;
6547 dgst_pos2 = 2;
6548 dgst_pos3 = 1;
6549 break;
6550
6551 case 23: hash_type = HASH_TYPE_MD5;
6552 salt_type = SALT_TYPE_EMBEDDED;
6553 attack_exec = ATTACK_EXEC_ON_GPU;
6554 opts_type = OPTS_TYPE_PT_GENERATE_LE
6555 | OPTS_TYPE_PT_ADD80
6556 | OPTS_TYPE_PT_ADDBITS14;
6557 kern_type = KERN_TYPE_MD5_SLTPW;
6558 dgst_size = DGST_SIZE_4_4;
6559 parse_func = skype_parse_hash;
6560 sort_by_digest = sort_by_digest_4_4;
6561 opti_type = OPTI_TYPE_ZERO_BYTE
6562 | OPTI_TYPE_PRECOMPUTE_INIT
6563 | OPTI_TYPE_PRECOMPUTE_MERKLE
6564 | OPTI_TYPE_EARLY_SKIP
6565 | OPTI_TYPE_NOT_ITERATED
6566 | OPTI_TYPE_PREPENDED_SALT
6567 | OPTI_TYPE_RAW_HASH;
6568 dgst_pos0 = 0;
6569 dgst_pos1 = 3;
6570 dgst_pos2 = 2;
6571 dgst_pos3 = 1;
6572 break;
6573
6574 case 30: hash_type = HASH_TYPE_MD5;
6575 salt_type = SALT_TYPE_INTERN;
6576 attack_exec = ATTACK_EXEC_ON_GPU;
6577 opts_type = OPTS_TYPE_PT_GENERATE_LE
6578 | OPTS_TYPE_PT_UNICODE
6579 | OPTS_TYPE_ST_ADD80
6580 | OPTS_TYPE_ST_ADDBITS14;
6581 kern_type = KERN_TYPE_MD5_PWUSLT;
6582 dgst_size = DGST_SIZE_4_4;
6583 parse_func = md5s_parse_hash;
6584 sort_by_digest = sort_by_digest_4_4;
6585 opti_type = OPTI_TYPE_ZERO_BYTE
6586 | OPTI_TYPE_PRECOMPUTE_INIT
6587 | OPTI_TYPE_PRECOMPUTE_MERKLE
6588 | OPTI_TYPE_MEET_IN_MIDDLE
6589 | OPTI_TYPE_EARLY_SKIP
6590 | OPTI_TYPE_NOT_ITERATED
6591 | OPTI_TYPE_APPENDED_SALT
6592 | OPTI_TYPE_RAW_HASH;
6593 dgst_pos0 = 0;
6594 dgst_pos1 = 3;
6595 dgst_pos2 = 2;
6596 dgst_pos3 = 1;
6597 break;
6598
6599 case 40: hash_type = HASH_TYPE_MD5;
6600 salt_type = SALT_TYPE_INTERN;
6601 attack_exec = ATTACK_EXEC_ON_GPU;
6602 opts_type = OPTS_TYPE_PT_GENERATE_LE
6603 | OPTS_TYPE_PT_ADD80
6604 | OPTS_TYPE_PT_ADDBITS14
6605 | OPTS_TYPE_PT_UNICODE;
6606 kern_type = KERN_TYPE_MD5_SLTPWU;
6607 dgst_size = DGST_SIZE_4_4;
6608 parse_func = md5s_parse_hash;
6609 sort_by_digest = sort_by_digest_4_4;
6610 opti_type = OPTI_TYPE_ZERO_BYTE
6611 | OPTI_TYPE_PRECOMPUTE_INIT
6612 | OPTI_TYPE_PRECOMPUTE_MERKLE
6613 | OPTI_TYPE_EARLY_SKIP
6614 | OPTI_TYPE_NOT_ITERATED
6615 | OPTI_TYPE_PREPENDED_SALT
6616 | OPTI_TYPE_RAW_HASH;
6617 dgst_pos0 = 0;
6618 dgst_pos1 = 3;
6619 dgst_pos2 = 2;
6620 dgst_pos3 = 1;
6621 break;
6622
6623 case 50: hash_type = HASH_TYPE_MD5;
6624 salt_type = SALT_TYPE_INTERN;
6625 attack_exec = ATTACK_EXEC_ON_GPU;
6626 opts_type = OPTS_TYPE_PT_GENERATE_LE
6627 | OPTS_TYPE_ST_ADD80
6628 | OPTS_TYPE_ST_ADDBITS14;
6629 kern_type = KERN_TYPE_HMACMD5_PW;
6630 dgst_size = DGST_SIZE_4_4;
6631 parse_func = hmacmd5_parse_hash;
6632 sort_by_digest = sort_by_digest_4_4;
6633 opti_type = OPTI_TYPE_ZERO_BYTE
6634 | OPTI_TYPE_NOT_ITERATED;
6635 dgst_pos0 = 0;
6636 dgst_pos1 = 3;
6637 dgst_pos2 = 2;
6638 dgst_pos3 = 1;
6639 break;
6640
6641 case 60: hash_type = HASH_TYPE_MD5;
6642 salt_type = SALT_TYPE_INTERN;
6643 attack_exec = ATTACK_EXEC_ON_GPU;
6644 opts_type = OPTS_TYPE_PT_GENERATE_LE
6645 | OPTS_TYPE_PT_ADD80
6646 | OPTS_TYPE_PT_ADDBITS14;
6647 kern_type = KERN_TYPE_HMACMD5_SLT;
6648 dgst_size = DGST_SIZE_4_4;
6649 parse_func = hmacmd5_parse_hash;
6650 sort_by_digest = sort_by_digest_4_4;
6651 opti_type = OPTI_TYPE_ZERO_BYTE
6652 | OPTI_TYPE_NOT_ITERATED;
6653 dgst_pos0 = 0;
6654 dgst_pos1 = 3;
6655 dgst_pos2 = 2;
6656 dgst_pos3 = 1;
6657 break;
6658
6659 case 100: hash_type = HASH_TYPE_SHA1;
6660 salt_type = SALT_TYPE_NONE;
6661 attack_exec = ATTACK_EXEC_ON_GPU;
6662 opts_type = OPTS_TYPE_PT_GENERATE_BE
6663 | OPTS_TYPE_PT_ADD80
6664 | OPTS_TYPE_PT_ADDBITS15;
6665 kern_type = KERN_TYPE_SHA1;
6666 dgst_size = DGST_SIZE_4_5;
6667 parse_func = sha1_parse_hash;
6668 sort_by_digest = sort_by_digest_4_5;
6669 opti_type = OPTI_TYPE_ZERO_BYTE
6670 | OPTI_TYPE_PRECOMPUTE_INIT
6671 | OPTI_TYPE_PRECOMPUTE_MERKLE
6672 | OPTI_TYPE_EARLY_SKIP
6673 | OPTI_TYPE_NOT_ITERATED
6674 | OPTI_TYPE_NOT_SALTED
6675 | OPTI_TYPE_RAW_HASH;
6676 dgst_pos0 = 3;
6677 dgst_pos1 = 4;
6678 dgst_pos2 = 2;
6679 dgst_pos3 = 1;
6680 break;
6681
6682 case 101: hash_type = HASH_TYPE_SHA1;
6683 salt_type = SALT_TYPE_NONE;
6684 attack_exec = ATTACK_EXEC_ON_GPU;
6685 opts_type = OPTS_TYPE_PT_GENERATE_BE
6686 | OPTS_TYPE_PT_ADD80
6687 | OPTS_TYPE_PT_ADDBITS15;
6688 kern_type = KERN_TYPE_SHA1;
6689 dgst_size = DGST_SIZE_4_5;
6690 parse_func = sha1b64_parse_hash;
6691 sort_by_digest = sort_by_digest_4_5;
6692 opti_type = OPTI_TYPE_ZERO_BYTE
6693 | OPTI_TYPE_PRECOMPUTE_INIT
6694 | OPTI_TYPE_PRECOMPUTE_MERKLE
6695 | OPTI_TYPE_EARLY_SKIP
6696 | OPTI_TYPE_NOT_ITERATED
6697 | OPTI_TYPE_NOT_SALTED
6698 | OPTI_TYPE_RAW_HASH;
6699 dgst_pos0 = 3;
6700 dgst_pos1 = 4;
6701 dgst_pos2 = 2;
6702 dgst_pos3 = 1;
6703 break;
6704
6705 case 110: hash_type = HASH_TYPE_SHA1;
6706 salt_type = SALT_TYPE_INTERN;
6707 attack_exec = ATTACK_EXEC_ON_GPU;
6708 opts_type = OPTS_TYPE_PT_GENERATE_BE
6709 | OPTS_TYPE_ST_ADD80
6710 | OPTS_TYPE_ST_ADDBITS15;
6711 kern_type = KERN_TYPE_SHA1_PWSLT;
6712 dgst_size = DGST_SIZE_4_5;
6713 parse_func = sha1s_parse_hash;
6714 sort_by_digest = sort_by_digest_4_5;
6715 opti_type = OPTI_TYPE_ZERO_BYTE
6716 | OPTI_TYPE_PRECOMPUTE_INIT
6717 | OPTI_TYPE_PRECOMPUTE_MERKLE
6718 | OPTI_TYPE_EARLY_SKIP
6719 | OPTI_TYPE_NOT_ITERATED
6720 | OPTI_TYPE_APPENDED_SALT
6721 | OPTI_TYPE_RAW_HASH;
6722 dgst_pos0 = 3;
6723 dgst_pos1 = 4;
6724 dgst_pos2 = 2;
6725 dgst_pos3 = 1;
6726 break;
6727
6728 case 111: hash_type = HASH_TYPE_SHA1;
6729 salt_type = SALT_TYPE_EMBEDDED;
6730 attack_exec = ATTACK_EXEC_ON_GPU;
6731 opts_type = OPTS_TYPE_PT_GENERATE_BE
6732 | OPTS_TYPE_ST_ADD80
6733 | OPTS_TYPE_ST_ADDBITS15;
6734 kern_type = KERN_TYPE_SHA1_PWSLT;
6735 dgst_size = DGST_SIZE_4_5;
6736 parse_func = sha1b64s_parse_hash;
6737 sort_by_digest = sort_by_digest_4_5;
6738 opti_type = OPTI_TYPE_ZERO_BYTE
6739 | OPTI_TYPE_PRECOMPUTE_INIT
6740 | OPTI_TYPE_PRECOMPUTE_MERKLE
6741 | OPTI_TYPE_EARLY_SKIP
6742 | OPTI_TYPE_NOT_ITERATED
6743 | OPTI_TYPE_APPENDED_SALT
6744 | OPTI_TYPE_RAW_HASH;
6745 dgst_pos0 = 3;
6746 dgst_pos1 = 4;
6747 dgst_pos2 = 2;
6748 dgst_pos3 = 1;
6749 break;
6750
6751 case 112: hash_type = HASH_TYPE_SHA1;
6752 salt_type = SALT_TYPE_INTERN;
6753 attack_exec = ATTACK_EXEC_ON_GPU;
6754 opts_type = OPTS_TYPE_PT_GENERATE_BE
6755 | OPTS_TYPE_ST_ADD80
6756 | OPTS_TYPE_ST_ADDBITS15
6757 | OPTS_TYPE_ST_HEX;
6758 kern_type = KERN_TYPE_SHA1_PWSLT;
6759 dgst_size = DGST_SIZE_4_5;
6760 parse_func = oracles_parse_hash;
6761 sort_by_digest = sort_by_digest_4_5;
6762 opti_type = OPTI_TYPE_ZERO_BYTE
6763 | OPTI_TYPE_PRECOMPUTE_INIT
6764 | OPTI_TYPE_PRECOMPUTE_MERKLE
6765 | OPTI_TYPE_EARLY_SKIP
6766 | OPTI_TYPE_NOT_ITERATED
6767 | OPTI_TYPE_APPENDED_SALT
6768 | OPTI_TYPE_RAW_HASH;
6769 dgst_pos0 = 3;
6770 dgst_pos1 = 4;
6771 dgst_pos2 = 2;
6772 dgst_pos3 = 1;
6773 break;
6774
6775 case 120: hash_type = HASH_TYPE_SHA1;
6776 salt_type = SALT_TYPE_INTERN;
6777 attack_exec = ATTACK_EXEC_ON_GPU;
6778 opts_type = OPTS_TYPE_PT_GENERATE_BE
6779 | OPTS_TYPE_PT_ADD80
6780 | OPTS_TYPE_PT_ADDBITS15;
6781 kern_type = KERN_TYPE_SHA1_SLTPW;
6782 dgst_size = DGST_SIZE_4_5;
6783 parse_func = sha1s_parse_hash;
6784 sort_by_digest = sort_by_digest_4_5;
6785 opti_type = OPTI_TYPE_ZERO_BYTE
6786 | OPTI_TYPE_PRECOMPUTE_INIT
6787 | OPTI_TYPE_PRECOMPUTE_MERKLE
6788 | OPTI_TYPE_EARLY_SKIP
6789 | OPTI_TYPE_NOT_ITERATED
6790 | OPTI_TYPE_PREPENDED_SALT
6791 | OPTI_TYPE_RAW_HASH;
6792 dgst_pos0 = 3;
6793 dgst_pos1 = 4;
6794 dgst_pos2 = 2;
6795 dgst_pos3 = 1;
6796 break;
6797
6798 case 121: hash_type = HASH_TYPE_SHA1;
6799 salt_type = SALT_TYPE_INTERN;
6800 attack_exec = ATTACK_EXEC_ON_GPU;
6801 opts_type = OPTS_TYPE_PT_GENERATE_BE
6802 | OPTS_TYPE_PT_ADD80
6803 | OPTS_TYPE_PT_ADDBITS15
6804 | OPTS_TYPE_ST_LOWER;
6805 kern_type = KERN_TYPE_SHA1_SLTPW;
6806 dgst_size = DGST_SIZE_4_5;
6807 parse_func = smf_parse_hash;
6808 sort_by_digest = sort_by_digest_4_5;
6809 opti_type = OPTI_TYPE_ZERO_BYTE
6810 | OPTI_TYPE_PRECOMPUTE_INIT
6811 | OPTI_TYPE_PRECOMPUTE_MERKLE
6812 | OPTI_TYPE_EARLY_SKIP
6813 | OPTI_TYPE_NOT_ITERATED
6814 | OPTI_TYPE_PREPENDED_SALT
6815 | OPTI_TYPE_RAW_HASH;
6816 dgst_pos0 = 3;
6817 dgst_pos1 = 4;
6818 dgst_pos2 = 2;
6819 dgst_pos3 = 1;
6820 break;
6821
6822 case 122: hash_type = HASH_TYPE_SHA1;
6823 salt_type = SALT_TYPE_EMBEDDED;
6824 attack_exec = ATTACK_EXEC_ON_GPU;
6825 opts_type = OPTS_TYPE_PT_GENERATE_BE
6826 | OPTS_TYPE_PT_ADD80
6827 | OPTS_TYPE_PT_ADDBITS15
6828 | OPTS_TYPE_ST_HEX;
6829 kern_type = KERN_TYPE_SHA1_SLTPW;
6830 dgst_size = DGST_SIZE_4_5;
6831 parse_func = osx1_parse_hash;
6832 sort_by_digest = sort_by_digest_4_5;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_PREPENDED_SALT
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 3;
6841 dgst_pos1 = 4;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 124: hash_type = HASH_TYPE_SHA1;
6847 salt_type = SALT_TYPE_EMBEDDED;
6848 attack_exec = ATTACK_EXEC_ON_GPU;
6849 opts_type = OPTS_TYPE_PT_GENERATE_BE
6850 | OPTS_TYPE_PT_ADD80
6851 | OPTS_TYPE_PT_ADDBITS15;
6852 kern_type = KERN_TYPE_SHA1_SLTPW;
6853 dgst_size = DGST_SIZE_4_5;
6854 parse_func = djangosha1_parse_hash;
6855 sort_by_digest = sort_by_digest_4_5;
6856 opti_type = OPTI_TYPE_ZERO_BYTE
6857 | OPTI_TYPE_PRECOMPUTE_INIT
6858 | OPTI_TYPE_PRECOMPUTE_MERKLE
6859 | OPTI_TYPE_EARLY_SKIP
6860 | OPTI_TYPE_NOT_ITERATED
6861 | OPTI_TYPE_PREPENDED_SALT
6862 | OPTI_TYPE_RAW_HASH;
6863 dgst_pos0 = 3;
6864 dgst_pos1 = 4;
6865 dgst_pos2 = 2;
6866 dgst_pos3 = 1;
6867 break;
6868
6869 case 130: hash_type = HASH_TYPE_SHA1;
6870 salt_type = SALT_TYPE_INTERN;
6871 attack_exec = ATTACK_EXEC_ON_GPU;
6872 opts_type = OPTS_TYPE_PT_GENERATE_BE
6873 | OPTS_TYPE_PT_UNICODE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1_PWUSLT;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_5;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_APPENDED_SALT
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 3;
6888 dgst_pos1 = 4;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 131: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_EMBEDDED;
6895 attack_exec = ATTACK_EXEC_ON_GPU;
6896 opts_type = OPTS_TYPE_PT_GENERATE_BE
6897 | OPTS_TYPE_PT_UNICODE
6898 | OPTS_TYPE_PT_UPPER
6899 | OPTS_TYPE_ST_ADD80
6900 | OPTS_TYPE_ST_ADDBITS15
6901 | OPTS_TYPE_ST_HEX;
6902 kern_type = KERN_TYPE_SHA1_PWUSLT;
6903 dgst_size = DGST_SIZE_4_5;
6904 parse_func = mssql2000_parse_hash;
6905 sort_by_digest = sort_by_digest_4_5;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_EARLY_SKIP
6910 | OPTI_TYPE_NOT_ITERATED
6911 | OPTI_TYPE_APPENDED_SALT
6912 | OPTI_TYPE_RAW_HASH;
6913 dgst_pos0 = 3;
6914 dgst_pos1 = 4;
6915 dgst_pos2 = 2;
6916 dgst_pos3 = 1;
6917 break;
6918
6919 case 132: hash_type = HASH_TYPE_SHA1;
6920 salt_type = SALT_TYPE_EMBEDDED;
6921 attack_exec = ATTACK_EXEC_ON_GPU;
6922 opts_type = OPTS_TYPE_PT_GENERATE_BE
6923 | OPTS_TYPE_PT_UNICODE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS15
6926 | OPTS_TYPE_ST_HEX;
6927 kern_type = KERN_TYPE_SHA1_PWUSLT;
6928 dgst_size = DGST_SIZE_4_5;
6929 parse_func = mssql2005_parse_hash;
6930 sort_by_digest = sort_by_digest_4_5;
6931 opti_type = OPTI_TYPE_ZERO_BYTE
6932 | OPTI_TYPE_PRECOMPUTE_INIT
6933 | OPTI_TYPE_PRECOMPUTE_MERKLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 3;
6939 dgst_pos1 = 4;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 133: hash_type = HASH_TYPE_SHA1;
6945 salt_type = SALT_TYPE_EMBEDDED;
6946 attack_exec = ATTACK_EXEC_ON_GPU;
6947 opts_type = OPTS_TYPE_PT_GENERATE_BE
6948 | OPTS_TYPE_PT_UNICODE
6949 | OPTS_TYPE_ST_ADD80
6950 | OPTS_TYPE_ST_ADDBITS15;
6951 kern_type = KERN_TYPE_SHA1_PWUSLT;
6952 dgst_size = DGST_SIZE_4_5;
6953 parse_func = peoplesoft_parse_hash;
6954 sort_by_digest = sort_by_digest_4_5;
6955 opti_type = OPTI_TYPE_ZERO_BYTE
6956 | OPTI_TYPE_PRECOMPUTE_INIT
6957 | OPTI_TYPE_PRECOMPUTE_MERKLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_APPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 3;
6963 dgst_pos1 = 4;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 140: hash_type = HASH_TYPE_SHA1;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_ON_GPU;
6971 opts_type = OPTS_TYPE_PT_GENERATE_BE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS15
6974 | OPTS_TYPE_PT_UNICODE;
6975 kern_type = KERN_TYPE_SHA1_SLTPWU;
6976 dgst_size = DGST_SIZE_4_5;
6977 parse_func = sha1s_parse_hash;
6978 sort_by_digest = sort_by_digest_4_5;
6979 opti_type = OPTI_TYPE_ZERO_BYTE
6980 | OPTI_TYPE_PRECOMPUTE_INIT
6981 | OPTI_TYPE_PRECOMPUTE_MERKLE
6982 | OPTI_TYPE_EARLY_SKIP
6983 | OPTI_TYPE_NOT_ITERATED
6984 | OPTI_TYPE_PREPENDED_SALT
6985 | OPTI_TYPE_RAW_HASH;
6986 dgst_pos0 = 3;
6987 dgst_pos1 = 4;
6988 dgst_pos2 = 2;
6989 dgst_pos3 = 1;
6990 break;
6991
6992 case 141: hash_type = HASH_TYPE_SHA1;
6993 salt_type = SALT_TYPE_EMBEDDED;
6994 attack_exec = ATTACK_EXEC_ON_GPU;
6995 opts_type = OPTS_TYPE_PT_GENERATE_BE
6996 | OPTS_TYPE_PT_ADD80
6997 | OPTS_TYPE_PT_ADDBITS15
6998 | OPTS_TYPE_PT_UNICODE
6999 | OPTS_TYPE_ST_BASE64;
7000 kern_type = KERN_TYPE_SHA1_SLTPWU;
7001 dgst_size = DGST_SIZE_4_5;
7002 parse_func = episerver_parse_hash;
7003 sort_by_digest = sort_by_digest_4_5;
7004 opti_type = OPTI_TYPE_ZERO_BYTE
7005 | OPTI_TYPE_PRECOMPUTE_INIT
7006 | OPTI_TYPE_PRECOMPUTE_MERKLE
7007 | OPTI_TYPE_EARLY_SKIP
7008 | OPTI_TYPE_NOT_ITERATED
7009 | OPTI_TYPE_PREPENDED_SALT
7010 | OPTI_TYPE_RAW_HASH;
7011 dgst_pos0 = 3;
7012 dgst_pos1 = 4;
7013 dgst_pos2 = 2;
7014 dgst_pos3 = 1;
7015 break;
7016
7017 case 150: hash_type = HASH_TYPE_SHA1;
7018 salt_type = SALT_TYPE_INTERN;
7019 attack_exec = ATTACK_EXEC_ON_GPU;
7020 opts_type = OPTS_TYPE_PT_GENERATE_BE
7021 | OPTS_TYPE_ST_ADD80
7022 | OPTS_TYPE_ST_ADDBITS15;
7023 kern_type = KERN_TYPE_HMACSHA1_PW;
7024 dgst_size = DGST_SIZE_4_5;
7025 parse_func = hmacsha1_parse_hash;
7026 sort_by_digest = sort_by_digest_4_5;
7027 opti_type = OPTI_TYPE_ZERO_BYTE
7028 | OPTI_TYPE_NOT_ITERATED;
7029 dgst_pos0 = 3;
7030 dgst_pos1 = 4;
7031 dgst_pos2 = 2;
7032 dgst_pos3 = 1;
7033 break;
7034
7035 case 160: hash_type = HASH_TYPE_SHA1;
7036 salt_type = SALT_TYPE_INTERN;
7037 attack_exec = ATTACK_EXEC_ON_GPU;
7038 opts_type = OPTS_TYPE_PT_GENERATE_BE
7039 | OPTS_TYPE_PT_ADD80
7040 | OPTS_TYPE_PT_ADDBITS15;
7041 kern_type = KERN_TYPE_HMACSHA1_SLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = hmacsha1_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_NOT_ITERATED;
7047 dgst_pos0 = 3;
7048 dgst_pos1 = 4;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 190: hash_type = HASH_TYPE_SHA1;
7054 salt_type = SALT_TYPE_NONE;
7055 attack_exec = ATTACK_EXEC_ON_GPU;
7056 opts_type = OPTS_TYPE_PT_GENERATE_BE
7057 | OPTS_TYPE_PT_ADD80
7058 | OPTS_TYPE_PT_ADDBITS15;
7059 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7060 dgst_size = DGST_SIZE_4_5;
7061 parse_func = sha1linkedin_parse_hash;
7062 sort_by_digest = sort_by_digest_4_5;
7063 opti_type = OPTI_TYPE_ZERO_BYTE
7064 | OPTI_TYPE_PRECOMPUTE_INIT
7065 | OPTI_TYPE_EARLY_SKIP
7066 | OPTI_TYPE_NOT_ITERATED
7067 | OPTI_TYPE_NOT_SALTED;
7068 dgst_pos0 = 0;
7069 dgst_pos1 = 4;
7070 dgst_pos2 = 3;
7071 dgst_pos3 = 2;
7072 break;
7073
7074 case 200: hash_type = HASH_TYPE_MYSQL;
7075 salt_type = SALT_TYPE_NONE;
7076 attack_exec = ATTACK_EXEC_ON_GPU;
7077 opts_type = 0;
7078 kern_type = KERN_TYPE_MYSQL;
7079 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7080 parse_func = mysql323_parse_hash;
7081 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7082 opti_type = OPTI_TYPE_ZERO_BYTE;
7083 dgst_pos0 = 0;
7084 dgst_pos1 = 1;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 3;
7087 break;
7088
7089 case 300: hash_type = HASH_TYPE_SHA1;
7090 salt_type = SALT_TYPE_NONE;
7091 attack_exec = ATTACK_EXEC_ON_GPU;
7092 opts_type = OPTS_TYPE_PT_GENERATE_BE
7093 | OPTS_TYPE_PT_ADD80
7094 | OPTS_TYPE_PT_ADDBITS15;
7095 kern_type = KERN_TYPE_MYSQL41;
7096 dgst_size = DGST_SIZE_4_5;
7097 parse_func = sha1_parse_hash;
7098 sort_by_digest = sort_by_digest_4_5;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_EARLY_SKIP
7103 | OPTI_TYPE_NOT_ITERATED
7104 | OPTI_TYPE_NOT_SALTED;
7105 dgst_pos0 = 3;
7106 dgst_pos1 = 4;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 400: hash_type = HASH_TYPE_MD5;
7112 salt_type = SALT_TYPE_EMBEDDED;
7113 attack_exec = ATTACK_EXEC_ON_CPU;
7114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7115 kern_type = KERN_TYPE_PHPASS;
7116 dgst_size = DGST_SIZE_4_4;
7117 parse_func = phpass_parse_hash;
7118 sort_by_digest = sort_by_digest_4_4;
7119 opti_type = OPTI_TYPE_ZERO_BYTE;
7120 dgst_pos0 = 0;
7121 dgst_pos1 = 1;
7122 dgst_pos2 = 2;
7123 dgst_pos3 = 3;
7124 break;
7125
7126 case 500: hash_type = HASH_TYPE_MD5;
7127 salt_type = SALT_TYPE_EMBEDDED;
7128 attack_exec = ATTACK_EXEC_ON_CPU;
7129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7130 kern_type = KERN_TYPE_MD5CRYPT;
7131 dgst_size = DGST_SIZE_4_4;
7132 parse_func = md5crypt_parse_hash;
7133 sort_by_digest = sort_by_digest_4_4;
7134 opti_type = OPTI_TYPE_ZERO_BYTE;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 1;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 3;
7139 break;
7140
7141 case 501: hash_type = HASH_TYPE_MD5;
7142 salt_type = SALT_TYPE_EMBEDDED;
7143 attack_exec = ATTACK_EXEC_ON_CPU;
7144 opts_type = OPTS_TYPE_PT_GENERATE_LE
7145 | OPTS_TYPE_HASH_COPY;
7146 kern_type = KERN_TYPE_MD5CRYPT;
7147 dgst_size = DGST_SIZE_4_4;
7148 parse_func = juniper_parse_hash;
7149 sort_by_digest = sort_by_digest_4_4;
7150 opti_type = OPTI_TYPE_ZERO_BYTE;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 1;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 3;
7155 break;
7156
7157 case 900: hash_type = HASH_TYPE_MD4;
7158 salt_type = SALT_TYPE_NONE;
7159 attack_exec = ATTACK_EXEC_ON_GPU;
7160 opts_type = OPTS_TYPE_PT_GENERATE_LE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS14;
7163 kern_type = KERN_TYPE_MD4;
7164 dgst_size = DGST_SIZE_4_4;
7165 parse_func = md4_parse_hash;
7166 sort_by_digest = sort_by_digest_4_4;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_MEET_IN_MIDDLE
7171 | OPTI_TYPE_EARLY_SKIP
7172 | OPTI_TYPE_NOT_ITERATED
7173 | OPTI_TYPE_NOT_SALTED
7174 | OPTI_TYPE_RAW_HASH;
7175 dgst_pos0 = 0;
7176 dgst_pos1 = 3;
7177 dgst_pos2 = 2;
7178 dgst_pos3 = 1;
7179 break;
7180
7181 case 1000: hash_type = HASH_TYPE_MD4;
7182 salt_type = SALT_TYPE_NONE;
7183 attack_exec = ATTACK_EXEC_ON_GPU;
7184 opts_type = OPTS_TYPE_PT_GENERATE_LE
7185 | OPTS_TYPE_PT_ADD80
7186 | OPTS_TYPE_PT_ADDBITS14
7187 | OPTS_TYPE_PT_UNICODE;
7188 kern_type = KERN_TYPE_MD4_PWU;
7189 dgst_size = DGST_SIZE_4_4;
7190 parse_func = md4_parse_hash;
7191 sort_by_digest = sort_by_digest_4_4;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_MEET_IN_MIDDLE
7196 | OPTI_TYPE_EARLY_SKIP
7197 | OPTI_TYPE_NOT_ITERATED
7198 | OPTI_TYPE_NOT_SALTED
7199 | OPTI_TYPE_RAW_HASH;
7200 dgst_pos0 = 0;
7201 dgst_pos1 = 3;
7202 dgst_pos2 = 2;
7203 dgst_pos3 = 1;
7204 break;
7205
7206 case 1100: hash_type = HASH_TYPE_MD4;
7207 salt_type = SALT_TYPE_INTERN;
7208 attack_exec = ATTACK_EXEC_ON_GPU;
7209 opts_type = OPTS_TYPE_PT_GENERATE_LE
7210 | OPTS_TYPE_PT_ADD80
7211 | OPTS_TYPE_PT_ADDBITS14
7212 | OPTS_TYPE_PT_UNICODE
7213 | OPTS_TYPE_ST_ADD80
7214 | OPTS_TYPE_ST_UNICODE
7215 | OPTS_TYPE_ST_LOWER;
7216 kern_type = KERN_TYPE_MD44_PWUSLT;
7217 dgst_size = DGST_SIZE_4_4;
7218 parse_func = dcc_parse_hash;
7219 sort_by_digest = sort_by_digest_4_4;
7220 opti_type = OPTI_TYPE_ZERO_BYTE
7221 | OPTI_TYPE_PRECOMPUTE_INIT
7222 | OPTI_TYPE_PRECOMPUTE_MERKLE
7223 | OPTI_TYPE_EARLY_SKIP
7224 | OPTI_TYPE_NOT_ITERATED;
7225 dgst_pos0 = 0;
7226 dgst_pos1 = 3;
7227 dgst_pos2 = 2;
7228 dgst_pos3 = 1;
7229 break;
7230
7231 case 1400: hash_type = HASH_TYPE_SHA256;
7232 salt_type = SALT_TYPE_NONE;
7233 attack_exec = ATTACK_EXEC_ON_GPU;
7234 opts_type = OPTS_TYPE_PT_GENERATE_BE
7235 | OPTS_TYPE_PT_ADD80
7236 | OPTS_TYPE_PT_ADDBITS15;
7237 kern_type = KERN_TYPE_SHA256;
7238 dgst_size = DGST_SIZE_4_8;
7239 parse_func = sha256_parse_hash;
7240 sort_by_digest = sort_by_digest_4_8;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_NOT_SALTED
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 7;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 6;
7252 break;
7253
7254 case 1410: hash_type = HASH_TYPE_SHA256;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_ON_GPU;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_ST_ADD80
7259 | OPTS_TYPE_ST_ADDBITS15;
7260 kern_type = KERN_TYPE_SHA256_PWSLT;
7261 dgst_size = DGST_SIZE_4_8;
7262 parse_func = sha256s_parse_hash;
7263 sort_by_digest = sort_by_digest_4_8;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_APPENDED_SALT
7270 | OPTI_TYPE_RAW_HASH;
7271 dgst_pos0 = 3;
7272 dgst_pos1 = 7;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 6;
7275 break;
7276
7277 case 1420: hash_type = HASH_TYPE_SHA256;
7278 salt_type = SALT_TYPE_INTERN;
7279 attack_exec = ATTACK_EXEC_ON_GPU;
7280 opts_type = OPTS_TYPE_PT_GENERATE_BE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS15;
7283 kern_type = KERN_TYPE_SHA256_SLTPW;
7284 dgst_size = DGST_SIZE_4_8;
7285 parse_func = sha256s_parse_hash;
7286 sort_by_digest = sort_by_digest_4_8;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_PREPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 3;
7295 dgst_pos1 = 7;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 6;
7298 break;
7299
7300 case 1421: hash_type = HASH_TYPE_SHA256;
7301 salt_type = SALT_TYPE_EMBEDDED;
7302 attack_exec = ATTACK_EXEC_ON_GPU;
7303 opts_type = OPTS_TYPE_PT_GENERATE_BE
7304 | OPTS_TYPE_PT_ADD80
7305 | OPTS_TYPE_PT_ADDBITS15;
7306 kern_type = KERN_TYPE_SHA256_SLTPW;
7307 dgst_size = DGST_SIZE_4_8;
7308 parse_func = hmailserver_parse_hash;
7309 sort_by_digest = sort_by_digest_4_8;
7310 opti_type = OPTI_TYPE_ZERO_BYTE
7311 | OPTI_TYPE_PRECOMPUTE_INIT
7312 | OPTI_TYPE_PRECOMPUTE_MERKLE
7313 | OPTI_TYPE_EARLY_SKIP
7314 | OPTI_TYPE_NOT_ITERATED
7315 | OPTI_TYPE_PREPENDED_SALT
7316 | OPTI_TYPE_RAW_HASH;
7317 dgst_pos0 = 3;
7318 dgst_pos1 = 7;
7319 dgst_pos2 = 2;
7320 dgst_pos3 = 6;
7321 break;
7322
7323 case 1430: hash_type = HASH_TYPE_SHA256;
7324 salt_type = SALT_TYPE_INTERN;
7325 attack_exec = ATTACK_EXEC_ON_GPU;
7326 opts_type = OPTS_TYPE_PT_GENERATE_BE
7327 | OPTS_TYPE_PT_UNICODE
7328 | OPTS_TYPE_ST_ADD80
7329 | OPTS_TYPE_ST_ADDBITS15;
7330 kern_type = KERN_TYPE_SHA256_PWUSLT;
7331 dgst_size = DGST_SIZE_4_8;
7332 parse_func = sha256s_parse_hash;
7333 sort_by_digest = sort_by_digest_4_8;
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 | OPTI_TYPE_APPENDED_SALT
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 7;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 6;
7345 break;
7346
7347 case 1440: hash_type = HASH_TYPE_SHA256;
7348 salt_type = SALT_TYPE_INTERN;
7349 attack_exec = ATTACK_EXEC_ON_GPU;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_PT_ADD80
7352 | OPTS_TYPE_PT_ADDBITS15
7353 | OPTS_TYPE_PT_UNICODE;
7354 kern_type = KERN_TYPE_SHA256_SLTPWU;
7355 dgst_size = DGST_SIZE_4_8;
7356 parse_func = sha256s_parse_hash;
7357 sort_by_digest = sort_by_digest_4_8;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_PREPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 7;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 6;
7369 break;
7370
7371 case 1441: hash_type = HASH_TYPE_SHA256;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_ON_GPU;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_ADD80
7376 | OPTS_TYPE_PT_ADDBITS15
7377 | OPTS_TYPE_PT_UNICODE
7378 | OPTS_TYPE_ST_BASE64;
7379 kern_type = KERN_TYPE_SHA256_SLTPWU;
7380 dgst_size = DGST_SIZE_4_8;
7381 parse_func = episerver4_parse_hash;
7382 sort_by_digest = sort_by_digest_4_8;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_PREPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 7;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 6;
7394 break;
7395
7396 case 1450: hash_type = HASH_TYPE_SHA256;
7397 salt_type = SALT_TYPE_INTERN;
7398 attack_exec = ATTACK_EXEC_ON_GPU;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_ST_ADD80;
7401 kern_type = KERN_TYPE_HMACSHA256_PW;
7402 dgst_size = DGST_SIZE_4_8;
7403 parse_func = hmacsha256_parse_hash;
7404 sort_by_digest = sort_by_digest_4_8;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_NOT_ITERATED;
7407 dgst_pos0 = 3;
7408 dgst_pos1 = 7;
7409 dgst_pos2 = 2;
7410 dgst_pos3 = 6;
7411 break;
7412
7413 case 1460: hash_type = HASH_TYPE_SHA256;
7414 salt_type = SALT_TYPE_INTERN;
7415 attack_exec = ATTACK_EXEC_ON_GPU;
7416 opts_type = OPTS_TYPE_PT_GENERATE_BE
7417 | OPTS_TYPE_PT_ADD80
7418 | OPTS_TYPE_PT_ADDBITS15;
7419 kern_type = KERN_TYPE_HMACSHA256_SLT;
7420 dgst_size = DGST_SIZE_4_8;
7421 parse_func = hmacsha256_parse_hash;
7422 sort_by_digest = sort_by_digest_4_8;
7423 opti_type = OPTI_TYPE_ZERO_BYTE
7424 | OPTI_TYPE_NOT_ITERATED;
7425 dgst_pos0 = 3;
7426 dgst_pos1 = 7;
7427 dgst_pos2 = 2;
7428 dgst_pos3 = 6;
7429 break;
7430
7431 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7432 salt_type = SALT_TYPE_EMBEDDED;
7433 attack_exec = ATTACK_EXEC_ON_GPU;
7434 opts_type = OPTS_TYPE_PT_GENERATE_LE
7435 | OPTS_TYPE_PT_BITSLICE;
7436 kern_type = KERN_TYPE_DESCRYPT;
7437 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7438 parse_func = descrypt_parse_hash;
7439 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7440 opti_type = OPTI_TYPE_ZERO_BYTE
7441 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7442 dgst_pos0 = 0;
7443 dgst_pos1 = 1;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 3;
7446 break;
7447
7448 case 1600: hash_type = HASH_TYPE_MD5;
7449 salt_type = SALT_TYPE_EMBEDDED;
7450 attack_exec = ATTACK_EXEC_ON_CPU;
7451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7452 kern_type = KERN_TYPE_APR1CRYPT;
7453 dgst_size = DGST_SIZE_4_4;
7454 parse_func = md5apr1_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4;
7456 opti_type = OPTI_TYPE_ZERO_BYTE;
7457 dgst_pos0 = 0;
7458 dgst_pos1 = 1;
7459 dgst_pos2 = 2;
7460 dgst_pos3 = 3;
7461 break;
7462
7463 case 1700: hash_type = HASH_TYPE_SHA512;
7464 salt_type = SALT_TYPE_NONE;
7465 attack_exec = ATTACK_EXEC_ON_GPU;
7466 opts_type = OPTS_TYPE_PT_GENERATE_BE
7467 | OPTS_TYPE_PT_ADD80
7468 | OPTS_TYPE_PT_ADDBITS15;
7469 kern_type = KERN_TYPE_SHA512;
7470 dgst_size = DGST_SIZE_8_8;
7471 parse_func = sha512_parse_hash;
7472 sort_by_digest = sort_by_digest_8_8;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_NOT_SALTED
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 14;
7481 dgst_pos1 = 15;
7482 dgst_pos2 = 6;
7483 dgst_pos3 = 7;
7484 break;
7485
7486 case 1710: hash_type = HASH_TYPE_SHA512;
7487 salt_type = SALT_TYPE_INTERN;
7488 attack_exec = ATTACK_EXEC_ON_GPU;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_ST_ADD80
7491 | OPTS_TYPE_ST_ADDBITS15;
7492 kern_type = KERN_TYPE_SHA512_PWSLT;
7493 dgst_size = DGST_SIZE_8_8;
7494 parse_func = sha512s_parse_hash;
7495 sort_by_digest = sort_by_digest_8_8;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_APPENDED_SALT
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 14;
7504 dgst_pos1 = 15;
7505 dgst_pos2 = 6;
7506 dgst_pos3 = 7;
7507 break;
7508
7509 case 1711: hash_type = HASH_TYPE_SHA512;
7510 salt_type = SALT_TYPE_EMBEDDED;
7511 attack_exec = ATTACK_EXEC_ON_GPU;
7512 opts_type = OPTS_TYPE_PT_GENERATE_BE
7513 | OPTS_TYPE_ST_ADD80
7514 | OPTS_TYPE_ST_ADDBITS15;
7515 kern_type = KERN_TYPE_SHA512_PWSLT;
7516 dgst_size = DGST_SIZE_8_8;
7517 parse_func = sha512b64s_parse_hash;
7518 sort_by_digest = sort_by_digest_8_8;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_EARLY_SKIP
7523 | OPTI_TYPE_NOT_ITERATED
7524 | OPTI_TYPE_APPENDED_SALT
7525 | OPTI_TYPE_RAW_HASH;
7526 dgst_pos0 = 14;
7527 dgst_pos1 = 15;
7528 dgst_pos2 = 6;
7529 dgst_pos3 = 7;
7530 break;
7531
7532 case 1720: hash_type = HASH_TYPE_SHA512;
7533 salt_type = SALT_TYPE_INTERN;
7534 attack_exec = ATTACK_EXEC_ON_GPU;
7535 opts_type = OPTS_TYPE_PT_GENERATE_BE
7536 | OPTS_TYPE_PT_ADD80
7537 | OPTS_TYPE_PT_ADDBITS15;
7538 kern_type = KERN_TYPE_SHA512_SLTPW;
7539 dgst_size = DGST_SIZE_8_8;
7540 parse_func = sha512s_parse_hash;
7541 sort_by_digest = sort_by_digest_8_8;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_PRECOMPUTE_INIT
7544 | OPTI_TYPE_PRECOMPUTE_MERKLE
7545 | OPTI_TYPE_EARLY_SKIP
7546 | OPTI_TYPE_NOT_ITERATED
7547 | OPTI_TYPE_PREPENDED_SALT
7548 | OPTI_TYPE_RAW_HASH;
7549 dgst_pos0 = 14;
7550 dgst_pos1 = 15;
7551 dgst_pos2 = 6;
7552 dgst_pos3 = 7;
7553 break;
7554
7555 case 1722: hash_type = HASH_TYPE_SHA512;
7556 salt_type = SALT_TYPE_EMBEDDED;
7557 attack_exec = ATTACK_EXEC_ON_GPU;
7558 opts_type = OPTS_TYPE_PT_GENERATE_BE
7559 | OPTS_TYPE_PT_ADD80
7560 | OPTS_TYPE_PT_ADDBITS15
7561 | OPTS_TYPE_ST_HEX;
7562 kern_type = KERN_TYPE_SHA512_SLTPW;
7563 dgst_size = DGST_SIZE_8_8;
7564 parse_func = osx512_parse_hash;
7565 sort_by_digest = sort_by_digest_8_8;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_PRECOMPUTE_INIT
7568 | OPTI_TYPE_PRECOMPUTE_MERKLE
7569 | OPTI_TYPE_EARLY_SKIP
7570 | OPTI_TYPE_NOT_ITERATED
7571 | OPTI_TYPE_PREPENDED_SALT
7572 | OPTI_TYPE_RAW_HASH;
7573 dgst_pos0 = 14;
7574 dgst_pos1 = 15;
7575 dgst_pos2 = 6;
7576 dgst_pos3 = 7;
7577 break;
7578
7579 case 1730: hash_type = HASH_TYPE_SHA512;
7580 salt_type = SALT_TYPE_INTERN;
7581 attack_exec = ATTACK_EXEC_ON_GPU;
7582 opts_type = OPTS_TYPE_PT_GENERATE_BE
7583 | OPTS_TYPE_PT_UNICODE
7584 | OPTS_TYPE_ST_ADD80
7585 | OPTS_TYPE_ST_ADDBITS15;
7586 kern_type = KERN_TYPE_SHA512_PWSLTU;
7587 dgst_size = DGST_SIZE_8_8;
7588 parse_func = sha512s_parse_hash;
7589 sort_by_digest = sort_by_digest_8_8;
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_INIT
7592 | OPTI_TYPE_PRECOMPUTE_MERKLE
7593 | OPTI_TYPE_EARLY_SKIP
7594 | OPTI_TYPE_NOT_ITERATED
7595 | OPTI_TYPE_APPENDED_SALT
7596 | OPTI_TYPE_RAW_HASH;
7597 dgst_pos0 = 14;
7598 dgst_pos1 = 15;
7599 dgst_pos2 = 6;
7600 dgst_pos3 = 7;
7601 break;
7602
7603 case 1731: hash_type = HASH_TYPE_SHA512;
7604 salt_type = SALT_TYPE_EMBEDDED;
7605 attack_exec = ATTACK_EXEC_ON_GPU;
7606 opts_type = OPTS_TYPE_PT_GENERATE_BE
7607 | OPTS_TYPE_PT_UNICODE
7608 | OPTS_TYPE_ST_ADD80
7609 | OPTS_TYPE_ST_ADDBITS15
7610 | OPTS_TYPE_ST_HEX;
7611 kern_type = KERN_TYPE_SHA512_PWSLTU;
7612 dgst_size = DGST_SIZE_8_8;
7613 parse_func = mssql2012_parse_hash;
7614 sort_by_digest = sort_by_digest_8_8;
7615 opti_type = OPTI_TYPE_ZERO_BYTE
7616 | OPTI_TYPE_PRECOMPUTE_INIT
7617 | OPTI_TYPE_PRECOMPUTE_MERKLE
7618 | OPTI_TYPE_EARLY_SKIP
7619 | OPTI_TYPE_NOT_ITERATED
7620 | OPTI_TYPE_APPENDED_SALT
7621 | OPTI_TYPE_RAW_HASH;
7622 dgst_pos0 = 14;
7623 dgst_pos1 = 15;
7624 dgst_pos2 = 6;
7625 dgst_pos3 = 7;
7626 break;
7627
7628 case 1740: hash_type = HASH_TYPE_SHA512;
7629 salt_type = SALT_TYPE_INTERN;
7630 attack_exec = ATTACK_EXEC_ON_GPU;
7631 opts_type = OPTS_TYPE_PT_GENERATE_BE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS15
7634 | OPTS_TYPE_PT_UNICODE;
7635 kern_type = KERN_TYPE_SHA512_SLTPWU;
7636 dgst_size = DGST_SIZE_8_8;
7637 parse_func = sha512s_parse_hash;
7638 sort_by_digest = sort_by_digest_8_8;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_EARLY_SKIP
7643 | OPTI_TYPE_NOT_ITERATED
7644 | OPTI_TYPE_PREPENDED_SALT
7645 | OPTI_TYPE_RAW_HASH;
7646 dgst_pos0 = 14;
7647 dgst_pos1 = 15;
7648 dgst_pos2 = 6;
7649 dgst_pos3 = 7;
7650 break;
7651
7652 case 1750: hash_type = HASH_TYPE_SHA512;
7653 salt_type = SALT_TYPE_INTERN;
7654 attack_exec = ATTACK_EXEC_ON_GPU;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_ST_ADD80;
7657 kern_type = KERN_TYPE_HMACSHA512_PW;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = hmacsha512_parse_hash;
7660 sort_by_digest = sort_by_digest_8_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_NOT_ITERATED;
7663 dgst_pos0 = 14;
7664 dgst_pos1 = 15;
7665 dgst_pos2 = 6;
7666 dgst_pos3 = 7;
7667 break;
7668
7669 case 1760: hash_type = HASH_TYPE_SHA512;
7670 salt_type = SALT_TYPE_INTERN;
7671 attack_exec = ATTACK_EXEC_ON_GPU;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15;
7675 kern_type = KERN_TYPE_HMACSHA512_SLT;
7676 dgst_size = DGST_SIZE_8_8;
7677 parse_func = hmacsha512_parse_hash;
7678 sort_by_digest = sort_by_digest_8_8;
7679 opti_type = OPTI_TYPE_ZERO_BYTE
7680 | OPTI_TYPE_NOT_ITERATED;
7681 dgst_pos0 = 14;
7682 dgst_pos1 = 15;
7683 dgst_pos2 = 6;
7684 dgst_pos3 = 7;
7685 break;
7686
7687 case 1800: hash_type = HASH_TYPE_SHA512;
7688 salt_type = SALT_TYPE_EMBEDDED;
7689 attack_exec = ATTACK_EXEC_ON_CPU;
7690 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7691 kern_type = KERN_TYPE_SHA512CRYPT;
7692 dgst_size = DGST_SIZE_8_8;
7693 parse_func = sha512crypt_parse_hash;
7694 sort_by_digest = sort_by_digest_8_8;
7695 opti_type = OPTI_TYPE_ZERO_BYTE;
7696 dgst_pos0 = 0;
7697 dgst_pos1 = 1;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 3;
7700 break;
7701
7702 case 2100: hash_type = HASH_TYPE_DCC2;
7703 salt_type = SALT_TYPE_EMBEDDED;
7704 attack_exec = ATTACK_EXEC_ON_CPU;
7705 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_ST_LOWER
7707 | OPTS_TYPE_ST_UNICODE;
7708 kern_type = KERN_TYPE_DCC2;
7709 dgst_size = DGST_SIZE_4_4;
7710 parse_func = dcc2_parse_hash;
7711 sort_by_digest = sort_by_digest_4_4;
7712 opti_type = OPTI_TYPE_ZERO_BYTE;
7713 dgst_pos0 = 0;
7714 dgst_pos1 = 1;
7715 dgst_pos2 = 2;
7716 dgst_pos3 = 3;
7717 break;
7718
7719 case 2400: hash_type = HASH_TYPE_MD5;
7720 salt_type = SALT_TYPE_NONE;
7721 attack_exec = ATTACK_EXEC_ON_GPU;
7722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7723 kern_type = KERN_TYPE_MD5PIX;
7724 dgst_size = DGST_SIZE_4_4;
7725 parse_func = md5pix_parse_hash;
7726 sort_by_digest = sort_by_digest_4_4;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_NOT_SALTED;
7733 dgst_pos0 = 0;
7734 dgst_pos1 = 3;
7735 dgst_pos2 = 2;
7736 dgst_pos3 = 1;
7737 break;
7738
7739 case 2410: hash_type = HASH_TYPE_MD5;
7740 salt_type = SALT_TYPE_INTERN;
7741 attack_exec = ATTACK_EXEC_ON_GPU;
7742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7743 kern_type = KERN_TYPE_MD5ASA;
7744 dgst_size = DGST_SIZE_4_4;
7745 parse_func = md5asa_parse_hash;
7746 sort_by_digest = sort_by_digest_4_4;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_PRECOMPUTE_INIT
7749 | OPTI_TYPE_PRECOMPUTE_MERKLE
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED;
7752 dgst_pos0 = 0;
7753 dgst_pos1 = 3;
7754 dgst_pos2 = 2;
7755 dgst_pos3 = 1;
7756 break;
7757
7758 case 2500: hash_type = HASH_TYPE_WPA;
7759 salt_type = SALT_TYPE_EMBEDDED;
7760 attack_exec = ATTACK_EXEC_ON_CPU;
7761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7762 kern_type = KERN_TYPE_WPA;
7763 dgst_size = DGST_SIZE_4_4;
7764 parse_func = wpa_parse_hash;
7765 sort_by_digest = sort_by_digest_4_4;
7766 opti_type = OPTI_TYPE_ZERO_BYTE;
7767 dgst_pos0 = 0;
7768 dgst_pos1 = 1;
7769 dgst_pos2 = 2;
7770 dgst_pos3 = 3;
7771 break;
7772
7773 case 2600: hash_type = HASH_TYPE_MD5;
7774 salt_type = SALT_TYPE_VIRTUAL;
7775 attack_exec = ATTACK_EXEC_ON_GPU;
7776 opts_type = OPTS_TYPE_PT_GENERATE_LE
7777 | OPTS_TYPE_PT_ADD80
7778 | OPTS_TYPE_PT_ADDBITS14
7779 | OPTS_TYPE_ST_ADD80;
7780 kern_type = KERN_TYPE_MD55_PWSLT1;
7781 dgst_size = DGST_SIZE_4_4;
7782 parse_func = md5md5_parse_hash;
7783 sort_by_digest = sort_by_digest_4_4;
7784 opti_type = OPTI_TYPE_ZERO_BYTE
7785 | OPTI_TYPE_PRECOMPUTE_INIT
7786 | OPTI_TYPE_PRECOMPUTE_MERKLE
7787 | OPTI_TYPE_EARLY_SKIP;
7788 dgst_pos0 = 0;
7789 dgst_pos1 = 3;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 1;
7792 break;
7793
7794 case 2611: hash_type = HASH_TYPE_MD5;
7795 salt_type = SALT_TYPE_INTERN;
7796 attack_exec = ATTACK_EXEC_ON_GPU;
7797 opts_type = OPTS_TYPE_PT_GENERATE_LE
7798 | OPTS_TYPE_PT_ADD80
7799 | OPTS_TYPE_PT_ADDBITS14
7800 | OPTS_TYPE_ST_ADD80;
7801 kern_type = KERN_TYPE_MD55_PWSLT1;
7802 dgst_size = DGST_SIZE_4_4;
7803 parse_func = vb3_parse_hash;
7804 sort_by_digest = sort_by_digest_4_4;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_PRECOMPUTE_INIT
7807 | OPTI_TYPE_PRECOMPUTE_MERKLE
7808 | OPTI_TYPE_EARLY_SKIP;
7809 dgst_pos0 = 0;
7810 dgst_pos1 = 3;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 1;
7813 break;
7814
7815 case 2612: hash_type = HASH_TYPE_MD5;
7816 salt_type = SALT_TYPE_EMBEDDED;
7817 attack_exec = ATTACK_EXEC_ON_GPU;
7818 opts_type = OPTS_TYPE_PT_GENERATE_LE
7819 | OPTS_TYPE_PT_ADD80
7820 | OPTS_TYPE_PT_ADDBITS14
7821 | OPTS_TYPE_ST_ADD80
7822 | OPTS_TYPE_ST_HEX;
7823 kern_type = KERN_TYPE_MD55_PWSLT1;
7824 dgst_size = DGST_SIZE_4_4;
7825 parse_func = phps_parse_hash;
7826 sort_by_digest = sort_by_digest_4_4;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP;
7831 dgst_pos0 = 0;
7832 dgst_pos1 = 3;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 1;
7835 break;
7836
7837 case 2711: hash_type = HASH_TYPE_MD5;
7838 salt_type = SALT_TYPE_INTERN;
7839 attack_exec = ATTACK_EXEC_ON_GPU;
7840 opts_type = OPTS_TYPE_PT_GENERATE_LE
7841 | OPTS_TYPE_PT_ADD80
7842 | OPTS_TYPE_PT_ADDBITS14
7843 | OPTS_TYPE_ST_ADD80;
7844 kern_type = KERN_TYPE_MD55_PWSLT2;
7845 dgst_size = DGST_SIZE_4_4;
7846 parse_func = vb30_parse_hash;
7847 sort_by_digest = sort_by_digest_4_4;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_EARLY_SKIP;
7851 dgst_pos0 = 0;
7852 dgst_pos1 = 3;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 1;
7855 break;
7856
7857 case 2811: hash_type = HASH_TYPE_MD5;
7858 salt_type = SALT_TYPE_INTERN;
7859 attack_exec = ATTACK_EXEC_ON_GPU;
7860 opts_type = OPTS_TYPE_PT_GENERATE_LE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS14;
7863 kern_type = KERN_TYPE_MD55_SLTPW;
7864 dgst_size = DGST_SIZE_4_4;
7865 parse_func = ipb2_parse_hash;
7866 sort_by_digest = sort_by_digest_4_4;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_EARLY_SKIP;
7870 dgst_pos0 = 0;
7871 dgst_pos1 = 3;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 1;
7874 break;
7875
7876 case 3000: hash_type = HASH_TYPE_LM;
7877 salt_type = SALT_TYPE_NONE;
7878 attack_exec = ATTACK_EXEC_ON_GPU;
7879 opts_type = OPTS_TYPE_PT_GENERATE_LE
7880 | OPTS_TYPE_PT_UPPER
7881 | OPTS_TYPE_PT_BITSLICE;
7882 kern_type = KERN_TYPE_LM;
7883 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7884 parse_func = lm_parse_hash;
7885 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7888 dgst_pos0 = 0;
7889 dgst_pos1 = 1;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 3;
7892 break;
7893
7894 case 3100: hash_type = HASH_TYPE_ORACLEH;
7895 salt_type = SALT_TYPE_INTERN;
7896 attack_exec = ATTACK_EXEC_ON_GPU;
7897 opts_type = OPTS_TYPE_PT_GENERATE_LE
7898 | OPTS_TYPE_PT_UPPER
7899 | OPTS_TYPE_ST_UPPER;
7900 kern_type = KERN_TYPE_ORACLEH;
7901 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7902 parse_func = oracleh_parse_hash;
7903 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7904 opti_type = OPTI_TYPE_ZERO_BYTE;
7905 dgst_pos0 = 0;
7906 dgst_pos1 = 1;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 3;
7909 break;
7910
7911 case 3200: hash_type = HASH_TYPE_BCRYPT;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_ON_CPU;
7914 opts_type = OPTS_TYPE_PT_GENERATE_LE
7915 | OPTS_TYPE_ST_GENERATE_LE;
7916 kern_type = KERN_TYPE_BCRYPT;
7917 dgst_size = DGST_SIZE_4_6;
7918 parse_func = bcrypt_parse_hash;
7919 sort_by_digest = sort_by_digest_4_6;
7920 opti_type = OPTI_TYPE_ZERO_BYTE;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 1;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 3;
7925 break;
7926
7927 case 3710: hash_type = HASH_TYPE_MD5;
7928 salt_type = SALT_TYPE_INTERN;
7929 attack_exec = ATTACK_EXEC_ON_GPU;
7930 opts_type = OPTS_TYPE_PT_GENERATE_LE
7931 | OPTS_TYPE_PT_ADD80
7932 | OPTS_TYPE_PT_ADDBITS14;
7933 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7934 dgst_size = DGST_SIZE_4_4;
7935 parse_func = md5s_parse_hash;
7936 sort_by_digest = sort_by_digest_4_4;
7937 opti_type = OPTI_TYPE_ZERO_BYTE
7938 | OPTI_TYPE_PRECOMPUTE_INIT
7939 | OPTI_TYPE_PRECOMPUTE_MERKLE
7940 | OPTI_TYPE_EARLY_SKIP;
7941 dgst_pos0 = 0;
7942 dgst_pos1 = 3;
7943 dgst_pos2 = 2;
7944 dgst_pos3 = 1;
7945 break;
7946
7947 case 3711: hash_type = HASH_TYPE_MD5;
7948 salt_type = SALT_TYPE_EMBEDDED;
7949 attack_exec = ATTACK_EXEC_ON_GPU;
7950 opts_type = OPTS_TYPE_PT_GENERATE_LE
7951 | OPTS_TYPE_PT_ADD80
7952 | OPTS_TYPE_PT_ADDBITS14;
7953 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7954 dgst_size = DGST_SIZE_4_4;
7955 parse_func = mediawiki_b_parse_hash;
7956 sort_by_digest = sort_by_digest_4_4;
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_INIT
7959 | OPTI_TYPE_PRECOMPUTE_MERKLE
7960 | OPTI_TYPE_EARLY_SKIP;
7961 dgst_pos0 = 0;
7962 dgst_pos1 = 3;
7963 dgst_pos2 = 2;
7964 dgst_pos3 = 1;
7965 break;
7966
7967 case 3800: hash_type = HASH_TYPE_MD5;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_ON_GPU;
7970 opts_type = OPTS_TYPE_PT_GENERATE_LE
7971 | OPTS_TYPE_ST_ADDBITS14;
7972 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
7973 dgst_size = DGST_SIZE_4_4;
7974 parse_func = md5s_parse_hash;
7975 sort_by_digest = sort_by_digest_4_4;
7976 opti_type = OPTI_TYPE_ZERO_BYTE
7977 | OPTI_TYPE_PRECOMPUTE_INIT
7978 | OPTI_TYPE_PRECOMPUTE_MERKLE
7979 | OPTI_TYPE_EARLY_SKIP
7980 | OPTI_TYPE_NOT_ITERATED
7981 | OPTI_TYPE_RAW_HASH;
7982 dgst_pos0 = 0;
7983 dgst_pos1 = 3;
7984 dgst_pos2 = 2;
7985 dgst_pos3 = 1;
7986 break;
7987
7988 case 4300: hash_type = HASH_TYPE_MD5;
7989 salt_type = SALT_TYPE_VIRTUAL;
7990 attack_exec = ATTACK_EXEC_ON_GPU;
7991 opts_type = OPTS_TYPE_PT_GENERATE_LE
7992 | OPTS_TYPE_PT_ADD80
7993 | OPTS_TYPE_PT_ADDBITS14
7994 | OPTS_TYPE_ST_ADD80;
7995 kern_type = KERN_TYPE_MD5U5_PWSLT1;
7996 dgst_size = DGST_SIZE_4_4;
7997 parse_func = md5md5_parse_hash;
7998 sort_by_digest = sort_by_digest_4_4;
7999 opti_type = OPTI_TYPE_ZERO_BYTE
8000 | OPTI_TYPE_PRECOMPUTE_INIT
8001 | OPTI_TYPE_PRECOMPUTE_MERKLE
8002 | OPTI_TYPE_EARLY_SKIP;
8003 dgst_pos0 = 0;
8004 dgst_pos1 = 3;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 1;
8007 break;
8008
8009
8010 case 4400: hash_type = HASH_TYPE_MD5;
8011 salt_type = SALT_TYPE_NONE;
8012 attack_exec = ATTACK_EXEC_ON_GPU;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_PT_ADD80
8015 | OPTS_TYPE_PT_ADDBITS15;
8016 kern_type = KERN_TYPE_MD5_SHA1;
8017 dgst_size = DGST_SIZE_4_4;
8018 parse_func = md5_parse_hash;
8019 sort_by_digest = sort_by_digest_4_4;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_NOT_SALTED
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 0;
8028 dgst_pos1 = 3;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 1;
8031 break;
8032
8033 case 4500: hash_type = HASH_TYPE_SHA1;
8034 salt_type = SALT_TYPE_NONE;
8035 attack_exec = ATTACK_EXEC_ON_GPU;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS15;
8039 kern_type = KERN_TYPE_SHA11;
8040 dgst_size = DGST_SIZE_4_5;
8041 parse_func = sha1_parse_hash;
8042 sort_by_digest = sort_by_digest_4_5;
8043 opti_type = OPTI_TYPE_ZERO_BYTE
8044 | OPTI_TYPE_PRECOMPUTE_INIT
8045 | OPTI_TYPE_PRECOMPUTE_MERKLE
8046 | OPTI_TYPE_EARLY_SKIP
8047 | OPTI_TYPE_NOT_SALTED;
8048 dgst_pos0 = 3;
8049 dgst_pos1 = 4;
8050 dgst_pos2 = 2;
8051 dgst_pos3 = 1;
8052 break;
8053
8054 case 4700: hash_type = HASH_TYPE_SHA1;
8055 salt_type = SALT_TYPE_NONE;
8056 attack_exec = ATTACK_EXEC_ON_GPU;
8057 opts_type = OPTS_TYPE_PT_GENERATE_LE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS14;
8060 kern_type = KERN_TYPE_SHA1_MD5;
8061 dgst_size = DGST_SIZE_4_5;
8062 parse_func = sha1_parse_hash;
8063 sort_by_digest = sort_by_digest_4_5;
8064 opti_type = OPTI_TYPE_ZERO_BYTE
8065 | OPTI_TYPE_PRECOMPUTE_INIT
8066 | OPTI_TYPE_PRECOMPUTE_MERKLE
8067 | OPTI_TYPE_EARLY_SKIP
8068 | OPTI_TYPE_NOT_ITERATED
8069 | OPTI_TYPE_NOT_SALTED
8070 | OPTI_TYPE_RAW_HASH;
8071 dgst_pos0 = 3;
8072 dgst_pos1 = 4;
8073 dgst_pos2 = 2;
8074 dgst_pos3 = 1;
8075 break;
8076
8077 case 4800: hash_type = HASH_TYPE_MD5;
8078 salt_type = SALT_TYPE_EMBEDDED;
8079 attack_exec = ATTACK_EXEC_ON_GPU;
8080 opts_type = OPTS_TYPE_PT_GENERATE_LE
8081 | OPTS_TYPE_PT_ADDBITS14;
8082 kern_type = KERN_TYPE_MD5_CHAP;
8083 dgst_size = DGST_SIZE_4_4;
8084 parse_func = chap_parse_hash;
8085 sort_by_digest = sort_by_digest_4_4;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_PRECOMPUTE_INIT
8088 | OPTI_TYPE_PRECOMPUTE_MERKLE
8089 | OPTI_TYPE_MEET_IN_MIDDLE
8090 | OPTI_TYPE_EARLY_SKIP
8091 | OPTI_TYPE_NOT_ITERATED
8092 | OPTI_TYPE_RAW_HASH;
8093 dgst_pos0 = 0;
8094 dgst_pos1 = 3;
8095 dgst_pos2 = 2;
8096 dgst_pos3 = 1;
8097 break;
8098
8099 case 4900: hash_type = HASH_TYPE_SHA1;
8100 salt_type = SALT_TYPE_INTERN;
8101 attack_exec = ATTACK_EXEC_ON_GPU;
8102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8103 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8104 dgst_size = DGST_SIZE_4_5;
8105 parse_func = sha1s_parse_hash;
8106 sort_by_digest = sort_by_digest_4_5;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_EARLY_SKIP;
8111 dgst_pos0 = 3;
8112 dgst_pos1 = 4;
8113 dgst_pos2 = 2;
8114 dgst_pos3 = 1;
8115 break;
8116
8117 case 5000: hash_type = HASH_TYPE_KECCAK;
8118 salt_type = SALT_TYPE_EMBEDDED;
8119 attack_exec = ATTACK_EXEC_ON_GPU;
8120 opts_type = OPTS_TYPE_PT_GENERATE_LE
8121 | OPTS_TYPE_PT_ADD01;
8122 kern_type = KERN_TYPE_KECCAK;
8123 dgst_size = DGST_SIZE_8_25;
8124 parse_func = keccak_parse_hash;
8125 sort_by_digest = sort_by_digest_8_25;
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_RAW_HASH;
8128 dgst_pos0 = 2;
8129 dgst_pos1 = 3;
8130 dgst_pos2 = 4;
8131 dgst_pos3 = 5;
8132 break;
8133
8134 case 5100: hash_type = HASH_TYPE_MD5H;
8135 salt_type = SALT_TYPE_NONE;
8136 attack_exec = ATTACK_EXEC_ON_GPU;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE
8138 | OPTS_TYPE_PT_ADD80
8139 | OPTS_TYPE_PT_ADDBITS14;
8140 kern_type = KERN_TYPE_MD5H;
8141 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8142 parse_func = md5half_parse_hash;
8143 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8144 opti_type = OPTI_TYPE_ZERO_BYTE
8145 | OPTI_TYPE_RAW_HASH;
8146 dgst_pos0 = 0;
8147 dgst_pos1 = 1;
8148 dgst_pos2 = 2;
8149 dgst_pos3 = 3;
8150 break;
8151
8152 case 5200: hash_type = HASH_TYPE_SHA256;
8153 salt_type = SALT_TYPE_EMBEDDED;
8154 attack_exec = ATTACK_EXEC_ON_CPU;
8155 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8156 kern_type = KERN_TYPE_PSAFE3;
8157 dgst_size = DGST_SIZE_4_8;
8158 parse_func = psafe3_parse_hash;
8159 sort_by_digest = sort_by_digest_4_8;
8160 opti_type = OPTI_TYPE_ZERO_BYTE;
8161 dgst_pos0 = 0;
8162 dgst_pos1 = 1;
8163 dgst_pos2 = 2;
8164 dgst_pos3 = 3;
8165 break;
8166
8167 case 5300: hash_type = HASH_TYPE_MD5;
8168 salt_type = SALT_TYPE_EMBEDDED;
8169 attack_exec = ATTACK_EXEC_ON_GPU;
8170 opts_type = OPTS_TYPE_PT_GENERATE_LE
8171 | OPTS_TYPE_ST_ADD80;
8172 kern_type = KERN_TYPE_IKEPSK_MD5;
8173 dgst_size = DGST_SIZE_4_4;
8174 parse_func = ikepsk_md5_parse_hash;
8175 sort_by_digest = sort_by_digest_4_4;
8176 opti_type = OPTI_TYPE_ZERO_BYTE;
8177 dgst_pos0 = 0;
8178 dgst_pos1 = 3;
8179 dgst_pos2 = 2;
8180 dgst_pos3 = 1;
8181 break;
8182
8183 case 5400: hash_type = HASH_TYPE_SHA1;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_ON_GPU;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_ST_ADD80;
8188 kern_type = KERN_TYPE_IKEPSK_SHA1;
8189 dgst_size = DGST_SIZE_4_5;
8190 parse_func = ikepsk_sha1_parse_hash;
8191 sort_by_digest = sort_by_digest_4_5;
8192 opti_type = OPTI_TYPE_ZERO_BYTE;
8193 dgst_pos0 = 3;
8194 dgst_pos1 = 4;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 1;
8197 break;
8198
8199 case 5500: hash_type = HASH_TYPE_NETNTLM;
8200 salt_type = SALT_TYPE_EMBEDDED;
8201 attack_exec = ATTACK_EXEC_ON_GPU;
8202 opts_type = OPTS_TYPE_PT_GENERATE_LE
8203 | OPTS_TYPE_PT_ADD80
8204 | OPTS_TYPE_PT_ADDBITS14
8205 | OPTS_TYPE_PT_UNICODE
8206 | OPTS_TYPE_ST_HEX;
8207 kern_type = KERN_TYPE_NETNTLMv1;
8208 dgst_size = DGST_SIZE_4_4;
8209 parse_func = netntlmv1_parse_hash;
8210 sort_by_digest = sort_by_digest_4_4;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8213 dgst_pos0 = 0;
8214 dgst_pos1 = 1;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 3;
8217 break;
8218
8219 case 5600: hash_type = HASH_TYPE_MD5;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_ON_GPU;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE
8223 | OPTS_TYPE_PT_ADD80
8224 | OPTS_TYPE_PT_ADDBITS14
8225 | OPTS_TYPE_PT_UNICODE;
8226 kern_type = KERN_TYPE_NETNTLMv2;
8227 dgst_size = DGST_SIZE_4_4;
8228 parse_func = netntlmv2_parse_hash;
8229 sort_by_digest = sort_by_digest_4_4;
8230 opti_type = OPTI_TYPE_ZERO_BYTE;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 3;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 1;
8235 break;
8236
8237 case 5700: hash_type = HASH_TYPE_SHA256;
8238 salt_type = SALT_TYPE_NONE;
8239 attack_exec = ATTACK_EXEC_ON_GPU;
8240 opts_type = OPTS_TYPE_PT_GENERATE_BE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS15;
8243 kern_type = KERN_TYPE_SHA256;
8244 dgst_size = DGST_SIZE_4_8;
8245 parse_func = cisco4_parse_hash;
8246 sort_by_digest = sort_by_digest_4_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_NOT_SALTED
8253 | OPTI_TYPE_RAW_HASH;
8254 dgst_pos0 = 3;
8255 dgst_pos1 = 7;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 6;
8258 break;
8259
8260 case 5800: hash_type = HASH_TYPE_SHA1;
8261 salt_type = SALT_TYPE_INTERN;
8262 attack_exec = ATTACK_EXEC_ON_CPU;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8264 | OPTS_TYPE_ST_ADD80;
8265 kern_type = KERN_TYPE_ANDROIDPIN;
8266 dgst_size = DGST_SIZE_4_5;
8267 parse_func = androidpin_parse_hash;
8268 sort_by_digest = sort_by_digest_4_5;
8269 opti_type = OPTI_TYPE_ZERO_BYTE;
8270 dgst_pos0 = 0;
8271 dgst_pos1 = 1;
8272 dgst_pos2 = 2;
8273 dgst_pos3 = 3;
8274 break;
8275
8276 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8277 salt_type = SALT_TYPE_NONE;
8278 attack_exec = ATTACK_EXEC_ON_GPU;
8279 opts_type = OPTS_TYPE_PT_GENERATE_LE
8280 | OPTS_TYPE_PT_ADD80;
8281 kern_type = KERN_TYPE_RIPEMD160;
8282 dgst_size = DGST_SIZE_4_5;
8283 parse_func = ripemd160_parse_hash;
8284 sort_by_digest = sort_by_digest_4_5;
8285 opti_type = OPTI_TYPE_ZERO_BYTE;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 1;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 3;
8290 break;
8291
8292 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8293 salt_type = SALT_TYPE_NONE;
8294 attack_exec = ATTACK_EXEC_ON_GPU;
8295 opts_type = OPTS_TYPE_PT_GENERATE_BE
8296 | OPTS_TYPE_PT_ADD80;
8297 kern_type = KERN_TYPE_WHIRLPOOL;
8298 dgst_size = DGST_SIZE_4_16;
8299 parse_func = whirlpool_parse_hash;
8300 sort_by_digest = sort_by_digest_4_16;
8301 opti_type = OPTI_TYPE_ZERO_BYTE;
8302 dgst_pos0 = 0;
8303 dgst_pos1 = 1;
8304 dgst_pos2 = 2;
8305 dgst_pos3 = 3;
8306 break;
8307
8308 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8309 salt_type = SALT_TYPE_EMBEDDED;
8310 attack_exec = ATTACK_EXEC_ON_CPU;
8311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8312 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8313 dgst_size = DGST_SIZE_4_5;
8314 parse_func = truecrypt_parse_hash_2k;
8315 sort_by_digest = sort_by_digest_4_5;
8316 opti_type = OPTI_TYPE_ZERO_BYTE;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 1;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 3;
8321 break;
8322
8323 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8324 salt_type = SALT_TYPE_EMBEDDED;
8325 attack_exec = ATTACK_EXEC_ON_CPU;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8327 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8328 dgst_size = DGST_SIZE_4_5;
8329 parse_func = truecrypt_parse_hash_2k;
8330 sort_by_digest = sort_by_digest_4_5;
8331 opti_type = OPTI_TYPE_ZERO_BYTE;
8332 dgst_pos0 = 0;
8333 dgst_pos1 = 1;
8334 dgst_pos2 = 2;
8335 dgst_pos3 = 3;
8336 break;
8337
8338 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8339 salt_type = SALT_TYPE_EMBEDDED;
8340 attack_exec = ATTACK_EXEC_ON_CPU;
8341 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8342 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8343 dgst_size = DGST_SIZE_4_5;
8344 parse_func = truecrypt_parse_hash_2k;
8345 sort_by_digest = sort_by_digest_4_5;
8346 opti_type = OPTI_TYPE_ZERO_BYTE;
8347 dgst_pos0 = 0;
8348 dgst_pos1 = 1;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 3;
8351 break;
8352
8353 case 6221: hash_type = HASH_TYPE_SHA512;
8354 salt_type = SALT_TYPE_EMBEDDED;
8355 attack_exec = ATTACK_EXEC_ON_CPU;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8357 kern_type = KERN_TYPE_TCSHA512_XTS512;
8358 dgst_size = DGST_SIZE_8_8;
8359 parse_func = truecrypt_parse_hash_1k;
8360 sort_by_digest = sort_by_digest_8_8;
8361 opti_type = OPTI_TYPE_ZERO_BYTE;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 1;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 3;
8366 break;
8367
8368 case 6222: hash_type = HASH_TYPE_SHA512;
8369 salt_type = SALT_TYPE_EMBEDDED;
8370 attack_exec = ATTACK_EXEC_ON_CPU;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8372 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8373 dgst_size = DGST_SIZE_8_8;
8374 parse_func = truecrypt_parse_hash_1k;
8375 sort_by_digest = sort_by_digest_8_8;
8376 opti_type = OPTI_TYPE_ZERO_BYTE;
8377 dgst_pos0 = 0;
8378 dgst_pos1 = 1;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 3;
8381 break;
8382
8383 case 6223: hash_type = HASH_TYPE_SHA512;
8384 salt_type = SALT_TYPE_EMBEDDED;
8385 attack_exec = ATTACK_EXEC_ON_CPU;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8387 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8388 dgst_size = DGST_SIZE_8_8;
8389 parse_func = truecrypt_parse_hash_1k;
8390 sort_by_digest = sort_by_digest_8_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE;
8392 dgst_pos0 = 0;
8393 dgst_pos1 = 1;
8394 dgst_pos2 = 2;
8395 dgst_pos3 = 3;
8396 break;
8397
8398 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8399 salt_type = SALT_TYPE_EMBEDDED;
8400 attack_exec = ATTACK_EXEC_ON_CPU;
8401 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8402 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8403 dgst_size = DGST_SIZE_4_8;
8404 parse_func = truecrypt_parse_hash_1k;
8405 sort_by_digest = sort_by_digest_4_8;
8406 opti_type = OPTI_TYPE_ZERO_BYTE;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 1;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 3;
8411 break;
8412
8413 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8414 salt_type = SALT_TYPE_EMBEDDED;
8415 attack_exec = ATTACK_EXEC_ON_CPU;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8417 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8418 dgst_size = DGST_SIZE_4_8;
8419 parse_func = truecrypt_parse_hash_1k;
8420 sort_by_digest = sort_by_digest_4_8;
8421 opti_type = OPTI_TYPE_ZERO_BYTE;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8429 salt_type = SALT_TYPE_EMBEDDED;
8430 attack_exec = ATTACK_EXEC_ON_CPU;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8433 dgst_size = DGST_SIZE_4_8;
8434 parse_func = truecrypt_parse_hash_1k;
8435 sort_by_digest = sort_by_digest_4_8;
8436 opti_type = OPTI_TYPE_ZERO_BYTE;
8437 dgst_pos0 = 0;
8438 dgst_pos1 = 1;
8439 dgst_pos2 = 2;
8440 dgst_pos3 = 3;
8441 break;
8442
8443 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8444 salt_type = SALT_TYPE_EMBEDDED;
8445 attack_exec = ATTACK_EXEC_ON_CPU;
8446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8447 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8448 dgst_size = DGST_SIZE_4_5;
8449 parse_func = truecrypt_parse_hash_1k;
8450 sort_by_digest = sort_by_digest_4_5;
8451 opti_type = OPTI_TYPE_ZERO_BYTE;
8452 dgst_pos0 = 0;
8453 dgst_pos1 = 1;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 3;
8456 break;
8457
8458 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8459 salt_type = SALT_TYPE_EMBEDDED;
8460 attack_exec = ATTACK_EXEC_ON_CPU;
8461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8462 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8463 dgst_size = DGST_SIZE_4_5;
8464 parse_func = truecrypt_parse_hash_1k;
8465 sort_by_digest = sort_by_digest_4_5;
8466 opti_type = OPTI_TYPE_ZERO_BYTE;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 1;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 3;
8471 break;
8472
8473 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8474 salt_type = SALT_TYPE_EMBEDDED;
8475 attack_exec = ATTACK_EXEC_ON_CPU;
8476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8477 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8478 dgst_size = DGST_SIZE_4_5;
8479 parse_func = truecrypt_parse_hash_1k;
8480 sort_by_digest = sort_by_digest_4_5;
8481 opti_type = OPTI_TYPE_ZERO_BYTE;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 1;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 3;
8486 break;
8487
8488 case 6300: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_EMBEDDED;
8490 attack_exec = ATTACK_EXEC_ON_CPU;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8492 kern_type = KERN_TYPE_MD5AIX;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5aix_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 6400: hash_type = HASH_TYPE_SHA256;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_ON_CPU;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8507 kern_type = KERN_TYPE_SHA256AIX;
8508 dgst_size = DGST_SIZE_4_8;
8509 parse_func = sha256aix_parse_hash;
8510 sort_by_digest = sort_by_digest_4_8;
8511 opti_type = OPTI_TYPE_ZERO_BYTE;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 1;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 3;
8516 break;
8517
8518 case 6500: hash_type = HASH_TYPE_SHA512;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_ON_CPU;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8522 kern_type = KERN_TYPE_SHA512AIX;
8523 dgst_size = DGST_SIZE_8_8;
8524 parse_func = sha512aix_parse_hash;
8525 sort_by_digest = sort_by_digest_8_8;
8526 opti_type = OPTI_TYPE_ZERO_BYTE;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 6600: hash_type = HASH_TYPE_AES;
8534 salt_type = SALT_TYPE_EMBEDDED;
8535 attack_exec = ATTACK_EXEC_ON_CPU;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8537 kern_type = KERN_TYPE_AGILEKEY;
8538 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8539 parse_func = agilekey_parse_hash;
8540 sort_by_digest = sort_by_digest_4_5;
8541 opti_type = OPTI_TYPE_ZERO_BYTE;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 6700: hash_type = HASH_TYPE_SHA1;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_ON_CPU;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8552 kern_type = KERN_TYPE_SHA1AIX;
8553 dgst_size = DGST_SIZE_4_5;
8554 parse_func = sha1aix_parse_hash;
8555 sort_by_digest = sort_by_digest_4_5;
8556 opti_type = OPTI_TYPE_ZERO_BYTE;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 1;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 3;
8561 break;
8562
8563 case 6800: hash_type = HASH_TYPE_AES;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_ON_CPU;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8567 kern_type = KERN_TYPE_LASTPASS;
8568 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8569 parse_func = lastpass_parse_hash;
8570 sort_by_digest = sort_by_digest_4_8;
8571 opti_type = OPTI_TYPE_ZERO_BYTE;
8572 dgst_pos0 = 0;
8573 dgst_pos1 = 1;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 3;
8576 break;
8577
8578 case 6900: hash_type = HASH_TYPE_GOST;
8579 salt_type = SALT_TYPE_NONE;
8580 attack_exec = ATTACK_EXEC_ON_GPU;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8582 kern_type = KERN_TYPE_GOST;
8583 dgst_size = DGST_SIZE_4_8;
8584 parse_func = gost_parse_hash;
8585 sort_by_digest = sort_by_digest_4_8;
8586 opti_type = OPTI_TYPE_ZERO_BYTE;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 1;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 3;
8591 break;
8592
8593 case 7100: hash_type = HASH_TYPE_SHA512;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_ON_CPU;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8597 kern_type = KERN_TYPE_PBKDF2_SHA512;
8598 dgst_size = DGST_SIZE_8_16;
8599 parse_func = sha512osx_parse_hash;
8600 sort_by_digest = sort_by_digest_8_16;
8601 opti_type = OPTI_TYPE_ZERO_BYTE;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 7200: hash_type = HASH_TYPE_SHA512;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_ON_CPU;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8612 kern_type = KERN_TYPE_PBKDF2_SHA512;
8613 dgst_size = DGST_SIZE_8_16;
8614 parse_func = sha512grub_parse_hash;
8615 sort_by_digest = sort_by_digest_8_16;
8616 opti_type = OPTI_TYPE_ZERO_BYTE;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 1;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 3;
8621 break;
8622
8623 case 7300: hash_type = HASH_TYPE_SHA1;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_ON_GPU;
8626 opts_type = OPTS_TYPE_PT_GENERATE_BE
8627 | OPTS_TYPE_ST_ADD80
8628 | OPTS_TYPE_ST_ADDBITS15;
8629 kern_type = KERN_TYPE_RAKP;
8630 dgst_size = DGST_SIZE_4_5;
8631 parse_func = rakp_parse_hash;
8632 sort_by_digest = sort_by_digest_4_5;
8633 opti_type = OPTI_TYPE_ZERO_BYTE
8634 | OPTI_TYPE_NOT_ITERATED;
8635 dgst_pos0 = 3;
8636 dgst_pos1 = 4;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 1;
8639 break;
8640
8641 case 7400: hash_type = HASH_TYPE_SHA256;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_ON_CPU;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8645 kern_type = KERN_TYPE_SHA256CRYPT;
8646 dgst_size = DGST_SIZE_4_8;
8647 parse_func = sha256crypt_parse_hash;
8648 sort_by_digest = sort_by_digest_4_8;
8649 opti_type = OPTI_TYPE_ZERO_BYTE;
8650 dgst_pos0 = 0;
8651 dgst_pos1 = 1;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 3;
8654 break;
8655
8656 case 7500: hash_type = HASH_TYPE_KRB5PA;
8657 salt_type = SALT_TYPE_EMBEDDED;
8658 attack_exec = ATTACK_EXEC_ON_GPU;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8660 kern_type = KERN_TYPE_KRB5PA;
8661 dgst_size = DGST_SIZE_4_4;
8662 parse_func = krb5pa_parse_hash;
8663 sort_by_digest = sort_by_digest_4_4;
8664 opti_type = OPTI_TYPE_ZERO_BYTE
8665 | OPTI_TYPE_NOT_ITERATED;
8666 dgst_pos0 = 3;
8667 dgst_pos1 = 7;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 6;
8670 break;
8671
8672 case 7600: hash_type = HASH_TYPE_SHA1;
8673 salt_type = SALT_TYPE_INTERN;
8674 attack_exec = ATTACK_EXEC_ON_GPU;
8675 opts_type = OPTS_TYPE_PT_GENERATE_BE
8676 | OPTS_TYPE_PT_ADD80
8677 | OPTS_TYPE_PT_ADDBITS15;
8678 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8679 dgst_size = DGST_SIZE_4_5;
8680 parse_func = redmine_parse_hash;
8681 sort_by_digest = sort_by_digest_4_5;
8682 opti_type = OPTI_TYPE_ZERO_BYTE
8683 | OPTI_TYPE_PRECOMPUTE_INIT
8684 | OPTI_TYPE_EARLY_SKIP
8685 | OPTI_TYPE_NOT_ITERATED
8686 | OPTI_TYPE_PREPENDED_SALT;
8687 dgst_pos0 = 3;
8688 dgst_pos1 = 4;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 1;
8691 break;
8692
8693 case 7700: hash_type = HASH_TYPE_SAPB;
8694 salt_type = SALT_TYPE_EMBEDDED;
8695 attack_exec = ATTACK_EXEC_ON_GPU;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE
8697 | OPTS_TYPE_PT_UPPER
8698 | OPTS_TYPE_ST_UPPER;
8699 kern_type = KERN_TYPE_SAPB;
8700 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8701 parse_func = sapb_parse_hash;
8702 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8703 opti_type = OPTI_TYPE_ZERO_BYTE
8704 | OPTI_TYPE_PRECOMPUTE_INIT
8705 | OPTI_TYPE_NOT_ITERATED;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 1;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 3;
8710 break;
8711
8712 case 7800: hash_type = HASH_TYPE_SAPG;
8713 salt_type = SALT_TYPE_EMBEDDED;
8714 attack_exec = ATTACK_EXEC_ON_GPU;
8715 opts_type = OPTS_TYPE_PT_GENERATE_BE
8716 | OPTS_TYPE_ST_ADD80
8717 | OPTS_TYPE_ST_UPPER;
8718 kern_type = KERN_TYPE_SAPG;
8719 dgst_size = DGST_SIZE_4_5;
8720 parse_func = sapg_parse_hash;
8721 sort_by_digest = sort_by_digest_4_5;
8722 opti_type = OPTI_TYPE_ZERO_BYTE
8723 | OPTI_TYPE_PRECOMPUTE_INIT
8724 | OPTI_TYPE_NOT_ITERATED;
8725 dgst_pos0 = 3;
8726 dgst_pos1 = 4;
8727 dgst_pos2 = 2;
8728 dgst_pos3 = 1;
8729 break;
8730
8731 case 7900: hash_type = HASH_TYPE_SHA512;
8732 salt_type = SALT_TYPE_EMBEDDED;
8733 attack_exec = ATTACK_EXEC_ON_CPU;
8734 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8735 kern_type = KERN_TYPE_DRUPAL7;
8736 dgst_size = DGST_SIZE_8_8;
8737 parse_func = drupal7_parse_hash;
8738 sort_by_digest = sort_by_digest_8_8;
8739 opti_type = OPTI_TYPE_ZERO_BYTE;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 1;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 3;
8744 break;
8745
8746 case 8000: hash_type = HASH_TYPE_SHA256;
8747 salt_type = SALT_TYPE_EMBEDDED;
8748 attack_exec = ATTACK_EXEC_ON_GPU;
8749 opts_type = OPTS_TYPE_PT_GENERATE_BE
8750 | OPTS_TYPE_PT_UNICODE
8751 | OPTS_TYPE_ST_ADD80
8752 | OPTS_TYPE_ST_HEX;
8753 kern_type = KERN_TYPE_SYBASEASE;
8754 dgst_size = DGST_SIZE_4_8;
8755 parse_func = sybasease_parse_hash;
8756 sort_by_digest = sort_by_digest_4_8;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_PRECOMPUTE_INIT
8759 | OPTI_TYPE_EARLY_SKIP
8760 | OPTI_TYPE_NOT_ITERATED
8761 | OPTI_TYPE_RAW_HASH;
8762 dgst_pos0 = 3;
8763 dgst_pos1 = 7;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 6;
8766 break;
8767
8768 case 8100: hash_type = HASH_TYPE_SHA1;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_ON_GPU;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8772 kern_type = KERN_TYPE_NETSCALER;
8773 dgst_size = DGST_SIZE_4_5;
8774 parse_func = netscaler_parse_hash;
8775 sort_by_digest = sort_by_digest_4_5;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_PRECOMPUTE_INIT
8778 | OPTI_TYPE_PRECOMPUTE_MERKLE
8779 | OPTI_TYPE_EARLY_SKIP
8780 | OPTI_TYPE_NOT_ITERATED
8781 | OPTI_TYPE_PREPENDED_SALT
8782 | OPTI_TYPE_RAW_HASH;
8783 dgst_pos0 = 3;
8784 dgst_pos1 = 4;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 8200: hash_type = HASH_TYPE_SHA256;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_ON_CPU;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8793 kern_type = KERN_TYPE_CLOUDKEY;
8794 dgst_size = DGST_SIZE_4_8;
8795 parse_func = cloudkey_parse_hash;
8796 sort_by_digest = sort_by_digest_4_8;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 8300: hash_type = HASH_TYPE_SHA1;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_ON_GPU;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE
8808 | OPTS_TYPE_ST_HEX
8809 | OPTS_TYPE_ST_ADD80;
8810 kern_type = KERN_TYPE_NSEC3;
8811 dgst_size = DGST_SIZE_4_5;
8812 parse_func = nsec3_parse_hash;
8813 sort_by_digest = sort_by_digest_4_5;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 3;
8816 dgst_pos1 = 4;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 1;
8819 break;
8820
8821 case 8400: hash_type = HASH_TYPE_SHA1;
8822 salt_type = SALT_TYPE_INTERN;
8823 attack_exec = ATTACK_EXEC_ON_GPU;
8824 opts_type = OPTS_TYPE_PT_GENERATE_BE
8825 | OPTS_TYPE_PT_ADD80
8826 | OPTS_TYPE_PT_ADDBITS15;
8827 kern_type = KERN_TYPE_WBB3;
8828 dgst_size = DGST_SIZE_4_5;
8829 parse_func = wbb3_parse_hash;
8830 sort_by_digest = sort_by_digest_4_5;
8831 opti_type = OPTI_TYPE_ZERO_BYTE
8832 | OPTI_TYPE_PRECOMPUTE_INIT
8833 | OPTI_TYPE_NOT_ITERATED;
8834 dgst_pos0 = 3;
8835 dgst_pos1 = 4;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 1;
8838 break;
8839
8840 case 8500: hash_type = HASH_TYPE_DESRACF;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_ON_GPU;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE
8844 | OPTS_TYPE_ST_UPPER;
8845 kern_type = KERN_TYPE_RACF;
8846 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8847 parse_func = racf_parse_hash;
8848 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 1;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 3;
8855 break;
8856
8857 case 8600: hash_type = HASH_TYPE_LOTUS5;
8858 salt_type = SALT_TYPE_NONE;
8859 attack_exec = ATTACK_EXEC_ON_GPU;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8861 kern_type = KERN_TYPE_LOTUS5;
8862 dgst_size = DGST_SIZE_4_4;
8863 parse_func = lotus5_parse_hash;
8864 sort_by_digest = sort_by_digest_4_4;
8865 opti_type = OPTI_TYPE_EARLY_SKIP
8866 | OPTI_TYPE_NOT_ITERATED
8867 | OPTI_TYPE_NOT_SALTED
8868 | OPTI_TYPE_RAW_HASH;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 8700: hash_type = HASH_TYPE_LOTUS6;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_ON_GPU;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8879 kern_type = KERN_TYPE_LOTUS6;
8880 dgst_size = DGST_SIZE_4_4;
8881 parse_func = lotus6_parse_hash;
8882 sort_by_digest = sort_by_digest_4_4;
8883 opti_type = OPTI_TYPE_EARLY_SKIP
8884 | OPTI_TYPE_NOT_ITERATED
8885 | OPTI_TYPE_RAW_HASH;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_ON_CPU;
8895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8896 kern_type = KERN_TYPE_ANDROIDFDE;
8897 dgst_size = DGST_SIZE_4_4;
8898 parse_func = androidfde_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4;
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 8900: hash_type = HASH_TYPE_SCRYPT;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_ON_CPU;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8911 kern_type = KERN_TYPE_SCRYPT;
8912 dgst_size = DGST_SIZE_4_8;
8913 parse_func = scrypt_parse_hash;
8914 sort_by_digest = sort_by_digest_4_8;
8915 opti_type = OPTI_TYPE_ZERO_BYTE;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 9000: hash_type = HASH_TYPE_SHA1;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_ON_CPU;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE
8926 | OPTS_TYPE_ST_GENERATE_LE;
8927 kern_type = KERN_TYPE_PSAFE2;
8928 dgst_size = DGST_SIZE_4_5;
8929 parse_func = psafe2_parse_hash;
8930 sort_by_digest = sort_by_digest_4_5;
8931 opti_type = OPTI_TYPE_ZERO_BYTE;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 1;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 3;
8936 break;
8937
8938 case 9100: hash_type = HASH_TYPE_LOTUS8;
8939 salt_type = SALT_TYPE_EMBEDDED;
8940 attack_exec = ATTACK_EXEC_ON_CPU;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8942 kern_type = KERN_TYPE_LOTUS8;
8943 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8944 parse_func = lotus8_parse_hash;
8945 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8946 opti_type = OPTI_TYPE_ZERO_BYTE;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 1;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 3;
8951 break;
8952
8953 case 9200: hash_type = HASH_TYPE_SHA256;
8954 salt_type = SALT_TYPE_EMBEDDED;
8955 attack_exec = ATTACK_EXEC_ON_CPU;
8956 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8957 kern_type = KERN_TYPE_PBKDF2_SHA256;
8958 dgst_size = DGST_SIZE_4_32;
8959 parse_func = cisco8_parse_hash;
8960 sort_by_digest = sort_by_digest_4_32;
8961 opti_type = OPTI_TYPE_ZERO_BYTE;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 9300: hash_type = HASH_TYPE_SCRYPT;
8969 salt_type = SALT_TYPE_EMBEDDED;
8970 attack_exec = ATTACK_EXEC_ON_CPU;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8972 kern_type = KERN_TYPE_SCRYPT;
8973 dgst_size = DGST_SIZE_4_8;
8974 parse_func = cisco9_parse_hash;
8975 sort_by_digest = sort_by_digest_4_8;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 9400: hash_type = HASH_TYPE_OFFICE2007;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_ON_CPU;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8987 kern_type = KERN_TYPE_OFFICE2007;
8988 dgst_size = DGST_SIZE_4_4;
8989 parse_func = office2007_parse_hash;
8990 sort_by_digest = sort_by_digest_4_4;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 9500: hash_type = HASH_TYPE_OFFICE2010;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_ON_CPU;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9002 kern_type = KERN_TYPE_OFFICE2010;
9003 dgst_size = DGST_SIZE_4_4;
9004 parse_func = office2010_parse_hash;
9005 sort_by_digest = sort_by_digest_4_4;
9006 opti_type = OPTI_TYPE_ZERO_BYTE;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_ON_CPU;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9017 kern_type = KERN_TYPE_OFFICE2013;
9018 dgst_size = DGST_SIZE_4_4;
9019 parse_func = office2013_parse_hash;
9020 sort_by_digest = sort_by_digest_4_4;
9021 opti_type = OPTI_TYPE_ZERO_BYTE;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_ON_GPU;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE
9032 | OPTS_TYPE_PT_ADD80
9033 | OPTS_TYPE_PT_UNICODE;
9034 kern_type = KERN_TYPE_OLDOFFICE01;
9035 dgst_size = DGST_SIZE_4_4;
9036 parse_func = oldoffice01_parse_hash;
9037 sort_by_digest = sort_by_digest_4_4;
9038 opti_type = OPTI_TYPE_ZERO_BYTE
9039 | OPTI_TYPE_PRECOMPUTE_INIT
9040 | OPTI_TYPE_NOT_ITERATED;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 1;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 3;
9045 break;
9046
9047 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9048 salt_type = SALT_TYPE_EMBEDDED;
9049 attack_exec = ATTACK_EXEC_ON_GPU;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE
9051 | OPTS_TYPE_PT_ADD80;
9052 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9053 dgst_size = DGST_SIZE_4_4;
9054 parse_func = oldoffice01cm1_parse_hash;
9055 sort_by_digest = sort_by_digest_4_4;
9056 opti_type = OPTI_TYPE_ZERO_BYTE
9057 | OPTI_TYPE_PRECOMPUTE_INIT
9058 | OPTI_TYPE_NOT_ITERATED;
9059 dgst_pos0 = 0;
9060 dgst_pos1 = 1;
9061 dgst_pos2 = 2;
9062 dgst_pos3 = 3;
9063 break;
9064
9065 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9066 salt_type = SALT_TYPE_EMBEDDED;
9067 attack_exec = ATTACK_EXEC_ON_GPU;
9068 opts_type = OPTS_TYPE_PT_GENERATE_LE
9069 | OPTS_TYPE_PT_ADD80
9070 | OPTS_TYPE_PT_UNICODE
9071 | OPTS_TYPE_PT_NEVERCRACK;
9072 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9073 dgst_size = DGST_SIZE_4_4;
9074 parse_func = oldoffice01cm2_parse_hash;
9075 sort_by_digest = sort_by_digest_4_4;
9076 opti_type = OPTI_TYPE_ZERO_BYTE
9077 | OPTI_TYPE_PRECOMPUTE_INIT
9078 | OPTI_TYPE_NOT_ITERATED;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_ON_GPU;
9088 opts_type = OPTS_TYPE_PT_GENERATE_BE
9089 | OPTS_TYPE_PT_ADD80
9090 | OPTS_TYPE_PT_UNICODE;
9091 kern_type = KERN_TYPE_OLDOFFICE34;
9092 dgst_size = DGST_SIZE_4_4;
9093 parse_func = oldoffice34_parse_hash;
9094 sort_by_digest = sort_by_digest_4_4;
9095 opti_type = OPTI_TYPE_ZERO_BYTE
9096 | OPTI_TYPE_PRECOMPUTE_INIT
9097 | OPTI_TYPE_NOT_ITERATED;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_ON_GPU;
9107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9108 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9109 dgst_size = DGST_SIZE_4_4;
9110 parse_func = oldoffice34cm1_parse_hash;
9111 sort_by_digest = sort_by_digest_4_4;
9112 opti_type = OPTI_TYPE_ZERO_BYTE
9113 | OPTI_TYPE_PRECOMPUTE_INIT
9114 | OPTI_TYPE_NOT_ITERATED;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_ON_GPU;
9124 opts_type = OPTS_TYPE_PT_GENERATE_BE
9125 | OPTS_TYPE_PT_ADD80
9126 | OPTS_TYPE_PT_UNICODE
9127 | OPTS_TYPE_PT_NEVERCRACK;
9128 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9129 dgst_size = DGST_SIZE_4_4;
9130 parse_func = oldoffice34cm2_parse_hash;
9131 sort_by_digest = sort_by_digest_4_4;
9132 opti_type = OPTI_TYPE_ZERO_BYTE
9133 | OPTI_TYPE_PRECOMPUTE_INIT
9134 | OPTI_TYPE_NOT_ITERATED;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 1;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 3;
9139 break;
9140
9141 case 9900: hash_type = HASH_TYPE_MD5;
9142 salt_type = SALT_TYPE_NONE;
9143 attack_exec = ATTACK_EXEC_ON_GPU;
9144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9145 kern_type = KERN_TYPE_RADMIN2;
9146 dgst_size = DGST_SIZE_4_4;
9147 parse_func = radmin2_parse_hash;
9148 sort_by_digest = sort_by_digest_4_4;
9149 opti_type = OPTI_TYPE_ZERO_BYTE
9150 | OPTI_TYPE_PRECOMPUTE_INIT
9151 | OPTI_TYPE_EARLY_SKIP
9152 | OPTI_TYPE_NOT_ITERATED
9153 | OPTI_TYPE_NOT_SALTED;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 3;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 1;
9158 break;
9159
9160 case 10000: hash_type = HASH_TYPE_SHA256;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_ON_CPU;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9164 kern_type = KERN_TYPE_PBKDF2_SHA256;
9165 dgst_size = DGST_SIZE_4_32;
9166 parse_func = djangopbkdf2_parse_hash;
9167 sort_by_digest = sort_by_digest_4_32;
9168 opti_type = OPTI_TYPE_ZERO_BYTE;
9169 dgst_pos0 = 0;
9170 dgst_pos1 = 1;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 3;
9173 break;
9174
9175 case 10100: hash_type = HASH_TYPE_SIPHASH;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_ON_GPU;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9179 kern_type = KERN_TYPE_SIPHASH;
9180 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9181 parse_func = siphash_parse_hash;
9182 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_NOT_ITERATED
9185 | OPTI_TYPE_RAW_HASH;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 10200: hash_type = HASH_TYPE_MD5;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_ON_GPU;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE
9196 | OPTS_TYPE_ST_ADD80
9197 | OPTS_TYPE_ST_ADDBITS14;
9198 kern_type = KERN_TYPE_HMACMD5_PW;
9199 dgst_size = DGST_SIZE_4_4;
9200 parse_func = crammd5_parse_hash;
9201 sort_by_digest = sort_by_digest_4_4;
9202 opti_type = OPTI_TYPE_ZERO_BYTE
9203 | OPTI_TYPE_NOT_ITERATED;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 3;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 1;
9208 break;
9209
9210 case 10300: hash_type = HASH_TYPE_SHA1;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_ON_CPU;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_SAPH_SHA1;
9215 dgst_size = DGST_SIZE_4_5;
9216 parse_func = saph_sha1_parse_hash;
9217 sort_by_digest = sort_by_digest_4_5;
9218 opti_type = OPTI_TYPE_ZERO_BYTE;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 10400: hash_type = HASH_TYPE_PDFU16;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_ON_GPU;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9229 kern_type = KERN_TYPE_PDF11;
9230 dgst_size = DGST_SIZE_4_4;
9231 parse_func = pdf11_parse_hash;
9232 sort_by_digest = sort_by_digest_4_4;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_NOT_ITERATED;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 10410: hash_type = HASH_TYPE_PDFU16;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_ON_GPU;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9245 kern_type = KERN_TYPE_PDF11CM1;
9246 dgst_size = DGST_SIZE_4_4;
9247 parse_func = pdf11cm1_parse_hash;
9248 sort_by_digest = sort_by_digest_4_4;
9249 opti_type = OPTI_TYPE_ZERO_BYTE
9250 | OPTI_TYPE_NOT_ITERATED;
9251 dgst_pos0 = 0;
9252 dgst_pos1 = 1;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 3;
9255 break;
9256
9257 case 10420: hash_type = HASH_TYPE_PDFU16;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_ON_GPU;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9261 kern_type = KERN_TYPE_PDF11CM2;
9262 dgst_size = DGST_SIZE_4_4;
9263 parse_func = pdf11cm2_parse_hash;
9264 sort_by_digest = sort_by_digest_4_4;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_NOT_ITERATED;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 10500: hash_type = HASH_TYPE_PDFU16;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_ON_CPU;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_PDF14;
9278 dgst_size = DGST_SIZE_4_4;
9279 parse_func = pdf14_parse_hash;
9280 sort_by_digest = sort_by_digest_4_4;
9281 opti_type = OPTI_TYPE_ZERO_BYTE
9282 | OPTI_TYPE_NOT_ITERATED;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 10600: hash_type = HASH_TYPE_SHA256;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_ON_GPU;
9292 opts_type = OPTS_TYPE_PT_GENERATE_BE
9293 | OPTS_TYPE_ST_ADD80
9294 | OPTS_TYPE_ST_ADDBITS15
9295 | OPTS_TYPE_HASH_COPY;
9296 kern_type = KERN_TYPE_SHA256_PWSLT;
9297 dgst_size = DGST_SIZE_4_8;
9298 parse_func = pdf17l3_parse_hash;
9299 sort_by_digest = sort_by_digest_4_8;
9300 opti_type = OPTI_TYPE_ZERO_BYTE
9301 | OPTI_TYPE_PRECOMPUTE_INIT
9302 | OPTI_TYPE_PRECOMPUTE_MERKLE
9303 | OPTI_TYPE_EARLY_SKIP
9304 | OPTI_TYPE_NOT_ITERATED
9305 | OPTI_TYPE_APPENDED_SALT
9306 | OPTI_TYPE_RAW_HASH;
9307 dgst_pos0 = 3;
9308 dgst_pos1 = 7;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 6;
9311 break;
9312
9313 case 10700: hash_type = HASH_TYPE_PDFU32;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_ON_CPU;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE
9317 | OPTS_TYPE_HASH_COPY;
9318 kern_type = KERN_TYPE_PDF17L8;
9319 dgst_size = DGST_SIZE_4_8;
9320 parse_func = pdf17l8_parse_hash;
9321 sort_by_digest = sort_by_digest_4_8;
9322 opti_type = OPTI_TYPE_ZERO_BYTE
9323 | OPTI_TYPE_NOT_ITERATED;
9324 dgst_pos0 = 0;
9325 dgst_pos1 = 1;
9326 dgst_pos2 = 2;
9327 dgst_pos3 = 3;
9328 break;
9329
9330 case 10800: hash_type = HASH_TYPE_SHA384;
9331 salt_type = SALT_TYPE_NONE;
9332 attack_exec = ATTACK_EXEC_ON_GPU;
9333 opts_type = OPTS_TYPE_PT_GENERATE_BE
9334 | OPTS_TYPE_PT_ADD80
9335 | OPTS_TYPE_PT_ADDBITS15;
9336 kern_type = KERN_TYPE_SHA384;
9337 dgst_size = DGST_SIZE_8_8;
9338 parse_func = sha384_parse_hash;
9339 sort_by_digest = sort_by_digest_8_8;
9340 opti_type = OPTI_TYPE_ZERO_BYTE
9341 | OPTI_TYPE_PRECOMPUTE_INIT
9342 | OPTI_TYPE_PRECOMPUTE_MERKLE
9343 | OPTI_TYPE_EARLY_SKIP
9344 | OPTI_TYPE_NOT_ITERATED
9345 | OPTI_TYPE_NOT_SALTED
9346 | OPTI_TYPE_RAW_HASH;
9347 dgst_pos0 = 6;
9348 dgst_pos1 = 7;
9349 dgst_pos2 = 4;
9350 dgst_pos3 = 5;
9351 break;
9352
9353 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_ON_CPU;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE
9357 | OPTS_TYPE_ST_BASE64
9358 | OPTS_TYPE_HASH_COPY;
9359 kern_type = KERN_TYPE_PBKDF2_SHA256;
9360 dgst_size = DGST_SIZE_4_32;
9361 parse_func = pbkdf2_sha256_parse_hash;
9362 sort_by_digest = sort_by_digest_4_32;
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 11000: hash_type = HASH_TYPE_MD5;
9371 salt_type = SALT_TYPE_INTERN;
9372 attack_exec = ATTACK_EXEC_ON_GPU;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE
9374 | OPTS_TYPE_PT_ADD80;
9375 kern_type = KERN_TYPE_PRESTASHOP;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = prestashop_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_INIT
9381 | OPTI_TYPE_NOT_ITERATED
9382 | OPTI_TYPE_PREPENDED_SALT;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 3;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 1;
9387 break;
9388
9389 case 11100: hash_type = HASH_TYPE_MD5;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_ON_GPU;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE
9393 | OPTS_TYPE_ST_ADD80;
9394 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = postgresql_auth_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_PRECOMPUTE_INIT
9400 | OPTI_TYPE_PRECOMPUTE_MERKLE
9401 | OPTI_TYPE_EARLY_SKIP;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 3;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 1;
9406 break;
9407
9408 case 11200: hash_type = HASH_TYPE_SHA1;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_ON_GPU;
9411 opts_type = OPTS_TYPE_PT_GENERATE_BE
9412 | OPTS_TYPE_PT_ADD80
9413 | OPTS_TYPE_ST_HEX;
9414 kern_type = KERN_TYPE_MYSQL_AUTH;
9415 dgst_size = DGST_SIZE_4_5;
9416 parse_func = mysql_auth_parse_hash;
9417 sort_by_digest = sort_by_digest_4_5;
9418 opti_type = OPTI_TYPE_ZERO_BYTE
9419 | OPTI_TYPE_EARLY_SKIP;
9420 dgst_pos0 = 3;
9421 dgst_pos1 = 4;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 1;
9424 break;
9425
9426 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_ON_CPU;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE
9430 | OPTS_TYPE_ST_HEX
9431 | OPTS_TYPE_ST_ADD80;
9432 kern_type = KERN_TYPE_BITCOIN_WALLET;
9433 dgst_size = DGST_SIZE_4_4;
9434 parse_func = bitcoin_wallet_parse_hash;
9435 sort_by_digest = sort_by_digest_4_4;
9436 opti_type = OPTI_TYPE_ZERO_BYTE;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 11400: hash_type = HASH_TYPE_MD5;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_ON_GPU;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE
9447 | OPTS_TYPE_PT_ADD80
9448 | OPTS_TYPE_HASH_COPY;
9449 kern_type = KERN_TYPE_SIP_AUTH;
9450 dgst_size = DGST_SIZE_4_4;
9451 parse_func = sip_auth_parse_hash;
9452 sort_by_digest = sort_by_digest_4_4;
9453 opti_type = OPTI_TYPE_ZERO_BYTE;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 3;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 1;
9458 break;
9459
9460 case 11500: hash_type = HASH_TYPE_CRC32;
9461 salt_type = SALT_TYPE_INTERN;
9462 attack_exec = ATTACK_EXEC_ON_GPU;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE
9464 | OPTS_TYPE_ST_GENERATE_LE
9465 | OPTS_TYPE_ST_HEX;
9466 kern_type = KERN_TYPE_CRC32;
9467 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9468 parse_func = crc32_parse_hash;
9469 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9470 opti_type = OPTI_TYPE_ZERO_BYTE;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 11600: hash_type = HASH_TYPE_AES;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_ON_CPU;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE
9481 | OPTS_TYPE_PT_NEVERCRACK;
9482 kern_type = KERN_TYPE_SEVEN_ZIP;
9483 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9484 parse_func = seven_zip_parse_hash;
9485 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9494 salt_type = SALT_TYPE_NONE;
9495 attack_exec = ATTACK_EXEC_ON_GPU;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE
9497 | OPTS_TYPE_PT_ADD01;
9498 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9499 dgst_size = DGST_SIZE_4_8;
9500 parse_func = gost2012sbog_256_parse_hash;
9501 sort_by_digest = sort_by_digest_4_8;
9502 opti_type = OPTI_TYPE_ZERO_BYTE;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9510 salt_type = SALT_TYPE_NONE;
9511 attack_exec = ATTACK_EXEC_ON_GPU;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE
9513 | OPTS_TYPE_PT_ADD01;
9514 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9515 dgst_size = DGST_SIZE_4_16;
9516 parse_func = gost2012sbog_512_parse_hash;
9517 sort_by_digest = sort_by_digest_4_16;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_ON_CPU;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE
9529 | OPTS_TYPE_ST_BASE64
9530 | OPTS_TYPE_HASH_COPY;
9531 kern_type = KERN_TYPE_PBKDF2_MD5;
9532 dgst_size = DGST_SIZE_4_32;
9533 parse_func = pbkdf2_md5_parse_hash;
9534 sort_by_digest = sort_by_digest_4_32;
9535 opti_type = OPTI_TYPE_ZERO_BYTE;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_ON_CPU;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE
9546 | OPTS_TYPE_ST_BASE64
9547 | OPTS_TYPE_HASH_COPY;
9548 kern_type = KERN_TYPE_PBKDF2_SHA1;
9549 dgst_size = DGST_SIZE_4_32;
9550 parse_func = pbkdf2_sha1_parse_hash;
9551 sort_by_digest = sort_by_digest_4_32;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_ON_CPU;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_ST_BASE64
9564 | OPTS_TYPE_HASH_COPY;
9565 kern_type = KERN_TYPE_PBKDF2_SHA512;
9566 dgst_size = DGST_SIZE_8_16;
9567 parse_func = pbkdf2_sha512_parse_hash;
9568 sort_by_digest = sort_by_digest_8_16;
9569 opti_type = OPTI_TYPE_ZERO_BYTE;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_ON_CPU;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9580 kern_type = KERN_TYPE_ECRYPTFS;
9581 dgst_size = DGST_SIZE_8_8;
9582 parse_func = ecryptfs_parse_hash;
9583 sort_by_digest = sort_by_digest_8_8;
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 12300: hash_type = HASH_TYPE_ORACLET;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_ON_CPU;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9595 kern_type = KERN_TYPE_ORACLET;
9596 dgst_size = DGST_SIZE_8_16;
9597 parse_func = oraclet_parse_hash;
9598 sort_by_digest = sort_by_digest_8_16;
9599 opti_type = OPTI_TYPE_ZERO_BYTE;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_ON_CPU;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9610 kern_type = KERN_TYPE_BSDICRYPT;
9611 dgst_size = DGST_SIZE_4_4;
9612 parse_func = bsdicrypt_parse_hash;
9613 sort_by_digest = sort_by_digest_4_4;
9614 opti_type = OPTI_TYPE_ZERO_BYTE
9615 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 12500: hash_type = HASH_TYPE_RAR3HP;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_ON_CPU;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9626 kern_type = KERN_TYPE_RAR3;
9627 dgst_size = DGST_SIZE_4_4;
9628 parse_func = rar3hp_parse_hash;
9629 sort_by_digest = sort_by_digest_4_4;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 12600: hash_type = HASH_TYPE_SHA256;
9638 salt_type = SALT_TYPE_INTERN;
9639 attack_exec = ATTACK_EXEC_ON_GPU;
9640 opts_type = OPTS_TYPE_PT_GENERATE_BE
9641 | OPTS_TYPE_PT_ADD80;
9642 kern_type = KERN_TYPE_CF10;
9643 dgst_size = DGST_SIZE_4_8;
9644 parse_func = cf10_parse_hash;
9645 sort_by_digest = sort_by_digest_4_8;
9646 opti_type = OPTI_TYPE_ZERO_BYTE
9647 | OPTI_TYPE_PRECOMPUTE_INIT
9648 | OPTI_TYPE_EARLY_SKIP
9649 | OPTI_TYPE_NOT_ITERATED;
9650 dgst_pos0 = 3;
9651 dgst_pos1 = 7;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 6;
9654 break;
9655
9656 case 12700: hash_type = HASH_TYPE_AES;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_ON_CPU;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE
9660 | OPTS_TYPE_HASH_COPY;
9661 kern_type = KERN_TYPE_MYWALLET;
9662 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9663 parse_func = mywallet_parse_hash;
9664 sort_by_digest = sort_by_digest_4_5;
9665 opti_type = OPTI_TYPE_ZERO_BYTE;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_ON_CPU;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_MS_DRSR;
9677 dgst_size = DGST_SIZE_4_8;
9678 parse_func = ms_drsr_parse_hash;
9679 sort_by_digest = sort_by_digest_4_8;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 default: usage_mini_print (PROGNAME); return (-1);
9688 }
9689
9690 /**
9691 * transpose
9692 */
9693
9694 data.parse_func = parse_func;
9695
9696 /**
9697 * misc stuff
9698 */
9699
9700 if (hex_salt)
9701 {
9702 if (salt_type == SALT_TYPE_INTERN)
9703 {
9704 opts_type |= OPTS_TYPE_ST_HEX;
9705 }
9706 else
9707 {
9708 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9709
9710 return (-1);
9711 }
9712 }
9713
9714 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9715 | (salt_type == SALT_TYPE_EXTERN)
9716 | (salt_type == SALT_TYPE_EMBEDDED)
9717 | (salt_type == SALT_TYPE_VIRTUAL));
9718
9719 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9720
9721 data.hash_type = hash_type;
9722 data.attack_mode = attack_mode;
9723 data.attack_kern = attack_kern;
9724 data.attack_exec = attack_exec;
9725 data.kern_type = kern_type;
9726 data.opts_type = opts_type;
9727 data.dgst_size = dgst_size;
9728 data.salt_type = salt_type;
9729 data.isSalted = isSalted;
9730 data.sort_by_digest = sort_by_digest;
9731 data.dgst_pos0 = dgst_pos0;
9732 data.dgst_pos1 = dgst_pos1;
9733 data.dgst_pos2 = dgst_pos2;
9734 data.dgst_pos3 = dgst_pos3;
9735
9736 esalt_size = 0;
9737
9738 switch (hash_mode)
9739 {
9740 case 2500: esalt_size = sizeof (wpa_t); break;
9741 case 5300: esalt_size = sizeof (ikepsk_t); break;
9742 case 5400: esalt_size = sizeof (ikepsk_t); break;
9743 case 5500: esalt_size = sizeof (netntlm_t); break;
9744 case 5600: esalt_size = sizeof (netntlm_t); break;
9745 case 6211:
9746 case 6212:
9747 case 6213:
9748 case 6221:
9749 case 6222:
9750 case 6223:
9751 case 6231:
9752 case 6232:
9753 case 6233:
9754 case 6241:
9755 case 6242:
9756 case 6243: esalt_size = sizeof (tc_t); break;
9757 case 6600: esalt_size = sizeof (agilekey_t); break;
9758 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9759 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9760 case 7300: esalt_size = sizeof (rakp_t); break;
9761 case 7500: esalt_size = sizeof (krb5pa_t); break;
9762 case 8200: esalt_size = sizeof (cloudkey_t); break;
9763 case 8800: esalt_size = sizeof (androidfde_t); break;
9764 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9765 case 9400: esalt_size = sizeof (office2007_t); break;
9766 case 9500: esalt_size = sizeof (office2010_t); break;
9767 case 9600: esalt_size = sizeof (office2013_t); break;
9768 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9769 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9770 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9771 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9772 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9773 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9774 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9775 case 10200: esalt_size = sizeof (cram_md5_t); break;
9776 case 10400: esalt_size = sizeof (pdf_t); break;
9777 case 10410: esalt_size = sizeof (pdf_t); break;
9778 case 10420: esalt_size = sizeof (pdf_t); break;
9779 case 10500: esalt_size = sizeof (pdf_t); break;
9780 case 10600: esalt_size = sizeof (pdf_t); break;
9781 case 10700: esalt_size = sizeof (pdf_t); break;
9782 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9783 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9784 case 11400: esalt_size = sizeof (sip_t); break;
9785 case 11600: esalt_size = sizeof (seven_zip_t); break;
9786 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9787 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9788 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9789 }
9790
9791 data.esalt_size = esalt_size;
9792
9793 /**
9794 * choose dictionary parser
9795 */
9796
9797 if (hash_type == HASH_TYPE_LM)
9798 {
9799 get_next_word_func = get_next_word_lm;
9800 }
9801 else if (opts_type & OPTS_TYPE_PT_UPPER)
9802 {
9803 get_next_word_func = get_next_word_uc;
9804 }
9805 else
9806 {
9807 get_next_word_func = get_next_word_std;
9808 }
9809
9810 /**
9811 * dictstat
9812 */
9813
9814 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9815
9816 #ifdef _POSIX
9817 size_t dictstat_nmemb = 0;
9818 #endif
9819
9820 #ifdef _WIN
9821 uint dictstat_nmemb = 0;
9822 #endif
9823
9824 char dictstat[256];
9825
9826 FILE *dictstat_fp = NULL;
9827
9828 if (keyspace == 0)
9829 {
9830 memset (dictstat, 0, sizeof (dictstat));
9831
9832 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9833
9834 dictstat_fp = fopen (dictstat, "rb");
9835
9836 if (dictstat_fp)
9837 {
9838 #ifdef _POSIX
9839 struct stat tmpstat;
9840
9841 fstat (fileno (dictstat_fp), &tmpstat);
9842 #endif
9843
9844 #ifdef _WIN
9845 struct stat64 tmpstat;
9846
9847 _fstat64 (fileno (dictstat_fp), &tmpstat);
9848 #endif
9849
9850 if (tmpstat.st_mtime < COMPTIME)
9851 {
9852 /* with v0.15 the format changed so we have to ensure user is using a good version
9853 since there is no version-header in the dictstat file */
9854
9855 fclose (dictstat_fp);
9856
9857 unlink (dictstat);
9858 }
9859 else
9860 {
9861 while (!feof (dictstat_fp))
9862 {
9863 dictstat_t d;
9864
9865 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9866
9867 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9868
9869 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9870 {
9871 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9872
9873 return -1;
9874 }
9875 }
9876
9877 fclose (dictstat_fp);
9878 }
9879 }
9880 }
9881
9882 /**
9883 * potfile
9884 */
9885
9886 char potfile[256];
9887
9888 memset (potfile, 0, sizeof (potfile));
9889
9890 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9891
9892 data.pot_fp = NULL;
9893
9894 FILE *out_fp = NULL;
9895 FILE *pot_fp = NULL;
9896
9897 if (show == 1 || left == 1)
9898 {
9899 pot_fp = fopen (potfile, "rb");
9900
9901 if (pot_fp == NULL)
9902 {
9903 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9904
9905 return (-1);
9906 }
9907
9908 if (outfile != NULL)
9909 {
9910 if ((out_fp = fopen (outfile, "ab")) == NULL)
9911 {
9912 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9913
9914 fclose (pot_fp);
9915
9916 return (-1);
9917 }
9918 }
9919 else
9920 {
9921 out_fp = stdout;
9922 }
9923 }
9924 else
9925 {
9926 if (potfile_disable == 0)
9927 {
9928 pot_fp = fopen (potfile, "ab");
9929
9930 if (pot_fp == NULL)
9931 {
9932 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9933
9934 return (-1);
9935 }
9936
9937 data.pot_fp = pot_fp;
9938 }
9939 }
9940
9941 pot_t *pot = NULL;
9942
9943 uint pot_cnt = 0;
9944 uint pot_avail = 0;
9945
9946 if (show == 1 || left == 1)
9947 {
9948 SUPPRESS_OUTPUT = 1;
9949
9950 pot_avail = count_lines (pot_fp);
9951
9952 rewind (pot_fp);
9953
9954 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
9955
9956 uint pot_hashes_avail = 0;
9957
9958 uint line_num = 0;
9959
9960 while (!feof (pot_fp))
9961 {
9962 line_num++;
9963
9964 char line_buf[BUFSIZ];
9965
9966 int line_len = fgetl (pot_fp, line_buf);
9967
9968 if (line_len == 0) continue;
9969
9970 char *plain_buf = line_buf + line_len;
9971
9972 pot_t *pot_ptr = &pot[pot_cnt];
9973
9974 hash_t *hashes_buf = &pot_ptr->hash;
9975
9976 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
9977 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
9978
9979 if (pot_cnt == pot_hashes_avail)
9980 {
9981 uint pos = 0;
9982
9983 for (pos = 0; pos < INCR_POT; pos++)
9984 {
9985 if ((pot_cnt + pos) >= pot_avail) break;
9986
9987 pot_t *tmp_pot = &pot[pot_cnt + pos];
9988
9989 hash_t *tmp_hash = &tmp_pot->hash;
9990
9991 tmp_hash->digest = mymalloc (dgst_size);
9992
9993 if (isSalted)
9994 {
9995 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
9996 }
9997
9998 if (esalt_size)
9999 {
10000 tmp_hash->esalt = mymalloc (esalt_size);
10001 }
10002
10003 pot_hashes_avail++;
10004 }
10005 }
10006
10007 int plain_len = 0;
10008
10009 int parser_status;
10010
10011 int iter = MAX_CUT_TRIES;
10012
10013 do
10014 {
10015 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10016 {
10017 if (line_buf[i] == ':')
10018 {
10019 line_len--;
10020
10021 break;
10022 }
10023 }
10024
10025 if (data.hash_mode != 2500)
10026 {
10027 parser_status = parse_func (line_buf, line_len, hashes_buf);
10028 }
10029 else
10030 {
10031 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10032
10033 if (line_len > max_salt_size)
10034 {
10035 parser_status = PARSER_GLOBAL_LENGTH;
10036 }
10037 else
10038 {
10039 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10040
10041 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10042
10043 hashes_buf->salt->salt_len = line_len;
10044
10045 parser_status = PARSER_OK;
10046 }
10047 }
10048
10049 // if NOT parsed without error, we add the ":" to the plain
10050
10051 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10052 {
10053 plain_len++;
10054 plain_buf--;
10055 }
10056
10057 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10058
10059 if (parser_status < PARSER_GLOBAL_ZERO)
10060 {
10061 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10062
10063 continue;
10064 }
10065
10066 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10067
10068 pot_ptr->plain_len = plain_len;
10069
10070 pot_cnt++;
10071 }
10072
10073 fclose (pot_fp);
10074
10075 SUPPRESS_OUTPUT = 0;
10076
10077 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10078 }
10079
10080 /**
10081 * gpu accel and loops auto adjustment
10082 */
10083
10084 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10085 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10086
10087 if (workload_profile == 1)
10088 {
10089 gpu_loops /= 8;
10090 gpu_accel /= 4;
10091
10092 if (gpu_loops == 0) gpu_loops = 8;
10093 if (gpu_accel == 0) gpu_accel = 2;
10094 }
10095 else if (workload_profile == 3)
10096 {
10097 gpu_loops *= 8;
10098 gpu_accel *= 4;
10099
10100 if (gpu_loops > 1024) gpu_loops = 1024;
10101 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10102 }
10103
10104 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10105
10106 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10107 {
10108 gpu_loops = 1024;
10109 }
10110
10111 if (hash_mode == 12500)
10112 {
10113 gpu_loops = ROUNDS_RAR3 / 16;
10114 }
10115
10116 data.gpu_accel = gpu_accel;
10117 data.gpu_loops = gpu_loops;
10118
10119 /**
10120 * word len
10121 */
10122
10123 uint pw_min = PW_MIN;
10124 uint pw_max = PW_MAX;
10125
10126 switch (hash_mode)
10127 {
10128 case 400: if (pw_max > 40) pw_max = 40;
10129 break;
10130 case 500: if (pw_max > 16) pw_max = 16;
10131 break;
10132 case 1500: if (pw_max > 8) pw_max = 8;
10133 break;
10134 case 1600: if (pw_max > 16) pw_max = 16;
10135 break;
10136 case 1800: if (pw_max > 16) pw_max = 16;
10137 break;
10138 case 2100: if (pw_max > 16) pw_max = 16;
10139 break;
10140 case 2500: if (pw_min < 8) pw_min = 8;
10141 break;
10142 case 3000: if (pw_max > 7) pw_max = 7;
10143 break;
10144 case 5200: if (pw_max > 24) pw_max = 24;
10145 break;
10146 case 5800: if (pw_max > 16) pw_max = 16;
10147 break;
10148 case 6300: if (pw_max > 16) pw_max = 16;
10149 break;
10150 case 7400: if (pw_max > 16) pw_max = 16;
10151 break;
10152 case 7900: if (pw_max > 48) pw_max = 48;
10153 break;
10154 case 8500: if (pw_max > 8) pw_max = 8;
10155 break;
10156 case 8600: if (pw_max > 16) pw_max = 16;
10157 break;
10158 case 9710: pw_min = 5;
10159 pw_max = 5;
10160 break;
10161 case 9810: pw_min = 5;
10162 pw_max = 5;
10163 break;
10164 case 10410: pw_min = 5;
10165 pw_max = 5;
10166 break;
10167 case 10300: if (pw_max < 3) pw_min = 3;
10168 if (pw_max > 40) pw_max = 40;
10169 break;
10170 case 10500: if (pw_max < 3) pw_min = 3;
10171 if (pw_max > 40) pw_max = 40;
10172 break;
10173 case 10700: if (pw_max > 16) pw_max = 16;
10174 break;
10175 case 11300: if (pw_max > 40) pw_max = 40;
10176 break;
10177 case 12500: if (pw_max > 20) pw_max = 20;
10178 break;
10179 case 12800: if (pw_max > 24) pw_max = 24;
10180 break;
10181 }
10182
10183 if (attack_exec == ATTACK_EXEC_ON_GPU)
10184 {
10185 switch (attack_kern)
10186 {
10187 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10188 break;
10189 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10190 break;
10191 }
10192 }
10193
10194 /**
10195 * charsets : keep them together for more easy maintainnce
10196 */
10197
10198 cs_t mp_sys[6];
10199 cs_t mp_usr[4];
10200
10201 memset (mp_sys, 0, sizeof (mp_sys));
10202 memset (mp_usr, 0, sizeof (mp_usr));
10203
10204 mp_setup_sys (mp_sys);
10205
10206 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10207 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10208 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10209 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10210
10211 /**
10212 * load hashes, part I: find input mode, count hashes
10213 */
10214
10215 uint hashlist_mode = 0;
10216 uint hashlist_format = HLFMT_HASHCAT;
10217
10218 uint hashes_avail = 0;
10219
10220 if (benchmark == 0)
10221 {
10222 struct stat f;
10223
10224 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10225
10226 if ((hash_mode == 2500) ||
10227 (hash_mode == 5200) ||
10228 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10229 (hash_mode == 9000))
10230 {
10231 hashlist_mode = HL_MODE_ARG;
10232
10233 char *hashfile = myargv[optind];
10234
10235 data.hashfile = hashfile;
10236
10237 logfile_top_var_string ("target", hashfile);
10238 }
10239
10240 if (hashlist_mode == HL_MODE_ARG)
10241 {
10242 if (hash_mode == 2500)
10243 {
10244 struct stat st;
10245
10246 if (stat (data.hashfile, &st) == -1)
10247 {
10248 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10249
10250 return (-1);
10251 }
10252
10253 hashes_avail = st.st_size / sizeof (hccap_t);
10254 }
10255 else
10256 {
10257 hashes_avail = 1;
10258 }
10259 }
10260 else if (hashlist_mode == HL_MODE_FILE)
10261 {
10262 char *hashfile = myargv[optind];
10263
10264 data.hashfile = hashfile;
10265
10266 logfile_top_var_string ("target", hashfile);
10267
10268 FILE *fp = NULL;
10269
10270 if ((fp = fopen (hashfile, "rb")) == NULL)
10271 {
10272 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10273
10274 return (-1);
10275 }
10276
10277 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10278
10279 hashes_avail = count_lines (fp);
10280
10281 rewind (fp);
10282
10283 if (hashes_avail == 0)
10284 {
10285 log_error ("ERROR: hashfile is empty or corrupt");
10286
10287 fclose (fp);
10288
10289 return (-1);
10290 }
10291
10292 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10293
10294 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10295 {
10296 log_error ("ERROR: remove not supported in native hashfile-format mode");
10297
10298 fclose (fp);
10299
10300 return (-1);
10301 }
10302
10303 fclose (fp);
10304 }
10305 }
10306 else
10307 {
10308 hashlist_mode = HL_MODE_ARG;
10309
10310 hashes_avail = 1;
10311 }
10312
10313 if (hash_mode == 3000) hashes_avail *= 2;
10314
10315 data.hashlist_mode = hashlist_mode;
10316 data.hashlist_format = hashlist_format;
10317
10318 logfile_top_uint (hashlist_mode);
10319 logfile_top_uint (hashlist_format);
10320
10321 /**
10322 * load hashes, part II: allocate required memory, set pointers
10323 */
10324
10325 hash_t *hashes_buf = NULL;
10326 void *digests_buf = NULL;
10327 salt_t *salts_buf = NULL;
10328 void *esalts_buf = NULL;
10329
10330 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10331
10332 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10333
10334 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10335 {
10336 uint32_t hash_pos;
10337
10338 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10339 {
10340 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10341
10342 hashes_buf[hash_pos].hash_info = hash_info;
10343
10344 if (username && (remove || show || left))
10345 {
10346 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10347 }
10348
10349 if (benchmark)
10350 {
10351 hash_info->orighash = (char *) mymalloc (256);
10352 }
10353 }
10354 }
10355
10356 if (isSalted)
10357 {
10358 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10359
10360 if (esalt_size)
10361 {
10362 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10363 }
10364 }
10365 else
10366 {
10367 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10368 }
10369
10370 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10371 {
10372 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10373
10374 if (isSalted)
10375 {
10376 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10377
10378 if (esalt_size)
10379 {
10380 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10381 }
10382 }
10383 else
10384 {
10385 hashes_buf[hash_pos].salt = &salts_buf[0];
10386 }
10387 }
10388
10389 /**
10390 * load hashes, part III: parse hashes or generate them if benchmark
10391 */
10392
10393 uint hashes_cnt = 0;
10394
10395 if (benchmark == 0)
10396 {
10397 if (keyspace == 1)
10398 {
10399 // useless to read hash file for keyspace, cheat a little bit w/ optind
10400 }
10401 else if (hashes_avail == 0)
10402 {
10403 }
10404 else if (hashlist_mode == HL_MODE_ARG)
10405 {
10406 char *input_buf = myargv[optind];
10407
10408 uint input_len = strlen (input_buf);
10409
10410 logfile_top_var_string ("target", input_buf);
10411
10412 char *hash_buf = NULL;
10413 int hash_len = 0;
10414
10415 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10416
10417 if (hash_len)
10418 {
10419 if (opts_type & OPTS_TYPE_HASH_COPY)
10420 {
10421 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10422
10423 hash_info_tmp->orighash = mystrdup (hash_buf);
10424 }
10425
10426 if (isSalted)
10427 {
10428 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10429 }
10430
10431 int parser_status = PARSER_OK;
10432
10433 if (hash_mode == 2500)
10434 {
10435 if (hash_len == 0)
10436 {
10437 log_error ("ERROR: hccap file not specified");
10438
10439 return (-1);
10440 }
10441
10442 hashlist_mode = HL_MODE_FILE;
10443
10444 data.hashlist_mode = hashlist_mode;
10445
10446 FILE *fp = fopen (hash_buf, "rb");
10447
10448 if (fp == NULL)
10449 {
10450 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10451
10452 return (-1);
10453 }
10454
10455 if (hashes_avail < 1)
10456 {
10457 log_error ("ERROR: hccap file is empty or corrupt");
10458
10459 fclose (fp);
10460
10461 return (-1);
10462 }
10463
10464 uint hccap_size = sizeof (hccap_t);
10465
10466 char in[hccap_size];
10467
10468 while (!feof (fp))
10469 {
10470 int n = fread (&in, hccap_size, 1, fp);
10471
10472 if (n != 1)
10473 {
10474 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10475
10476 break;
10477 }
10478
10479 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10480
10481 if (parser_status != PARSER_OK)
10482 {
10483 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10484
10485 continue;
10486 }
10487
10488 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10489
10490 if ((show == 1) || (left == 1))
10491 {
10492 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10493
10494 char *salt_ptr = (char *) tmp_salt->salt_buf;
10495
10496 int cur_pos = tmp_salt->salt_len;
10497 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10498
10499 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10500
10501 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10502
10503 // do the appending task
10504
10505 snprintf (salt_ptr + cur_pos,
10506 rem_len,
10507 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10508 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10509 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10510
10511
10512 // memset () the remaining part of the salt
10513
10514 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10515 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10516
10517 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10518
10519 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10520 }
10521
10522 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);
10523 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);
10524
10525 hashes_cnt++;
10526 }
10527
10528 fclose (fp);
10529 }
10530 else if (hash_mode == 3000)
10531 {
10532 if (hash_len == 32)
10533 {
10534 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10535
10536 hash_t *lm_hash_left = NULL;
10537
10538 if (parser_status == PARSER_OK)
10539 {
10540 lm_hash_left = &hashes_buf[hashes_cnt];
10541
10542 hashes_cnt++;
10543 }
10544 else
10545 {
10546 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10547 }
10548
10549
10550 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10551
10552 hash_t *lm_hash_right = NULL;
10553
10554 if (parser_status == PARSER_OK)
10555 {
10556 lm_hash_right = &hashes_buf[hashes_cnt];
10557
10558 hashes_cnt++;
10559 }
10560 else
10561 {
10562 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10563 }
10564
10565 // show / left
10566
10567 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10568 {
10569 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);
10570 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);
10571 }
10572 }
10573 else
10574 {
10575 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10576
10577 if (parser_status == PARSER_OK)
10578 {
10579 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10580 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10581 }
10582
10583 if (parser_status == PARSER_OK)
10584 {
10585 hashes_cnt++;
10586 }
10587 else
10588 {
10589 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10590 }
10591 }
10592 }
10593 else
10594 {
10595 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10596
10597 if (parser_status == PARSER_OK)
10598 {
10599 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10600 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10601 }
10602
10603 if (parser_status == PARSER_OK)
10604 {
10605 hashes_cnt++;
10606 }
10607 else
10608 {
10609 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10610 }
10611 }
10612 }
10613 }
10614 else if (hashlist_mode == HL_MODE_FILE)
10615 {
10616 char *hashfile = data.hashfile;
10617
10618 FILE *fp;
10619
10620 if ((fp = fopen (hashfile, "rb")) == NULL)
10621 {
10622 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10623
10624 return (-1);
10625 }
10626
10627 uint line_num = 0;
10628
10629 while (!feof (fp))
10630 {
10631 line_num++;
10632
10633 char line_buf[BUFSIZ];
10634
10635 int line_len = fgetl (fp, line_buf);
10636
10637 if (line_len == 0) continue;
10638
10639 char *hash_buf = NULL;
10640 int hash_len = 0;
10641
10642 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10643
10644 if (username)
10645 {
10646 char *user_buf = NULL;
10647 int user_len = 0;
10648
10649 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10650
10651 if (remove || show)
10652 {
10653 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10654
10655 *user = (user_t *) malloc (sizeof (user_t));
10656
10657 user_t *user_ptr = *user;
10658
10659 if (user_buf != NULL)
10660 {
10661 user_ptr->user_name = mystrdup (user_buf);
10662 }
10663 else
10664 {
10665 user_ptr->user_name = mystrdup ("");
10666 }
10667
10668 user_ptr->user_len = user_len;
10669 }
10670 }
10671
10672 if (opts_type & OPTS_TYPE_HASH_COPY)
10673 {
10674 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10675
10676 hash_info_tmp->orighash = mystrdup (hash_buf);
10677 }
10678
10679 if (isSalted)
10680 {
10681 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10682 }
10683
10684 if (hash_mode == 3000)
10685 {
10686 if (hash_len == 32)
10687 {
10688 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10689
10690 if (parser_status < PARSER_GLOBAL_ZERO)
10691 {
10692 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10693
10694 continue;
10695 }
10696
10697 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10698
10699 hashes_cnt++;
10700
10701 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10702
10703 if (parser_status < PARSER_GLOBAL_ZERO)
10704 {
10705 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10706
10707 continue;
10708 }
10709
10710 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10711
10712 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);
10713
10714 hashes_cnt++;
10715
10716 // show / left
10717
10718 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);
10719 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);
10720 }
10721 else
10722 {
10723 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10724
10725 if (parser_status < PARSER_GLOBAL_ZERO)
10726 {
10727 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10728
10729 continue;
10730 }
10731
10732 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);
10733
10734 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10735 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10736
10737 hashes_cnt++;
10738 }
10739 }
10740 else
10741 {
10742 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10743
10744 if (parser_status < PARSER_GLOBAL_ZERO)
10745 {
10746 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10747
10748 continue;
10749 }
10750
10751 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);
10752
10753 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10754 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10755
10756 hashes_cnt++;
10757 }
10758 }
10759
10760 fclose (fp);
10761
10762 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10763
10764 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10765 }
10766 }
10767 else
10768 {
10769 if (isSalted)
10770 {
10771 hashes_buf[0].salt->salt_len = 8;
10772
10773 // special salt handling
10774
10775 switch (hash_mode)
10776 {
10777 case 1500: hashes_buf[0].salt->salt_len = 2;
10778 break;
10779 case 1731: hashes_buf[0].salt->salt_len = 4;
10780 break;
10781 case 2410: hashes_buf[0].salt->salt_len = 4;
10782 break;
10783 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10784 break;
10785 case 3100: hashes_buf[0].salt->salt_len = 1;
10786 break;
10787 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10788 break;
10789 case 5800: hashes_buf[0].salt->salt_len = 16;
10790 break;
10791 case 6800: hashes_buf[0].salt->salt_len = 32;
10792 break;
10793 case 8400: hashes_buf[0].salt->salt_len = 40;
10794 break;
10795 case 8800: hashes_buf[0].salt->salt_len = 16;
10796 break;
10797 case 8900: hashes_buf[0].salt->salt_len = 16;
10798 hashes_buf[0].salt->scrypt_N = 1024;
10799 hashes_buf[0].salt->scrypt_r = 1;
10800 hashes_buf[0].salt->scrypt_p = 1;
10801 break;
10802 case 9100: hashes_buf[0].salt->salt_len = 16;
10803 break;
10804 case 9300: hashes_buf[0].salt->salt_len = 14;
10805 hashes_buf[0].salt->scrypt_N = 16384;
10806 hashes_buf[0].salt->scrypt_r = 1;
10807 hashes_buf[0].salt->scrypt_p = 1;
10808 break;
10809 case 9400: hashes_buf[0].salt->salt_len = 16;
10810 break;
10811 case 9500: hashes_buf[0].salt->salt_len = 16;
10812 break;
10813 case 9600: hashes_buf[0].salt->salt_len = 16;
10814 break;
10815 case 9700: hashes_buf[0].salt->salt_len = 16;
10816 break;
10817 case 9710: hashes_buf[0].salt->salt_len = 16;
10818 break;
10819 case 9720: hashes_buf[0].salt->salt_len = 16;
10820 break;
10821 case 9800: hashes_buf[0].salt->salt_len = 16;
10822 break;
10823 case 9810: hashes_buf[0].salt->salt_len = 16;
10824 break;
10825 case 9820: hashes_buf[0].salt->salt_len = 16;
10826 break;
10827 case 10300: hashes_buf[0].salt->salt_len = 12;
10828 break;
10829 case 11500: hashes_buf[0].salt->salt_len = 4;
10830 break;
10831 case 11600: hashes_buf[0].salt->salt_len = 4;
10832 break;
10833 case 12400: hashes_buf[0].salt->salt_len = 4;
10834 break;
10835 case 12500: hashes_buf[0].salt->salt_len = 8;
10836 break;
10837 case 12600: hashes_buf[0].salt->salt_len = 64;
10838 break;
10839 }
10840
10841 // special esalt handling
10842
10843 switch (hash_mode)
10844 {
10845 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10846 break;
10847 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10848 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10849 break;
10850 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10851 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10852 break;
10853 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10854 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10855 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10856 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10857 break;
10858 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10859 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10860 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10861 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10862 break;
10863 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10864 break;
10865 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10866 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10867 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10868 break;
10869 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10870 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10871 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10872 break;
10873 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10874 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10875 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10876 break;
10877 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10878 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10879 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10880 break;
10881 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10882 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10883 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10884 break;
10885 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10886 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10887 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10888 break;
10889 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10890 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10891 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10892 break;
10893 }
10894 }
10895
10896 // set hashfile
10897
10898 switch (hash_mode)
10899 {
10900 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10901 break;
10902 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10903 break;
10904 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10905 break;
10906 case 6211:
10907 case 6212:
10908 case 6213:
10909 case 6221:
10910 case 6222:
10911 case 6223:
10912 case 6231:
10913 case 6232:
10914 case 6233:
10915 case 6241:
10916 case 6242:
10917 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10918 break;
10919 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10920 break;
10921 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10922 break;
10923 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10924 break;
10925 }
10926
10927 // set default iterations
10928
10929 switch (hash_mode)
10930 {
10931 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
10932 break;
10933 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10934 break;
10935 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10936 break;
10937 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10938 break;
10939 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
10940 break;
10941 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
10942 break;
10943 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
10944 break;
10945 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
10946 break;
10947 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
10948 break;
10949 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
10950 break;
10951 case 6211:
10952 case 6212:
10953 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
10954 break;
10955 case 6221:
10956 case 6222:
10957 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10958 break;
10959 case 6231:
10960 case 6232:
10961 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10962 break;
10963 case 6241:
10964 case 6242:
10965 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10966 break;
10967 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10968 break;
10969 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
10970 break;
10971 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
10972 break;
10973 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
10974 break;
10975 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
10976 break;
10977 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
10978 break;
10979 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
10980 break;
10981 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
10982 break;
10983 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
10984 break;
10985 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
10986 break;
10987 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
10988 break;
10989 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
10990 break;
10991 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
10992 break;
10993 case 8900: hashes_buf[0].salt->salt_iter = 1;
10994 break;
10995 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
10996 break;
10997 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
10998 break;
10999 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11000 break;
11001 case 9300: hashes_buf[0].salt->salt_iter = 1;
11002 break;
11003 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11004 break;
11005 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11006 break;
11007 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11008 break;
11009 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11010 break;
11011 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11012 break;
11013 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11014 break;
11015 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11016 break;
11017 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11018 break;
11019 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11020 break;
11021 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11022 break;
11023 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11024 break;
11025 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11026 break;
11027 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11028 break;
11029 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11030 break;
11031 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11032 break;
11033 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11034 break;
11035 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11036 break;
11037 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11038 break;
11039 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11040 break;
11041 }
11042
11043 // set special tuning for benchmark-mode 1
11044
11045 if (benchmark_mode == 1)
11046 {
11047 gpu_loops *= 8;
11048 gpu_accel *= 4;
11049
11050 switch (hash_mode)
11051 {
11052 case 400: gpu_loops = ROUNDS_PHPASS;
11053 gpu_accel = 32;
11054 break;
11055 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11056 gpu_accel = 32;
11057 break;
11058 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11059 gpu_accel = 32;
11060 break;
11061 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11062 gpu_accel = 32;
11063 break;
11064 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11065 gpu_accel = 8;
11066 break;
11067 case 2100: gpu_loops = ROUNDS_DCC2;
11068 gpu_accel = 16;
11069 break;
11070 case 2500: gpu_loops = ROUNDS_WPA2;
11071 gpu_accel = 32;
11072 break;
11073 case 3200: gpu_loops = ROUNDS_BCRYPT;
11074 gpu_accel = 2;
11075 break;
11076 case 5200: gpu_loops = ROUNDS_PSAFE3;
11077 gpu_accel = 16;
11078 break;
11079 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11080 gpu_accel = 16;
11081 break;
11082 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11083 gpu_accel = 64;
11084 break;
11085 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11086 gpu_accel = 32;
11087 break;
11088 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11089 gpu_accel = 32;
11090 break;
11091 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11092 gpu_accel = 8;
11093 break;
11094 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11095 gpu_accel = 8;
11096 break;
11097 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11098 gpu_accel = 8;
11099 break;
11100 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11101 gpu_accel = 8;
11102 break;
11103 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11104 gpu_accel = 8;
11105 break;
11106 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11107 gpu_accel = 8;
11108 break;
11109 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11110 gpu_accel = 128;
11111 break;
11112 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11113 gpu_accel = 64;
11114 break;
11115 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11116 gpu_accel = 64;
11117 break;
11118 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11119 gpu_accel = 32;
11120 break;
11121 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11122 gpu_accel = 128;
11123 break;
11124 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11125 gpu_accel = 128;
11126 break;
11127 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11128 gpu_accel = 32;
11129 break;
11130 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11131 gpu_accel = 64;
11132 break;
11133 case 6800: gpu_loops = ROUNDS_LASTPASS;
11134 gpu_accel = 64;
11135 break;
11136 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11137 gpu_accel = 2;
11138 break;
11139 case 7200: gpu_loops = ROUNDS_GRUB;
11140 gpu_accel = 2;
11141 break;
11142 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11143 gpu_accel = 4;
11144 break;
11145 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11146 gpu_accel = 8;
11147 break;
11148 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11149 gpu_accel = 2;
11150 break;
11151 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11152 gpu_accel = 32;
11153 break;
11154 case 8900: gpu_loops = 1;
11155 gpu_accel = 64;
11156 break;
11157 case 9000: gpu_loops = ROUNDS_PSAFE2;
11158 gpu_accel = 16;
11159 break;
11160 case 9100: gpu_loops = ROUNDS_LOTUS8;
11161 gpu_accel = 64;
11162 break;
11163 case 9200: gpu_loops = ROUNDS_CISCO8;
11164 gpu_accel = 8;
11165 break;
11166 case 9300: gpu_loops = 1;
11167 gpu_accel = 4;
11168 break;
11169 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11170 gpu_accel = 32;
11171 break;
11172 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11173 gpu_accel = 32;
11174 break;
11175 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11176 gpu_accel = 4;
11177 break;
11178 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11179 gpu_accel = 8;
11180 break;
11181 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11182 gpu_accel = 16;
11183 break;
11184 case 10500: gpu_loops = ROUNDS_PDF14;
11185 gpu_accel = 256;
11186 break;
11187 case 10700: gpu_loops = ROUNDS_PDF17L8;
11188 gpu_accel = 8;
11189 break;
11190 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11191 gpu_accel = 8;
11192 break;
11193 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11194 gpu_accel = 2;
11195 break;
11196 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11197 gpu_accel = 4;
11198 break;
11199 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11200 gpu_accel = 8;
11201 break;
11202 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11203 gpu_accel = 8;
11204 break;
11205 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11206 gpu_accel = 8;
11207 break;
11208 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11209 gpu_accel = 8;
11210 break;
11211 case 12300: gpu_loops = ROUNDS_ORACLET;
11212 gpu_accel = 8;
11213 break;
11214 case 12500: gpu_loops = ROUNDS_RAR3;
11215 gpu_accel = 32;
11216 break;
11217 case 12700: gpu_loops = ROUNDS_MYWALLET;
11218 gpu_accel = 512;
11219 break;
11220 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11221 gpu_accel = 512;
11222 break;
11223 }
11224
11225 // some algorithm collide too fast, make that impossible
11226
11227 switch (hash_mode)
11228 {
11229 case 11500: ((uint *) digests_buf)[1] = 1;
11230 break;
11231 }
11232
11233 if (gpu_loops > 1024) gpu_loops = 1024;
11234 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11235 }
11236
11237 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11238 {
11239 gpu_loops = 1024;
11240 }
11241
11242 if (hash_mode == 12500)
11243 {
11244 gpu_loops = ROUNDS_RAR3 / 16;
11245 }
11246
11247 data.gpu_accel = gpu_accel;
11248 data.gpu_loops = gpu_loops;
11249
11250 hashes_cnt = 1;
11251 }
11252
11253 if (show == 1 || left == 1)
11254 {
11255 for (uint i = 0; i < pot_cnt; i++)
11256 {
11257 pot_t *pot_ptr = &pot[i];
11258
11259 hash_t *hashes_buf = &pot_ptr->hash;
11260
11261 local_free (hashes_buf->digest);
11262
11263 if (isSalted)
11264 {
11265 local_free (hashes_buf->salt);
11266 }
11267 }
11268
11269 local_free (pot);
11270
11271 if (data.quiet == 0) log_info_nn ("");
11272
11273 return (0);
11274 }
11275
11276 if (keyspace == 0)
11277 {
11278 if (hashes_cnt == 0)
11279 {
11280 log_error ("ERROR: No hashes loaded");
11281
11282 return (-1);
11283 }
11284 }
11285
11286 /**
11287 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11288 */
11289
11290 if (data.outfile != NULL)
11291 {
11292 if (data.hashfile != NULL)
11293 {
11294 #ifdef _POSIX
11295 struct stat tmpstat_outfile;
11296 struct stat tmpstat_hashfile;
11297 #endif
11298
11299 #ifdef _WIN
11300 struct stat64 tmpstat_outfile;
11301 struct stat64 tmpstat_hashfile;
11302 #endif
11303
11304 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11305
11306 if (tmp_outfile_fp)
11307 {
11308 #ifdef _POSIX
11309 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11310 #endif
11311
11312 #ifdef _WIN
11313 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11314 #endif
11315
11316 fclose (tmp_outfile_fp);
11317 }
11318
11319 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11320
11321 if (tmp_hashfile_fp)
11322 {
11323 #ifdef _POSIX
11324 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11325 #endif
11326
11327 #ifdef _WIN
11328 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11329 #endif
11330
11331 fclose (tmp_hashfile_fp);
11332 }
11333
11334 if (tmp_outfile_fp && tmp_outfile_fp)
11335 {
11336 tmpstat_outfile.st_mode = 0;
11337 tmpstat_outfile.st_nlink = 0;
11338 tmpstat_outfile.st_uid = 0;
11339 tmpstat_outfile.st_gid = 0;
11340 tmpstat_outfile.st_rdev = 0;
11341 tmpstat_outfile.st_atime = 0;
11342
11343 tmpstat_hashfile.st_mode = 0;
11344 tmpstat_hashfile.st_nlink = 0;
11345 tmpstat_hashfile.st_uid = 0;
11346 tmpstat_hashfile.st_gid = 0;
11347 tmpstat_hashfile.st_rdev = 0;
11348 tmpstat_hashfile.st_atime = 0;
11349
11350 #ifdef _POSIX
11351 tmpstat_outfile.st_blksize = 0;
11352 tmpstat_outfile.st_blocks = 0;
11353
11354 tmpstat_hashfile.st_blksize = 0;
11355 tmpstat_hashfile.st_blocks = 0;
11356 #endif
11357
11358 #ifdef _POSIX
11359 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11360 {
11361 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11362
11363 return (-1);
11364 }
11365 #endif
11366
11367 #ifdef _WIN
11368 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11369 {
11370 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11371
11372 return (-1);
11373 }
11374 #endif
11375 }
11376 }
11377 }
11378
11379 /**
11380 * Remove duplicates
11381 */
11382
11383 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11384
11385 if (isSalted)
11386 {
11387 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11388 }
11389 else
11390 {
11391 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11392 }
11393
11394 uint hashes_cnt_orig = hashes_cnt;
11395
11396 hashes_cnt = 1;
11397
11398 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11399 {
11400 if (isSalted)
11401 {
11402 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11403 {
11404 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11405 }
11406 }
11407 else
11408 {
11409 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11410 }
11411
11412 if (hashes_pos > hashes_cnt)
11413 {
11414 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11415 }
11416
11417 hashes_cnt++;
11418 }
11419
11420 /**
11421 * Potfile removes
11422 */
11423
11424 uint potfile_remove_cracks = 0;
11425
11426 if (potfile_disable == 0)
11427 {
11428 hash_t hash_buf;
11429
11430 hash_buf.digest = mymalloc (dgst_size);
11431 hash_buf.salt = NULL;
11432 hash_buf.esalt = NULL;
11433 hash_buf.hash_info = NULL;
11434 hash_buf.cracked = 0;
11435
11436 if (isSalted)
11437 {
11438 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11439 }
11440
11441 if (esalt_size)
11442 {
11443 hash_buf.esalt = mymalloc (esalt_size);
11444 }
11445
11446 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11447
11448 // no solution for these special hash types (for instane because they use hashfile in output etc)
11449 if ((hash_mode != 5200) &&
11450 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11451 (hash_mode != 9000))
11452 {
11453 FILE *fp = fopen (potfile, "rb");
11454
11455 if (fp != NULL)
11456 {
11457 while (!feof (fp))
11458 {
11459 char line_buf[BUFSIZ];
11460
11461 memset (line_buf, 0, BUFSIZ);
11462
11463 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11464
11465 if (ptr == NULL) break;
11466
11467 int line_len = strlen (line_buf);
11468
11469 if (line_len == 0) continue;
11470
11471 int iter = MAX_CUT_TRIES;
11472
11473 for (int i = line_len - 1; i && iter; i--, line_len--)
11474 {
11475 if (line_buf[i] != ':') continue;
11476
11477 if (isSalted)
11478 {
11479 memset (hash_buf.salt, 0, sizeof (salt_t));
11480 }
11481
11482 hash_t *found = NULL;
11483
11484 if (hash_mode == 6800)
11485 {
11486 if (i < 48) // 48 = 12 * uint in salt_buf[]
11487 {
11488 // manipulate salt_buf
11489 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11490
11491 hash_buf.salt->salt_len = i;
11492
11493 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11494 }
11495 }
11496 else if (hash_mode == 2500)
11497 {
11498 if (i < 48) // 48 = 12 * uint in salt_buf[]
11499 {
11500 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11501 // manipulate salt_buf
11502
11503 // to be safe work with a copy (because of line_len loop, i etc)
11504
11505 char line_buf_cpy[BUFSIZ];
11506 memset (line_buf_cpy, 0, BUFSIZ);
11507
11508 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11509
11510 memcpy (line_buf_cpy, line_buf, i);
11511
11512 char *mac2_pos = strrchr (line_buf_cpy, ':');
11513
11514 if (mac2_pos == NULL) continue;
11515
11516 mac2_pos[0] = 0;
11517 mac2_pos++;
11518
11519 if (strlen (mac2_pos) != 12) continue;
11520
11521 char *mac1_pos = strrchr (line_buf_cpy, ':');
11522
11523 if (mac1_pos == NULL) continue;
11524
11525 mac1_pos[0] = 0;
11526 mac1_pos++;
11527
11528 if (strlen (mac1_pos) != 12) continue;
11529
11530 uint essid_length = mac1_pos - line_buf_cpy - 1;
11531
11532 // here we need the ESSID
11533 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11534
11535 hash_buf.salt->salt_len = essid_length;
11536
11537 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11538
11539 if (found)
11540 {
11541 wpa_t *wpa = (wpa_t *) found->esalt;
11542
11543 uint pke[25];
11544
11545 char *pke_ptr = (char *) pke;
11546
11547 for (uint i = 0; i < 25; i++)
11548 {
11549 pke[i] = byte_swap_32 (wpa->pke[i]);
11550 }
11551
11552 unsigned char mac1[6];
11553 unsigned char mac2[6];
11554
11555 memcpy (mac1, pke_ptr + 23, 6);
11556 memcpy (mac2, pke_ptr + 29, 6);
11557
11558 // compare hex string(s) vs binary MAC address(es)
11559
11560 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11561 {
11562 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11563 {
11564 found = NULL;
11565 break;
11566 }
11567 }
11568
11569 // early skip ;)
11570 if (!found) continue;
11571
11572 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11573 {
11574 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11575 {
11576 found = NULL;
11577 break;
11578 }
11579 }
11580 }
11581 }
11582 }
11583 else
11584 {
11585 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11586
11587 if (parser_status == PARSER_OK)
11588 {
11589 if (isSalted)
11590 {
11591 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11592 }
11593 else
11594 {
11595 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11596 }
11597 }
11598 }
11599
11600 if (found == NULL) continue;
11601
11602 if (!found->cracked) potfile_remove_cracks++;
11603
11604 found->cracked = 1;
11605
11606 if (found) break;
11607
11608 iter--;
11609 }
11610 }
11611
11612 fclose (fp);
11613 }
11614 }
11615
11616 if (esalt_size)
11617 {
11618 local_free (hash_buf.esalt);
11619 }
11620
11621 if (isSalted)
11622 {
11623 local_free (hash_buf.salt);
11624 }
11625
11626 local_free (hash_buf.digest);
11627 }
11628
11629 /**
11630 * Now generate all the buffers required for later
11631 */
11632
11633 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11634
11635 salt_t *salts_buf_new = NULL;
11636 void *esalts_buf_new = NULL;
11637
11638 if (isSalted)
11639 {
11640 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11641
11642 if (esalt_size)
11643 {
11644 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11645 }
11646 }
11647 else
11648 {
11649 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11650 }
11651
11652 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11653
11654 uint digests_cnt = hashes_cnt;
11655 uint digests_done = 0;
11656
11657 uint size_digests = digests_cnt * dgst_size;
11658 uint size_shown = digests_cnt * sizeof (uint);
11659
11660 uint *digests_shown = (uint *) mymalloc (size_shown);
11661 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11662
11663 uint salts_cnt = 0;
11664 uint salts_done = 0;
11665
11666 hashinfo_t **hash_info = NULL;
11667
11668 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11669 {
11670 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11671
11672 if (username && (remove || show))
11673 {
11674 uint user_pos;
11675
11676 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11677 {
11678 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11679
11680 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11681 }
11682 }
11683 }
11684
11685 uint *salts_shown = (uint *) mymalloc (size_shown);
11686
11687 salt_t *salt_buf;
11688
11689 {
11690 // copied from inner loop
11691
11692 salt_buf = &salts_buf_new[salts_cnt];
11693
11694 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11695
11696 if (esalt_size)
11697 {
11698 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11699 }
11700
11701 salt_buf->digests_cnt = 0;
11702 salt_buf->digests_done = 0;
11703 salt_buf->digests_offset = 0;
11704
11705 salts_cnt++;
11706 }
11707
11708 if (hashes_buf[0].cracked == 1)
11709 {
11710 digests_shown[0] = 1;
11711
11712 digests_done++;
11713
11714 salt_buf->digests_done++;
11715 }
11716
11717 salt_buf->digests_cnt++;
11718
11719 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11720
11721 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11722 {
11723 hash_info[0] = hashes_buf[0].hash_info;
11724 }
11725
11726 // copy from inner loop
11727
11728 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11729 {
11730 if (isSalted)
11731 {
11732 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11733 {
11734 salt_buf = &salts_buf_new[salts_cnt];
11735
11736 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11737
11738 if (esalt_size)
11739 {
11740 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11741 }
11742
11743 salt_buf->digests_cnt = 0;
11744 salt_buf->digests_done = 0;
11745 salt_buf->digests_offset = hashes_pos;
11746
11747 salts_cnt++;
11748 }
11749 }
11750
11751 if (hashes_buf[hashes_pos].cracked == 1)
11752 {
11753 digests_shown[hashes_pos] = 1;
11754
11755 digests_done++;
11756
11757 salt_buf->digests_done++;
11758 }
11759
11760 salt_buf->digests_cnt++;
11761
11762 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11763
11764 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11765 {
11766 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11767 }
11768 }
11769
11770 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11771 {
11772 salt_t *salt_buf = &salts_buf_new[salt_pos];
11773
11774 if (salt_buf->digests_done == salt_buf->digests_cnt)
11775 {
11776 salts_shown[salt_pos] = 1;
11777
11778 salts_done++;
11779 }
11780
11781 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11782 }
11783
11784 local_free (digests_buf);
11785 local_free (salts_buf);
11786 local_free (esalts_buf);
11787
11788 digests_buf = digests_buf_new;
11789 salts_buf = salts_buf_new;
11790 esalts_buf = esalts_buf_new;
11791
11792 local_free (hashes_buf);
11793
11794 /**
11795 * special modification not set from parser
11796 */
11797
11798 switch (hash_mode)
11799 {
11800 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11801 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11802 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11803 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11804 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11805 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11806 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11807 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11808 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11809 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11810 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11811 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11812 }
11813
11814 if (truecrypt_keyfiles)
11815 {
11816 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11817
11818 char *keyfiles = strdup (truecrypt_keyfiles);
11819
11820 char *keyfile = strtok (keyfiles, ",");
11821
11822 do
11823 {
11824 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11825
11826 } while ((keyfile = strtok (NULL, ",")) != NULL);
11827
11828 free (keyfiles);
11829 }
11830
11831 data.digests_cnt = digests_cnt;
11832 data.digests_done = digests_done;
11833 data.digests_buf = digests_buf;
11834 data.digests_shown = digests_shown;
11835 data.digests_shown_tmp = digests_shown_tmp;
11836
11837 data.salts_cnt = salts_cnt;
11838 data.salts_done = salts_done;
11839 data.salts_buf = salts_buf;
11840 data.salts_shown = salts_shown;
11841
11842 data.esalts_buf = esalts_buf;
11843 data.hash_info = hash_info;
11844
11845 /**
11846 * Automatic Optimizers
11847 */
11848
11849 if (salts_cnt == 1)
11850 opti_type |= OPTI_TYPE_SINGLE_SALT;
11851
11852 if (digests_cnt == 1)
11853 opti_type |= OPTI_TYPE_SINGLE_HASH;
11854
11855 if (attack_exec == ATTACK_EXEC_ON_GPU)
11856 opti_type |= OPTI_TYPE_NOT_ITERATED;
11857
11858 if (attack_mode == ATTACK_MODE_BF)
11859 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11860
11861 data.opti_type = opti_type;
11862
11863 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11864 {
11865 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11866 {
11867 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11868 {
11869 if (opts_type & OPTS_TYPE_ST_ADD80)
11870 {
11871 opts_type &= ~OPTS_TYPE_ST_ADD80;
11872 opts_type |= OPTS_TYPE_PT_ADD80;
11873 }
11874
11875 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11876 {
11877 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11878 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11879 }
11880
11881 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11882 {
11883 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11884 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11885 }
11886 }
11887 }
11888 }
11889
11890 /**
11891 * Some algorithm, like descrypt, can benefit from JIT compilation
11892 */
11893
11894 uint force_jit_compilation = 0;
11895
11896 if (hash_mode == 8900)
11897 {
11898 force_jit_compilation = 8900;
11899 }
11900 else if (hash_mode == 9300)
11901 {
11902 force_jit_compilation = 8900;
11903 }
11904 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11905 {
11906 force_jit_compilation = 1500;
11907 }
11908
11909 /**
11910 * generate bitmap tables
11911 */
11912
11913 const uint bitmap_shift1 = 5;
11914 const uint bitmap_shift2 = 13;
11915
11916 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11917
11918 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11919 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11920 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11921 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11922 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11923 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11924 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11925 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11926
11927 uint bitmap_bits;
11928 uint bitmap_nums;
11929 uint bitmap_mask;
11930 uint bitmap_size;
11931
11932 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
11933 {
11934 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
11935
11936 bitmap_nums = 1 << bitmap_bits;
11937
11938 bitmap_mask = bitmap_nums - 1;
11939
11940 bitmap_size = bitmap_nums * sizeof (uint);
11941
11942 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
11943
11944 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;
11945 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;
11946
11947 break;
11948 }
11949
11950 bitmap_nums = 1 << bitmap_bits;
11951
11952 bitmap_mask = bitmap_nums - 1;
11953
11954 bitmap_size = bitmap_nums * sizeof (uint);
11955
11956 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);
11957 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);
11958
11959 /**
11960 * prepare quick rule
11961 */
11962
11963 data.rule_buf_l = rule_buf_l;
11964 data.rule_buf_r = rule_buf_r;
11965
11966 int rule_len_l = (int) strlen (rule_buf_l);
11967 int rule_len_r = (int) strlen (rule_buf_r);
11968
11969 data.rule_len_l = rule_len_l;
11970 data.rule_len_r = rule_len_r;
11971
11972 /**
11973 * load rules
11974 */
11975
11976 uint *all_gpu_rules_cnt = NULL;
11977
11978 gpu_rule_t **all_gpu_rules_buf = NULL;
11979
11980 if (rp_files_cnt)
11981 {
11982 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
11983
11984 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
11985 }
11986
11987 char rule_buf[BUFSIZ];
11988
11989 int rule_len = 0;
11990
11991 for (uint i = 0; i < rp_files_cnt; i++)
11992 {
11993 uint gpu_rules_avail = 0;
11994
11995 uint gpu_rules_cnt = 0;
11996
11997 gpu_rule_t *gpu_rules_buf = NULL;
11998
11999 char *rp_file = rp_files[i];
12000
12001 char in[BLOCK_SIZE];
12002 char out[BLOCK_SIZE];
12003
12004 FILE *fp = NULL;
12005
12006 uint rule_line = 0;
12007
12008 if ((fp = fopen (rp_file, "rb")) == NULL)
12009 {
12010 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12011
12012 return (-1);
12013 }
12014
12015 while (!feof (fp))
12016 {
12017 memset (rule_buf, 0, BUFSIZ);
12018
12019 rule_len = fgetl (fp, rule_buf);
12020
12021 rule_line++;
12022
12023 if (rule_len == 0) continue;
12024
12025 if (rule_buf[0] == '#') continue;
12026
12027 if (gpu_rules_avail == gpu_rules_cnt)
12028 {
12029 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12030
12031 gpu_rules_avail += INCR_RULES;
12032 }
12033
12034 memset (in, 0, BLOCK_SIZE);
12035 memset (out, 0, BLOCK_SIZE);
12036
12037 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12038
12039 if (result == -1)
12040 {
12041 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12042
12043 continue;
12044 }
12045
12046 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12047 {
12048 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12049
12050 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12051
12052 continue;
12053 }
12054
12055 /* its so slow
12056 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12057 {
12058 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12059
12060 continue;
12061 }
12062 */
12063
12064 gpu_rules_cnt++;
12065 }
12066
12067 fclose (fp);
12068
12069 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12070
12071 all_gpu_rules_buf[i] = gpu_rules_buf;
12072 }
12073
12074 /**
12075 * merge rules or automatic rule generator
12076 */
12077
12078 uint gpu_rules_cnt = 0;
12079
12080 gpu_rule_t *gpu_rules_buf = NULL;
12081
12082 if (attack_mode == ATTACK_MODE_STRAIGHT)
12083 {
12084 if (rp_files_cnt)
12085 {
12086 gpu_rules_cnt = 1;
12087
12088 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12089
12090 repeats[0] = gpu_rules_cnt;
12091
12092 for (uint i = 0; i < rp_files_cnt; i++)
12093 {
12094 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12095
12096 repeats[i + 1] = gpu_rules_cnt;
12097 }
12098
12099 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12100
12101 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12102
12103 for (uint i = 0; i < gpu_rules_cnt; i++)
12104 {
12105 uint out_pos = 0;
12106
12107 gpu_rule_t *out = &gpu_rules_buf[i];
12108
12109 for (uint j = 0; j < rp_files_cnt; j++)
12110 {
12111 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12112 uint in_pos;
12113
12114 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12115
12116 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12117 {
12118 if (out_pos == RULES_MAX - 1)
12119 {
12120 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12121
12122 break;
12123 }
12124
12125 out->cmds[out_pos] = in->cmds[in_pos];
12126 }
12127 }
12128 }
12129
12130 local_free (repeats);
12131 }
12132 else if (rp_gen)
12133 {
12134 uint gpu_rules_avail = 0;
12135
12136 while (gpu_rules_cnt < rp_gen)
12137 {
12138 if (gpu_rules_avail == gpu_rules_cnt)
12139 {
12140 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12141
12142 gpu_rules_avail += INCR_RULES;
12143 }
12144
12145 memset (rule_buf, 0, BLOCK_SIZE);
12146
12147 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12148
12149 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12150
12151 gpu_rules_cnt++;
12152 }
12153 }
12154 }
12155
12156 /**
12157 * generate NOP rules
12158 */
12159
12160 if (gpu_rules_cnt == 0)
12161 {
12162 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12163
12164 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12165
12166 gpu_rules_cnt++;
12167 }
12168
12169 data.gpu_rules_cnt = gpu_rules_cnt;
12170 data.gpu_rules_buf = gpu_rules_buf;
12171
12172 /**
12173 * platform
12174 */
12175
12176 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12177
12178 uint CL_platforms_cnt = 0;
12179
12180 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12181
12182 if (CL_platforms_cnt == 0)
12183 {
12184 log_error ("ERROR: No OpenCL compatible platform found");
12185
12186 return (-1);
12187 }
12188
12189 if (CL_platforms_cnt > 1)
12190 {
12191 log_error ("ERROR: Too many OpenCL compatible platforms found");
12192
12193 return (-1);
12194 }
12195
12196 cl_platform_id CL_platform = CL_platforms[0];
12197
12198 char CL_platform_vendor[INFOSZ];
12199
12200 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12201
12202 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12203
12204 uint vendor_id;
12205
12206 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12207 {
12208 vendor_id = VENDOR_ID_AMD;
12209 }
12210 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12211 {
12212 vendor_id = VENDOR_ID_NV;
12213
12214 // make sure that we do not directly control the fan for NVidia
12215
12216 gpu_temp_retain = 0;
12217 data.gpu_temp_retain = gpu_temp_retain;
12218 }
12219 else
12220 {
12221 vendor_id = VENDOR_ID_UNKNOWN;
12222 }
12223
12224 if (vendor_id == VENDOR_ID_UNKNOWN)
12225 {
12226 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12227
12228 gpu_temp_disable = 1;
12229 }
12230
12231 data.vendor_id = vendor_id;
12232
12233 /**
12234 * devices
12235 */
12236
12237 cl_device_id devices_all[DEVICES_MAX];
12238 cl_device_id devices[DEVICES_MAX];
12239
12240 uint devices_all_cnt = 0;
12241
12242 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12243
12244 int hm_adapters_all = devices_all_cnt;
12245
12246 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12247
12248 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12249
12250 if (gpu_temp_disable == 0)
12251 {
12252 if (vendor_id == VENDOR_ID_NV)
12253 {
12254 #ifdef LINUX
12255 if (hc_NVML_nvmlInit () == NVML_SUCCESS)
12256 {
12257 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12258
12259 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12260
12261 int tmp_out = 0;
12262
12263 for (int i = 0; i < tmp_in; i++)
12264 {
12265 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12266 }
12267
12268 hm_adapters_all = tmp_out;
12269
12270 for (int i = 0; i < tmp_out; i++)
12271 {
12272 unsigned int speed;
12273
12274 if (nvmlDeviceGetFanSpeed (hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12275 }
12276 }
12277 #endif
12278
12279 #ifdef WIN
12280 if (NvAPI_Initialize () == NVAPI_OK)
12281 {
12282 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12283
12284 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12285
12286 int tmp_out = 0;
12287
12288 for (int i = 0; i < tmp_in; i++)
12289 {
12290 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12291 }
12292
12293 hm_adapters_all = tmp_out;
12294
12295 for (int i = 0; i < tmp_out; i++)
12296 {
12297 NvU32 speed;
12298
12299 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12300 }
12301 }
12302 #endif
12303 }
12304
12305 if (vendor_id == VENDOR_ID_AMD)
12306 {
12307 HM_LIB hm_dll = hm_init_amd ();
12308
12309 data.hm_dll = hm_dll;
12310
12311 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12312 {
12313 // total number of adapters
12314
12315 int hm_adapters_num;
12316
12317 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12318
12319 // adapter info
12320
12321 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12322
12323 if (lpAdapterInfo == NULL) return (-1);
12324
12325 // get a list (of ids of) valid/usable adapters
12326
12327 int num_adl_adapters = 0;
12328
12329 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12330
12331 if (num_adl_adapters > 0)
12332 {
12333 hc_thread_mutex_lock (mux_adl);
12334
12335 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12336
12337 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12338
12339 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12340 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12341
12342 hc_thread_mutex_unlock (mux_adl);
12343 }
12344
12345 hm_adapters_all = num_adl_adapters;
12346
12347 myfree (valid_adl_device_list);
12348 myfree (lpAdapterInfo);
12349 }
12350 }
12351 }
12352
12353 if (hm_adapters_all == 0)
12354 {
12355 gpu_temp_disable = 1;
12356 }
12357
12358 if (gpu_temp_disable == 1)
12359 {
12360 gpu_temp_abort = 0;
12361 gpu_temp_retain = 0;
12362 }
12363
12364 /**
12365 * enable custom signal handler(s)
12366 */
12367
12368 if (benchmark == 0)
12369 {
12370 hc_signal (sigHandler_default);
12371 }
12372 else
12373 {
12374 hc_signal (sigHandler_benchmark);
12375 }
12376
12377 /**
12378 * devices mask and properties
12379 */
12380
12381 uint devices_cnt = 0;
12382
12383 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12384 {
12385 if (gpu_devicemask)
12386 {
12387 uint device_all_id_mask = 1 << device_all_id;
12388
12389 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12390 {
12391 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12392
12393 continue;
12394 }
12395 }
12396
12397 const uint device_id = devices_cnt;
12398
12399 devices[device_id] = devices_all[device_all_id];
12400
12401 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12402
12403 char device_name[INFOSZ];
12404
12405 memset (device_name, 0, sizeof (device_name));
12406
12407 cl_ulong global_mem_size;
12408 cl_uint max_clock_frequency;
12409 cl_uint max_compute_units;
12410
12411 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12412 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12413 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12414 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12415
12416 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12417 {
12418 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
12419 device_all_id + 1,
12420 device_name,
12421 (unsigned int) (global_mem_size / 1024 / 1024),
12422 (unsigned int) (max_clock_frequency),
12423 (unsigned int) max_compute_units);
12424 }
12425
12426 devices_cnt++;
12427 }
12428
12429 if (devices_cnt == 0)
12430 {
12431 log_error ("ERROR: No devices left that matches your specification.");
12432
12433 return (-1);
12434 }
12435
12436 data.devices_cnt = devices_cnt;
12437
12438 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12439 {
12440 log_info ("");
12441 }
12442
12443 /**
12444 * inform the user
12445 */
12446
12447 // gpu temp sanity check
12448
12449 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12450 {
12451 if (gpu_temp_abort < gpu_temp_retain)
12452 {
12453 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12454
12455 return (-1);
12456 }
12457 }
12458
12459 data.gpu_temp_disable = gpu_temp_disable;
12460 data.gpu_temp_abort = gpu_temp_abort;
12461 data.gpu_temp_retain = gpu_temp_retain;
12462
12463 if (data.quiet == 0)
12464 {
12465 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12466
12467 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);
12468
12469 if (attack_mode == ATTACK_MODE_STRAIGHT)
12470 {
12471 log_info ("Rules: %u", gpu_rules_cnt);
12472 }
12473
12474 if (opti_type)
12475 {
12476 log_info ("Applicable Optimizers:");
12477
12478 for (uint i = 0; i < 32; i++)
12479 {
12480 const uint opti_bit = 1 << i;
12481
12482 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12483 }
12484 }
12485
12486 /**
12487 * Watchdog and Temperature balance
12488 */
12489
12490 if (gpu_temp_abort == 0)
12491 {
12492 log_info ("Watchdog: Temperature abort trigger disabled");
12493 }
12494 else
12495 {
12496 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12497 }
12498
12499 if (gpu_temp_retain == 0)
12500 {
12501 log_info ("Watchdog: Temperature retain trigger disabled");
12502 }
12503 else
12504 {
12505 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12506 }
12507 }
12508
12509 /**
12510 * devices init
12511 */
12512
12513 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12514
12515 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12516
12517 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12518
12519 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12520
12521 data.devices_param = devices_param;
12522
12523 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12524 {
12525 hc_device_param_t *device_param = &data.devices_param[device_id];
12526
12527 cl_device_id device = devices[device_id];
12528
12529 device_param->device = device;
12530
12531 cl_uint max_compute_units = 0;
12532
12533 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12534
12535 device_param->gpu_processors = max_compute_units;
12536
12537 cl_ulong max_mem_alloc_size = 0;
12538
12539 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12540
12541 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12542
12543 char tmp[INFOSZ], t1[64];
12544
12545 memset (tmp, 0, sizeof (tmp));
12546
12547 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12548
12549 device_param->device_name = mystrdup (tmp);
12550
12551 memset (tmp, 0, sizeof (tmp));
12552
12553 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12554
12555 memset (t1, 0, sizeof (t1));
12556
12557 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12558
12559 device_param->device_version = mystrdup (t1);
12560
12561 memset (tmp, 0, sizeof (tmp));
12562
12563 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12564
12565 device_param->driver_version = mystrdup (tmp);
12566
12567 if (vendor_id == VENDOR_ID_NV)
12568 {
12569 cl_uint sm_minor = 0;
12570 cl_uint sm_major = 0;
12571
12572 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12573 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12574
12575 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12576 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12577
12578 device_param->sm_minor = sm_minor;
12579 device_param->sm_major = sm_major;
12580 }
12581
12582 /**
12583 * catalyst driver check
12584 */
12585
12586 if (vendor_id == VENDOR_ID_AMD)
12587 {
12588 int catalyst_check = (force == 1) ? 0 : 1;
12589
12590 int catalyst_warn = 0;
12591
12592 int catalyst_broken = 0;
12593
12594 if (catalyst_check == 1)
12595 {
12596 catalyst_warn = 1;
12597
12598 // v14.9 and higher
12599 if ((atoi (device_param->device_version) >= 1573)
12600 && (atoi (device_param->driver_version) >= 1573))
12601 {
12602 catalyst_warn = 0;
12603 }
12604
12605 /*
12606 // v14.9
12607 if ((strstr (device_param->device_version, "1573.") != NULL)
12608 && (strstr (device_param->driver_version, "1573.") != NULL))
12609 {
12610 catalyst_warn = 0;
12611 }
12612
12613 // v14.12 -- version overlaps with v15.4 beta
12614 if ((strstr (device_param->device_version, "1642.") != NULL)
12615 && (strstr (device_param->driver_version, "1642.") != NULL))
12616 {
12617 catalyst_broken = 1;
12618 }
12619
12620 // v15.4 (Beta, Windows only release)
12621 if ((strstr (device_param->device_version, "1642.") != NULL)
12622 && (strstr (device_param->driver_version, "1642.") != NULL))
12623 {
12624 catalyst_warn = 0;
12625 }
12626
12627 // v15.5 (Release, Linux)
12628 if ((strstr (device_param->device_version, "1702.") != NULL)
12629 && (strstr (device_param->driver_version, "1702.") != NULL))
12630 {
12631 catalyst_warn = 0;
12632 }
12633
12634 // v15.3 (Beta, Ubuntu repository release)
12635 if ((strstr (device_param->device_version, "1729.") != NULL)
12636 && (strstr (device_param->driver_version, "1729.") != NULL))
12637 {
12638 catalyst_warn = 0;
12639 }
12640 */
12641
12642 catalyst_check = 0;
12643 }
12644
12645 if (catalyst_broken == 1)
12646 {
12647 log_error ("");
12648 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12649 log_error ("It will pass over cracked hashes and does not report them as cracked");
12650 log_error ("You are STRONGLY encouraged not to use it");
12651 log_error ("You can use --force to override this but do not post error reports if you do so");
12652
12653 return (-1);
12654 }
12655
12656 if (catalyst_warn == 1)
12657 {
12658 log_error ("");
12659 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12660 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12661 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12662 #ifdef _WIN
12663 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12664 #endif
12665 log_error ("You can use --force to override this but do not post error reports if you do so");
12666
12667 return (-1);
12668 }
12669 }
12670 }
12671
12672 /*
12673 * Temporary fix:
12674 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12675 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12676 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12677 * Driver / ADL bug?
12678 */
12679
12680 if (vendor_id == VENDOR_ID_AMD)
12681 {
12682 if (powertune_enable == 1)
12683 {
12684 hc_thread_mutex_lock (mux_adl);
12685
12686 for (uint i = 0; i < devices_cnt; i++)
12687 {
12688 if (data.hm_device[i].od_version == 6)
12689 {
12690 // set powertune value only
12691
12692 int powertune_supported = 0;
12693
12694 int ADL_rc = 0;
12695
12696 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12697 {
12698 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12699
12700 return (-1);
12701 }
12702
12703 if (powertune_supported != 0)
12704 {
12705 // powertune set
12706 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12707
12708 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12709 {
12710 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12711
12712 return (-1);
12713 }
12714
12715 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12716 {
12717 log_error ("ERROR: Failed to set new ADL PowerControl values");
12718
12719 return (-1);
12720 }
12721 }
12722 }
12723 }
12724
12725 hc_thread_mutex_unlock (mux_adl);
12726 }
12727 }
12728
12729 uint gpu_blocks_all = 0;
12730
12731 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12732 {
12733 /**
12734 * host buffer
12735 */
12736
12737 hc_device_param_t *device_param = &data.devices_param[device_id];
12738
12739 /**
12740 * device properties
12741 */
12742
12743 char *device_name = device_param->device_name;
12744 char *device_version = device_param->device_version;
12745 char *driver_version = device_param->driver_version;
12746
12747 uint gpu_processors = device_param->gpu_processors;
12748
12749 /**
12750 * create context for each device
12751 */
12752
12753 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12754
12755 /**
12756 * create command-queue
12757 */
12758
12759 // not support with NV
12760 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12761
12762 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12763
12764 /**
12765 * create input buffers on device
12766 */
12767
12768 uint gpu_threads = GPU_THREADS;
12769
12770 if (hash_mode == 3200) gpu_threads = 8;
12771 if (hash_mode == 9000) gpu_threads = 8;
12772
12773 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12774 uint gpu_blocks = gpu_power;
12775
12776 device_param->gpu_threads = gpu_threads;
12777 device_param->gpu_power_user = gpu_power;
12778 device_param->gpu_blocks_user = gpu_blocks;
12779
12780 gpu_blocks_all += gpu_blocks;
12781
12782 uint size_pws = gpu_power * sizeof (pw_t);
12783
12784 uint size_tmps = 4;
12785
12786 switch (hash_mode)
12787 {
12788 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12789 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12790 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12791 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12792 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12793 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12794 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12795 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12796 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12797 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12798 case 6211:
12799 case 6212:
12800 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12801 case 6221:
12802 case 6222:
12803 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12804 case 6231:
12805 case 6232:
12806 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12807 case 6241:
12808 case 6242:
12809 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12810 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12811 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12812 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12813 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12814 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12815 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12816 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12817 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12818 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12819 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12820 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12821 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12822 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12823 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12824 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12825 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12826 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12827 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12828 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12829 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12830 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12831 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12832 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12833 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12834 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12835 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12836 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12837 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12838 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12839 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12840 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12841 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12842 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12843 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12844 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12845 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12846 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12847 };
12848
12849 uint size_hooks = 4;
12850
12851 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12852 {
12853 // insert correct hook size
12854 }
12855
12856 // we can optimize some stuff here...
12857
12858 device_param->size_pws = size_pws;
12859 device_param->size_tmps = size_tmps;
12860 device_param->size_hooks = size_hooks;
12861
12862 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12863 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12864
12865 device_param->size_root_css = size_root_css;
12866 device_param->size_markov_css = size_markov_css;
12867
12868 uint size_results = GPU_THREADS * sizeof (uint);
12869
12870 device_param->size_results = size_results;
12871
12872 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12873 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12874 uint size_plains = digests_cnt * sizeof (plain_t);
12875 uint size_salts = salts_cnt * sizeof (salt_t);
12876 uint size_esalts = salts_cnt * esalt_size;
12877
12878 device_param->size_plains = size_plains;
12879 device_param->size_digests = size_digests;
12880 device_param->size_shown = size_shown;
12881 device_param->size_salts = size_salts;
12882
12883 uint size_combs = GPU_COMBS * sizeof (comb_t);
12884 uint size_bfs = GPU_BFS * sizeof (bf_t);
12885 uint size_tm = 32 * sizeof (bs_word_t);
12886
12887 uint64_t size_scryptV = 1;
12888
12889 if ((hash_mode == 8900) || (hash_mode == 9300))
12890 {
12891 #define SHADER_PER_MP 8
12892 #define WAVEFRONTS 64
12893
12894 uint tmto_start = 2;
12895 uint tmto_stop = 1024;
12896
12897 if (scrypt_tmto)
12898 {
12899 tmto_start = 1 << scrypt_tmto;
12900 tmto_stop = tmto_start + 1;
12901 }
12902
12903 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
12904 {
12905 // todo -- make sure all salts get the new tmto value
12906
12907 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
12908
12909 size_scryptV /= tmto;
12910
12911 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12912
12913 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
12914
12915 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
12916 {
12917 data.salts_buf[salts_pos].scrypt_tmto = tmto;
12918 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12919 }
12920
12921 break;
12922 }
12923
12924 if (data.salts_buf[0].scrypt_tmto == 0)
12925 {
12926 log_error ("ERROR: can't allocate enough GPU memory");
12927
12928 return -1;
12929 }
12930
12931 if (quiet == 0) log_info ("");
12932 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
12933 }
12934
12935 /**
12936 * kernel find
12937 */
12938
12939 char build_opts[1024];
12940
12941 // we don't have sm_* on AMD but it doesn't matter
12942
12943 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
12944
12945 struct stat st;
12946
12947 char kernel_file[256];
12948
12949 memset (kernel_file, 0, sizeof (kernel_file));
12950
12951 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
12952
12953 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
12954
12955 #ifdef BINARY_KERNEL
12956 if (force_jit_compilation == 0)
12957 {
12958 if (attack_exec == ATTACK_EXEC_ON_GPU)
12959 {
12960 if (attack_kern == ATTACK_KERN_STRAIGHT)
12961 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a0.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12962 else if (attack_kern == ATTACK_KERN_COMBI)
12963 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a1.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12964 else if (attack_kern == ATTACK_KERN_BF)
12965 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a3.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12966 }
12967 else
12968 {
12969 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12970
12971 if ((hash_mode == 8900) || (hash_mode == 9300))
12972 {
12973 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto, device_name, device_version, driver_version, COMPTIME);
12974 }
12975 }
12976
12977 if (stat (kernel_file, &st) == -1)
12978 {
12979 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_file);
12980
12981 char module_file[256];
12982
12983 memset (module_file, 0, sizeof (module_file));
12984
12985 if (attack_exec == ATTACK_EXEC_ON_GPU)
12986 {
12987 if (attack_kern == ATTACK_KERN_STRAIGHT)
12988 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a0.llvmir", install_dir, (int) kern_type);
12989 else if (attack_kern == ATTACK_KERN_COMBI)
12990 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a1.llvmir", install_dir, (int) kern_type);
12991 else if (attack_kern == ATTACK_KERN_BF)
12992 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a3.llvmir", install_dir, (int) kern_type);
12993 }
12994 else
12995 {
12996 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d.llvmir", install_dir, (int) kern_type);
12997
12998 if ((hash_mode == 8900) || (hash_mode == 9300))
12999 {
13000 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.llvmir", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
13001 }
13002 }
13003
13004 load_kernel (module_file, 1, kernel_lengths, kernel_sources);
13005
13006 cl_program program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13007
13008 local_free (kernel_sources[0]);
13009
13010 hc_clBuildProgram (program, 1, &device_param->device, build_opts, NULL, NULL);
13011
13012 size_t binary_size;
13013
13014 clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13015
13016 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13017
13018 clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13019
13020 writeProgramBin (kernel_file, binary, binary_size);
13021
13022 local_free (binary);
13023
13024 stat (kernel_file, &st); // to reload filesize
13025 }
13026 }
13027 else
13028 {
13029 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13030
13031 if (stat (kernel_file, &st) == -1)
13032 {
13033 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13034
13035 return -1;
13036 }
13037 }
13038
13039 #else
13040
13041 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13042
13043 if (stat (kernel_file, &st) == -1)
13044 {
13045 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13046
13047 return -1;
13048 }
13049
13050 #endif
13051
13052 load_kernel (kernel_file, 1, kernel_lengths, kernel_sources);
13053
13054 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_file, st.st_size);
13055
13056 #ifdef BINARY_KERNEL
13057 if (force_jit_compilation == 0)
13058 {
13059 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13060 }
13061 else
13062 {
13063 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13064 }
13065 #else
13066 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13067 #endif
13068
13069 local_free (kernel_lengths);
13070
13071 local_free (kernel_sources[0]);
13072
13073 local_free (kernel_sources)
13074
13075 /**
13076 * kernel mp find
13077 */
13078
13079 if (attack_mode != ATTACK_MODE_STRAIGHT)
13080 {
13081 char kernel_mp_file[256];
13082
13083 memset (kernel_mp_file, 0, sizeof (kernel_mp_file));
13084
13085 size_t *kernel_mp_lengths = (size_t *) mymalloc (sizeof (size_t));
13086
13087 const unsigned char **kernel_mp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13088
13089 #ifdef BINARY_KERNEL
13090 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13091 {
13092 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_be.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13093 }
13094 else
13095 {
13096 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_le.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13097 }
13098
13099 if (stat (kernel_mp_file, &st) == -1)
13100 {
13101 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_mp_file);
13102
13103 char module_mp_file[256];
13104
13105 memset (module_mp_file, 0, sizeof (module_mp_file));
13106
13107 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13108 {
13109 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_be.llvmir", install_dir);
13110 }
13111 else
13112 {
13113 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_le.llvmir", install_dir);
13114 }
13115
13116 load_kernel (module_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13117
13118 cl_program program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13119
13120 local_free (kernel_mp_sources[0]);
13121
13122 hc_clBuildProgram (program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13123
13124 size_t binary_mp_size;
13125
13126 clGetProgramInfo (program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_mp_size, NULL);
13127
13128 unsigned char *binary_mp = (unsigned char *) mymalloc (binary_mp_size);
13129
13130 clGetProgramInfo (program_mp, CL_PROGRAM_BINARIES, sizeof (binary_mp), &binary_mp, NULL);
13131
13132 writeProgramBin (kernel_mp_file, binary_mp, binary_mp_size);
13133
13134 local_free (binary_mp);
13135
13136 stat (kernel_mp_file, &st); // to reload filesize
13137 }
13138
13139 #else
13140 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13141 {
13142 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_be.cl", install_dir);
13143 }
13144 else
13145 {
13146 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_le.cl", install_dir);
13147 }
13148
13149 if (stat (kernel_mp_file, &st) == -1)
13150 {
13151 log_error ("ERROR: %s: %s", kernel_mp_file, strerror (errno));
13152
13153 return -1;
13154 }
13155
13156 #endif
13157
13158 load_kernel (kernel_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13159
13160 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_mp_file, st.st_size);
13161
13162 #ifdef BINARY_KERNEL
13163 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13164 #else
13165 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_mp_sources, NULL);
13166 #endif
13167
13168 local_free (kernel_mp_lengths);
13169
13170 local_free (kernel_mp_sources[0]);
13171
13172 local_free (kernel_mp_sources);
13173 }
13174
13175 /**
13176 * kernel amp find
13177 */
13178
13179 if (attack_exec == ATTACK_EXEC_ON_GPU)
13180 {
13181 // nothing to do
13182 }
13183 else
13184 {
13185 char kernel_amp_file[256];
13186
13187 memset (kernel_amp_file, 0, sizeof (kernel_amp_file));
13188
13189 size_t *kernel_amp_lengths = (size_t *) mymalloc (sizeof (size_t));
13190
13191 const unsigned char **kernel_amp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13192
13193 #ifdef BINARY_KERNEL
13194 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/kernels/4098/amp_a%d.%s_%s_%s_%d.kernel", install_dir, attack_kern, device_name, device_version, driver_version, COMPTIME);
13195
13196 if (stat (kernel_amp_file, &st) == -1)
13197 {
13198 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_amp_file);
13199
13200 char module_amp_file[256];
13201
13202 memset (module_amp_file, 0, sizeof (module_amp_file));
13203
13204 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4098/amp_a%d.llvmir", install_dir, attack_kern);
13205
13206 load_kernel (module_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13207
13208 cl_program program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13209
13210 local_free (kernel_amp_sources[0]);
13211
13212 hc_clBuildProgram (program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13213
13214 size_t binary_amp_size;
13215
13216 clGetProgramInfo (program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_amp_size, NULL);
13217
13218 unsigned char *binary_amp = (unsigned char *) mymalloc (binary_amp_size);
13219
13220 clGetProgramInfo (program_amp, CL_PROGRAM_BINARIES, sizeof (binary_amp), &binary_amp, NULL);
13221
13222 writeProgramBin (kernel_amp_file, binary_amp, binary_amp_size);
13223
13224 local_free (binary_amp);
13225
13226 stat (kernel_amp_file, &st); // to reload filesize
13227 }
13228 #else
13229 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
13230
13231 if (stat (kernel_amp_file, &st) == -1)
13232 {
13233 log_error ("ERROR: %s: %s", kernel_amp_file, strerror (errno));
13234
13235 return -1;
13236 }
13237 #endif
13238
13239 load_kernel (kernel_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13240
13241 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_amp_file, st.st_size);
13242
13243 #ifdef BINARY_KERNEL
13244 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13245 #else
13246 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_amp_sources, NULL);
13247 #endif
13248
13249 local_free (kernel_amp_lengths);
13250
13251 local_free (kernel_amp_sources[0]);
13252
13253 local_free (kernel_amp_sources);
13254 }
13255
13256 /**
13257 * kernel compile
13258 */
13259
13260 //#ifdef BINARY_KERNEL
13261
13262 if (force_jit_compilation == 0)
13263 {
13264 // nothing to do
13265 }
13266 else if (force_jit_compilation == 1500)
13267 {
13268 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13269 }
13270 else if (force_jit_compilation == 8900)
13271 {
13272 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, data.salts_buf[0].scrypt_tmto);
13273 }
13274
13275 //#endif
13276
13277 clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13278
13279 size_t ret_val_size = 0;
13280
13281 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13282
13283 if (ret_val_size > 1)
13284 {
13285 char *build_log = (char *) malloc (ret_val_size + 1);
13286
13287 memset (build_log, 0, ret_val_size + 1);
13288
13289 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13290
13291 puts (build_log);
13292
13293 free (build_log);
13294 }
13295
13296 if (attack_mode != ATTACK_MODE_STRAIGHT)
13297 {
13298 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13299 }
13300
13301 if (attack_exec == ATTACK_EXEC_ON_GPU)
13302 {
13303 // nothing to do
13304 }
13305 else
13306 {
13307 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13308 }
13309
13310 /**
13311 * amp is not independent
13312 */
13313
13314 if (attack_exec == ATTACK_EXEC_ON_GPU)
13315 {
13316 // nothing to do
13317 }
13318 else
13319 {
13320 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13321 }
13322
13323 /**
13324 * global buffers
13325 */
13326
13327 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13328 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13329 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13330 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13331 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13332 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13333 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13334 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13335 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13336 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13337 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13338 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13339 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13340 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13341 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13342 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13343 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13344 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13345
13346 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13347 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13348 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13349 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13350 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13351 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13352 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13353 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13354 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13355 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13356 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13357
13358 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13359 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13360 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13361 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13362 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13363 run_kernel_bzero (device_param, device_param->d_result, size_results);
13364
13365 /**
13366 * special buffers
13367 */
13368
13369 if (attack_kern == ATTACK_KERN_STRAIGHT)
13370 {
13371 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13372 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13373
13374 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13375
13376 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13377 }
13378 else if (attack_kern == ATTACK_KERN_COMBI)
13379 {
13380 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13381 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13382 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13383 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13384
13385 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13386 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13387 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13388 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13389 }
13390 else if (attack_kern == ATTACK_KERN_BF)
13391 {
13392 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13393 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13394 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13395 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13396 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13397
13398 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13399 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13400 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13401 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13402 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13403 }
13404
13405 if (size_esalts)
13406 {
13407 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13408
13409 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13410 }
13411
13412 /**
13413 * main host data
13414 */
13415
13416 uint *result = (uint *) mymalloc (size_results);
13417
13418 memset (result, 0, size_results);
13419
13420 device_param->result = result;
13421
13422 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13423
13424 memset (pws_buf, 0, size_pws);
13425
13426 device_param->pws_buf = pws_buf;
13427
13428 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13429
13430 for (int i = 0; i < 64; i++)
13431 {
13432 pw_caches[i].pw_buf.pw_len = i;
13433 pw_caches[i].cnt = 0;
13434 }
13435
13436 device_param->pw_caches = pw_caches;
13437
13438 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13439
13440 device_param->combs_buf = combs_buf;
13441
13442 void *hooks_buf = mymalloc (size_hooks);
13443
13444 device_param->hooks_buf = hooks_buf;
13445
13446 device_param->pw_transpose = pw_transpose_to_hi1;
13447 device_param->pw_add = pw_add_to_hc1;
13448
13449 /**
13450 * kernel args
13451 */
13452
13453 device_param->kernel_params_buf32[21] = bitmap_mask;
13454 device_param->kernel_params_buf32[22] = bitmap_shift1;
13455 device_param->kernel_params_buf32[23] = bitmap_shift2;
13456 device_param->kernel_params_buf32[24] = 0; // salt_pos
13457 device_param->kernel_params_buf32[25] = 0; // loop_pos
13458 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13459 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13460 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13461 device_param->kernel_params_buf32[29] = 0; // digests_offset
13462 device_param->kernel_params_buf32[30] = 0; // combs_mode
13463 device_param->kernel_params_buf32[31] = 0; // gid_max
13464
13465 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13466 ? &device_param->d_pws_buf
13467 : &device_param->d_pws_amp_buf;
13468 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13469 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13470 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13471 device_param->kernel_params[ 4] = &device_param->d_tmps;
13472 device_param->kernel_params[ 5] = &device_param->d_hooks;
13473 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13474 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13475 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13476 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13477 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13478 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13479 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13480 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13481 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13482 device_param->kernel_params[15] = &device_param->d_digests_buf;
13483 device_param->kernel_params[16] = &device_param->d_digests_shown;
13484 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13485 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13486 device_param->kernel_params[19] = &device_param->d_result;
13487 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13488 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13489 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13490 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13491 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13492 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13493 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13494 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13495 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13496 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13497 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13498 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13499
13500 device_param->kernel_params_mp_buf64[3] = 0;
13501 device_param->kernel_params_mp_buf32[4] = 0;
13502 device_param->kernel_params_mp_buf32[5] = 0;
13503 device_param->kernel_params_mp_buf32[6] = 0;
13504 device_param->kernel_params_mp_buf32[7] = 0;
13505 device_param->kernel_params_mp_buf32[8] = 0;
13506
13507 device_param->kernel_params_mp[0] = NULL;
13508 device_param->kernel_params_mp[1] = NULL;
13509 device_param->kernel_params_mp[2] = NULL;
13510 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13511 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13512 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13513 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13514 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13515 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13516
13517 device_param->kernel_params_mp_l_buf64[3] = 0;
13518 device_param->kernel_params_mp_l_buf32[4] = 0;
13519 device_param->kernel_params_mp_l_buf32[5] = 0;
13520 device_param->kernel_params_mp_l_buf32[6] = 0;
13521 device_param->kernel_params_mp_l_buf32[7] = 0;
13522 device_param->kernel_params_mp_l_buf32[8] = 0;
13523 device_param->kernel_params_mp_l_buf32[9] = 0;
13524
13525 device_param->kernel_params_mp_l[0] = NULL;
13526 device_param->kernel_params_mp_l[1] = NULL;
13527 device_param->kernel_params_mp_l[2] = NULL;
13528 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13529 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13530 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13531 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13532 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13533 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13534 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13535
13536 device_param->kernel_params_mp_r_buf64[3] = 0;
13537 device_param->kernel_params_mp_r_buf32[4] = 0;
13538 device_param->kernel_params_mp_r_buf32[5] = 0;
13539 device_param->kernel_params_mp_r_buf32[6] = 0;
13540 device_param->kernel_params_mp_r_buf32[7] = 0;
13541 device_param->kernel_params_mp_r_buf32[8] = 0;
13542
13543 device_param->kernel_params_mp_r[0] = NULL;
13544 device_param->kernel_params_mp_r[1] = NULL;
13545 device_param->kernel_params_mp_r[2] = NULL;
13546 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13547 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13548 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13549 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13550 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13551 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13552
13553 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13554 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13555
13556 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13557 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13558 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13559 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13560 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13561 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13562 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13563
13564 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13565
13566 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13567 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13568
13569 /**
13570 * kernel name
13571 */
13572
13573 char kernel_name[64];
13574
13575 memset (kernel_name, 0, sizeof (kernel_name));
13576
13577 if (attack_exec == ATTACK_EXEC_ON_GPU)
13578 {
13579 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13580 {
13581 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13582
13583 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13584
13585 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13586
13587 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13588
13589 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13590
13591 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13592 }
13593 else
13594 {
13595 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13596
13597 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13598
13599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13600
13601 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13602
13603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13604
13605 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13606 }
13607
13608 if (data.attack_mode == ATTACK_MODE_BF)
13609 {
13610 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13611 {
13612 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13613
13614 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13615
13616 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13617
13618 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13619 }
13620 }
13621 }
13622 else
13623 {
13624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13625
13626 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13627
13628 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13629
13630 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13631
13632 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13633
13634 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13635
13636 if (opts_type & OPTS_TYPE_HOOK12)
13637 {
13638 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13639
13640 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13641 }
13642
13643 if (opts_type & OPTS_TYPE_HOOK23)
13644 {
13645 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13646
13647 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13648 }
13649 }
13650
13651 for (uint i = 0; i <= 20; i++)
13652 {
13653 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13654 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13655 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13656
13657 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13658 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13659 }
13660
13661 for (uint i = 21; i <= 31; i++)
13662 {
13663 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13664 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13665 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13666
13667 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13668 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13669 }
13670
13671 if (attack_mode == ATTACK_MODE_BF)
13672 {
13673 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13674 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13675
13676 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13677 {
13678 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13679
13680 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13681 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13682 }
13683 }
13684 else if (attack_mode == ATTACK_MODE_HYBRID1)
13685 {
13686 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13687 }
13688 else if (attack_mode == ATTACK_MODE_HYBRID2)
13689 {
13690 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13691 }
13692
13693 if (attack_exec == ATTACK_EXEC_ON_GPU)
13694 {
13695 // nothing to do
13696 }
13697 else
13698 {
13699 for (uint i = 0; i < 5; i++)
13700 {
13701 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13702 }
13703
13704 for (uint i = 5; i < 7; i++)
13705 {
13706 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13707 }
13708 }
13709
13710 /**
13711 * Store initial fanspeed if gpu_temp_retain is enabled
13712 */
13713
13714 int gpu_temp_retain_set = 0;
13715
13716 if (gpu_temp_disable == 0)
13717 {
13718 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13719 {
13720 hc_thread_mutex_lock (mux_adl);
13721
13722 if (data.hm_device[device_id].fan_supported == 1)
13723 {
13724 if (gpu_temp_retain_chgd == 0)
13725 {
13726 uint cur_temp = 0;
13727 uint default_temp = 0;
13728
13729 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);
13730
13731 if (ADL_rc == ADL_OK)
13732 {
13733 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13734
13735 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13736
13737 // special case with multi gpu setups: always use minimum retain
13738
13739 if (gpu_temp_retain_set == 0)
13740 {
13741 gpu_temp_retain = gpu_temp_retain_target;
13742 gpu_temp_retain_set = 1;
13743 }
13744 else
13745 {
13746 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13747 }
13748
13749 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13750 }
13751 }
13752
13753 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13754
13755 temp_retain_fanspeed_value[device_id] = fan_speed;
13756
13757 if (fan_speed == -1)
13758 {
13759 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13760
13761 temp_retain_fanspeed_value[device_id] = 0;
13762 }
13763 }
13764
13765 hc_thread_mutex_unlock (mux_adl);
13766 }
13767 }
13768
13769 /**
13770 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13771 */
13772
13773 if (powertune_enable == 1) // VENDOR_ID_AMD implied
13774 {
13775 hc_thread_mutex_lock (mux_adl);
13776
13777 if (data.hm_device[device_id].od_version == 6)
13778 {
13779 int ADL_rc;
13780
13781 // check powertune capabilities first, if not available then skip device
13782
13783 int powertune_supported = 0;
13784
13785 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13786 {
13787 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13788
13789 return (-1);
13790 }
13791
13792 if (powertune_supported != 0)
13793 {
13794 // powercontrol settings
13795
13796 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13797
13798 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
13799 {
13800 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
13801 }
13802
13803 if (ADL_rc != ADL_OK)
13804 {
13805 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13806
13807 return (-1);
13808 }
13809
13810 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13811 {
13812 log_error ("ERROR: Failed to set new ADL PowerControl values");
13813
13814 return (-1);
13815 }
13816
13817 // clocks
13818
13819 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13820
13821 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13822
13823 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)
13824 {
13825 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13826
13827 return (-1);
13828 }
13829
13830 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13831
13832 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13833
13834 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
13835 {
13836 log_error ("ERROR: Failed to get ADL device capabilities");
13837
13838 return (-1);
13839 }
13840
13841 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13842 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13843
13844 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13845 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13846
13847 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13848 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13849
13850 // warning if profile has to low max values
13851
13852 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13853 {
13854 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13855 }
13856
13857 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13858 {
13859 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13860 }
13861
13862 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13863
13864 performance_state->iNumberOfPerformanceLevels = 2;
13865
13866 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
13867 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
13868 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
13869 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
13870
13871 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)
13872 {
13873 log_info ("ERROR: Failed to set ADL performance state");
13874
13875 return (-1);
13876 }
13877
13878 local_free (performance_state);
13879 }
13880 }
13881
13882 hc_thread_mutex_unlock (mux_adl);
13883 }
13884 }
13885
13886 data.gpu_blocks_all = gpu_blocks_all;
13887
13888 if (data.quiet == 0) log_info ("");
13889
13890 /**
13891 * Inform user which algorithm is checked and at which workload setting
13892 */
13893
13894 if (benchmark == 1)
13895 {
13896 quiet = 0;
13897
13898 data.quiet = quiet;
13899
13900 char *hash_type = strhashtype (data.hash_mode); // not a bug
13901
13902 log_info ("Hashtype: %s", hash_type);
13903 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
13904 log_info ("");
13905 }
13906
13907 /**
13908 * keep track of the progress
13909 */
13910
13911 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13912 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13913 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13914
13915 /**
13916 * open filehandles
13917 */
13918
13919 #if _WIN
13920 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
13921 {
13922 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
13923
13924 return (-1);
13925 }
13926
13927 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
13928 {
13929 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
13930
13931 return (-1);
13932 }
13933
13934 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
13935 {
13936 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
13937
13938 return (-1);
13939 }
13940 #endif
13941
13942 /**
13943 * dictionary pad
13944 */
13945
13946 segment_size *= (1024 * 1024);
13947
13948 data.segment_size = segment_size;
13949
13950 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
13951
13952 wl_data->buf = (char *) mymalloc (segment_size);
13953 wl_data->avail = segment_size;
13954 wl_data->incr = segment_size;
13955 wl_data->cnt = 0;
13956 wl_data->pos = 0;
13957
13958 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
13959
13960 data.wordlist_mode = wordlist_mode;
13961
13962 cs_t *css_buf = NULL;
13963 uint css_cnt = 0;
13964 uint dictcnt = 0;
13965 uint maskcnt = 1;
13966 char **masks = NULL;
13967 char **dictfiles = NULL;
13968
13969 uint mask_from_file = 0;
13970
13971 if (attack_mode == ATTACK_MODE_STRAIGHT)
13972 {
13973 if (wordlist_mode == WL_MODE_FILE)
13974 {
13975 int wls_left = myargc - (optind + 1);
13976
13977 for (int i = 0; i < wls_left; i++)
13978 {
13979 char *l0_filename = myargv[optind + 1 + i];
13980
13981 struct stat l0_stat;
13982
13983 if (stat (l0_filename, &l0_stat) == -1)
13984 {
13985 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
13986
13987 return (-1);
13988 }
13989
13990 uint is_dir = S_ISDIR (l0_stat.st_mode);
13991
13992 if (is_dir == 0)
13993 {
13994 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
13995
13996 dictcnt++;
13997
13998 dictfiles[dictcnt - 1] = l0_filename;
13999 }
14000 else
14001 {
14002 // do not allow --keyspace w/ a directory
14003
14004 if (keyspace == 1)
14005 {
14006 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14007
14008 return (-1);
14009 }
14010
14011 char **dictionary_files = NULL;
14012
14013 dictionary_files = scan_directory (l0_filename);
14014
14015 if (dictionary_files != NULL)
14016 {
14017 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14018
14019 for (int d = 0; dictionary_files[d] != NULL; d++)
14020 {
14021 char *l1_filename = dictionary_files[d];
14022
14023 struct stat l1_stat;
14024
14025 if (stat (l1_filename, &l1_stat) == -1)
14026 {
14027 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14028
14029 return (-1);
14030 }
14031
14032 if (S_ISREG (l1_stat.st_mode))
14033 {
14034 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14035
14036 dictcnt++;
14037
14038 dictfiles[dictcnt - 1] = strdup (l1_filename);
14039 }
14040 }
14041 }
14042
14043 local_free (dictionary_files);
14044 }
14045 }
14046
14047 if (dictcnt < 1)
14048 {
14049 log_error ("ERROR: No usable dictionary file found.");
14050
14051 return (-1);
14052 }
14053 }
14054 else if (wordlist_mode == WL_MODE_STDIN)
14055 {
14056 dictcnt = 1;
14057 }
14058 }
14059 else if (attack_mode == ATTACK_MODE_COMBI)
14060 {
14061 // display
14062
14063 char *dictfile1 = myargv[optind + 1 + 0];
14064 char *dictfile2 = myargv[optind + 1 + 1];
14065
14066 // find the bigger dictionary and use as base
14067
14068 FILE *fp1;
14069 FILE *fp2;
14070
14071 struct stat tmp_stat;
14072
14073 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14074 {
14075 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14076
14077 return (-1);
14078 }
14079
14080 if (stat (dictfile1, &tmp_stat) == -1)
14081 {
14082 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14083
14084 fclose (fp1);
14085
14086 return (-1);
14087 }
14088
14089 if (S_ISDIR (tmp_stat.st_mode))
14090 {
14091 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14092
14093 fclose (fp1);
14094
14095 return (-1);
14096 }
14097
14098 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14099 {
14100 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14101
14102 fclose (fp1);
14103
14104 return (-1);
14105 }
14106
14107 if (stat (dictfile2, &tmp_stat) == -1)
14108 {
14109 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14110
14111 fclose (fp1);
14112 fclose (fp2);
14113
14114 return (-1);
14115 }
14116
14117 if (S_ISDIR (tmp_stat.st_mode))
14118 {
14119 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14120
14121 fclose (fp1);
14122 fclose (fp2);
14123
14124 return (-1);
14125 }
14126
14127 data.combs_cnt = 1;
14128
14129 data.quiet = 1;
14130
14131 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14132
14133 data.quiet = quiet;
14134
14135 if (words1_cnt == 0)
14136 {
14137 log_error ("ERROR: %s: empty file", dictfile1);
14138
14139 fclose (fp1);
14140 fclose (fp2);
14141
14142 return (-1);
14143 }
14144
14145 data.combs_cnt = 1;
14146
14147 data.quiet = 1;
14148
14149 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14150
14151 data.quiet = quiet;
14152
14153 if (words2_cnt == 0)
14154 {
14155 log_error ("ERROR: %s: empty file", dictfile2);
14156
14157 fclose (fp1);
14158 fclose (fp2);
14159
14160 return (-1);
14161 }
14162
14163 fclose (fp1);
14164 fclose (fp2);
14165
14166 data.dictfile = dictfile1;
14167 data.dictfile2 = dictfile2;
14168
14169 if (words1_cnt >= words2_cnt)
14170 {
14171 data.combs_cnt = words2_cnt;
14172 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14173
14174 dictfiles = &data.dictfile;
14175
14176 dictcnt = 1;
14177 }
14178 else
14179 {
14180 data.combs_cnt = words1_cnt;
14181 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14182
14183 dictfiles = &data.dictfile2;
14184
14185 dictcnt = 1;
14186
14187 // we also have to switch wordlist related rules!
14188
14189 char *tmpc = data.rule_buf_l;
14190
14191 data.rule_buf_l = data.rule_buf_r;
14192 data.rule_buf_r = tmpc;
14193
14194 int tmpi = data.rule_len_l;
14195
14196 data.rule_len_l = data.rule_len_r;
14197 data.rule_len_r = tmpi;
14198 }
14199 }
14200 else if (attack_mode == ATTACK_MODE_BF)
14201 {
14202 char *mask = NULL;
14203
14204 maskcnt = 0;
14205
14206 if (benchmark == 0)
14207 {
14208 mask = myargv[optind + 1];
14209
14210 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14211
14212 if ((optind + 2) <= myargc)
14213 {
14214 struct stat file_stat;
14215
14216 if (stat (mask, &file_stat) == -1)
14217 {
14218 maskcnt = 1;
14219
14220 masks[maskcnt - 1] = mystrdup (mask);
14221 }
14222 else
14223 {
14224 int wls_left = myargc - (optind + 1);
14225
14226 uint masks_avail = INCR_MASKS;
14227
14228 for (int i = 0; i < wls_left; i++)
14229 {
14230 if (i != 0)
14231 {
14232 mask = myargv[optind + 1 + i];
14233
14234 if (stat (mask, &file_stat) == -1)
14235 {
14236 log_error ("ERROR: %s: %s", mask, strerror (errno));
14237
14238 return (-1);
14239 }
14240 }
14241
14242 uint is_file = S_ISREG (file_stat.st_mode);
14243
14244 if (is_file == 1)
14245 {
14246 FILE *mask_fp;
14247
14248 if ((mask_fp = fopen (mask, "r")) == NULL)
14249 {
14250 log_error ("ERROR: %s: %s", mask, strerror (errno));
14251
14252 return (-1);
14253 }
14254
14255 char line_buf[BUFSIZ];
14256
14257 while (!feof (mask_fp))
14258 {
14259 memset (line_buf, 0, BUFSIZ);
14260
14261 int line_len = fgetl (mask_fp, line_buf);
14262
14263 if (line_len == 0) continue;
14264
14265 if (line_buf[0] == '#') continue;
14266
14267 if (masks_avail == maskcnt)
14268 {
14269 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14270
14271 masks_avail += INCR_MASKS;
14272 }
14273
14274 masks[maskcnt] = mystrdup (line_buf);
14275
14276 maskcnt++;
14277 }
14278
14279 fclose (mask_fp);
14280 }
14281 else
14282 {
14283 log_error ("ERROR: %s: unsupported file-type", mask);
14284
14285 return (-1);
14286 }
14287 }
14288
14289 mask_from_file = 1;
14290 }
14291 }
14292 else
14293 {
14294 custom_charset_1 = (char *) "?l?d?u";
14295 custom_charset_2 = (char *) "?l?d";
14296 custom_charset_3 = (char *) "?l?d*!$@_";
14297
14298 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14299 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14300 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14301
14302 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14303
14304 wordlist_mode = WL_MODE_MASK;
14305
14306 data.wordlist_mode = wordlist_mode;
14307
14308 increment = 1;
14309
14310 maskcnt = 1;
14311 }
14312 }
14313 else
14314 {
14315 /**
14316 * generate full masks and charsets
14317 */
14318
14319 masks = (char **) mymalloc (sizeof (char *));
14320
14321 switch (hash_mode)
14322 {
14323 case 1731: pw_min = 5;
14324 pw_max = 5;
14325 mask = mystrdup ("?b?b?b?b?b");
14326 break;
14327 case 12500: pw_min = 5;
14328 pw_max = 5;
14329 mask = mystrdup ("?b?b?b?b?b");
14330 break;
14331 default: pw_min = 7;
14332 pw_max = 7;
14333 mask = mystrdup ("?b?b?b?b?b?b?b");
14334 break;
14335 }
14336
14337 maskcnt = 1;
14338
14339 masks[maskcnt - 1] = mystrdup (mask);
14340
14341 wordlist_mode = WL_MODE_MASK;
14342
14343 data.wordlist_mode = wordlist_mode;
14344
14345 increment = 1;
14346 }
14347
14348 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14349
14350 if (increment)
14351 {
14352 if (increment_min > pw_min) pw_min = increment_min;
14353
14354 if (increment_max < pw_max) pw_max = increment_max;
14355 }
14356 }
14357 else if (attack_mode == ATTACK_MODE_HYBRID1)
14358 {
14359 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14360
14361 // display
14362
14363 char *mask = myargv[myargc - 1];
14364
14365 maskcnt = 0;
14366
14367 masks = (char **) mymalloc (1 * sizeof (char *));
14368
14369 // mod
14370
14371 struct stat file_stat;
14372
14373 if (stat (mask, &file_stat) == -1)
14374 {
14375 maskcnt = 1;
14376
14377 masks[maskcnt - 1] = mystrdup (mask);
14378 }
14379 else
14380 {
14381 uint is_file = S_ISREG (file_stat.st_mode);
14382
14383 if (is_file == 1)
14384 {
14385 FILE *mask_fp;
14386
14387 if ((mask_fp = fopen (mask, "r")) == NULL)
14388 {
14389 log_error ("ERROR: %s: %s", mask, strerror (errno));
14390
14391 return (-1);
14392 }
14393
14394 char line_buf[BUFSIZ];
14395
14396 uint masks_avail = 1;
14397
14398 while (!feof (mask_fp))
14399 {
14400 memset (line_buf, 0, BUFSIZ);
14401
14402 int line_len = fgetl (mask_fp, line_buf);
14403
14404 if (line_len == 0) continue;
14405
14406 if (line_buf[0] == '#') continue;
14407
14408 if (masks_avail == maskcnt)
14409 {
14410 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14411
14412 masks_avail += INCR_MASKS;
14413 }
14414
14415 masks[maskcnt] = mystrdup (line_buf);
14416
14417 maskcnt++;
14418 }
14419
14420 fclose (mask_fp);
14421
14422 mask_from_file = 1;
14423 }
14424 else
14425 {
14426 maskcnt = 1;
14427
14428 masks[maskcnt - 1] = mystrdup (mask);
14429 }
14430 }
14431
14432 // base
14433
14434 int wls_left = myargc - (optind + 2);
14435
14436 for (int i = 0; i < wls_left; i++)
14437 {
14438 char *filename = myargv[optind + 1 + i];
14439
14440 struct stat file_stat;
14441
14442 if (stat (filename, &file_stat) == -1)
14443 {
14444 log_error ("ERROR: %s: %s", filename, strerror (errno));
14445
14446 return (-1);
14447 }
14448
14449 uint is_dir = S_ISDIR (file_stat.st_mode);
14450
14451 if (is_dir == 0)
14452 {
14453 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14454
14455 dictcnt++;
14456
14457 dictfiles[dictcnt - 1] = filename;
14458 }
14459 else
14460 {
14461 // do not allow --keyspace w/ a directory
14462
14463 if (keyspace == 1)
14464 {
14465 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14466
14467 return (-1);
14468 }
14469
14470 char **dictionary_files = NULL;
14471
14472 dictionary_files = scan_directory (filename);
14473
14474 if (dictionary_files != NULL)
14475 {
14476 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14477
14478 for (int d = 0; dictionary_files[d] != NULL; d++)
14479 {
14480 char *l1_filename = dictionary_files[d];
14481
14482 struct stat l1_stat;
14483
14484 if (stat (l1_filename, &l1_stat) == -1)
14485 {
14486 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14487
14488 return (-1);
14489 }
14490
14491 if (S_ISREG (l1_stat.st_mode))
14492 {
14493 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14494
14495 dictcnt++;
14496
14497 dictfiles[dictcnt - 1] = strdup (l1_filename);
14498 }
14499 }
14500 }
14501
14502 local_free (dictionary_files);
14503 }
14504 }
14505
14506 if (dictcnt < 1)
14507 {
14508 log_error ("ERROR: No usable dictionary file found.");
14509
14510 return (-1);
14511 }
14512
14513 if (increment)
14514 {
14515 maskcnt = 0;
14516
14517 uint mask_min = increment_min; // we can't reject smaller masks here
14518 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14519
14520 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14521 {
14522 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14523
14524 if (cur_mask == NULL) break;
14525
14526 masks[maskcnt] = cur_mask;
14527
14528 maskcnt++;
14529
14530 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14531 }
14532 }
14533 }
14534 else if (attack_mode == ATTACK_MODE_HYBRID2)
14535 {
14536 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14537
14538 // display
14539
14540 char *mask = myargv[optind + 1 + 0];
14541
14542 maskcnt = 0;
14543
14544 masks = (char **) mymalloc (1 * sizeof (char *));
14545
14546 // mod
14547
14548 struct stat file_stat;
14549
14550 if (stat (mask, &file_stat) == -1)
14551 {
14552 maskcnt = 1;
14553
14554 masks[maskcnt - 1] = mystrdup (mask);
14555 }
14556 else
14557 {
14558 uint is_file = S_ISREG (file_stat.st_mode);
14559
14560 if (is_file == 1)
14561 {
14562 FILE *mask_fp;
14563
14564 if ((mask_fp = fopen (mask, "r")) == NULL)
14565 {
14566 log_error ("ERROR: %s: %s", mask, strerror (errno));
14567
14568 return (-1);
14569 }
14570
14571 char line_buf[BUFSIZ];
14572
14573 uint masks_avail = 1;
14574
14575 while (!feof (mask_fp))
14576 {
14577 memset (line_buf, 0, BUFSIZ);
14578
14579 int line_len = fgetl (mask_fp, line_buf);
14580
14581 if (line_len == 0) continue;
14582
14583 if (line_buf[0] == '#') continue;
14584
14585 if (masks_avail == maskcnt)
14586 {
14587 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14588
14589 masks_avail += INCR_MASKS;
14590 }
14591
14592 masks[maskcnt] = mystrdup (line_buf);
14593
14594 maskcnt++;
14595 }
14596
14597 fclose (mask_fp);
14598
14599 mask_from_file = 1;
14600 }
14601 else
14602 {
14603 maskcnt = 1;
14604
14605 masks[maskcnt - 1] = mystrdup (mask);
14606 }
14607 }
14608
14609 // base
14610
14611 int wls_left = myargc - (optind + 2);
14612
14613 for (int i = 0; i < wls_left; i++)
14614 {
14615 char *filename = myargv[optind + 2 + i];
14616
14617 struct stat file_stat;
14618
14619 if (stat (filename, &file_stat) == -1)
14620 {
14621 log_error ("ERROR: %s: %s", filename, strerror (errno));
14622
14623 return (-1);
14624 }
14625
14626 uint is_dir = S_ISDIR (file_stat.st_mode);
14627
14628 if (is_dir == 0)
14629 {
14630 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14631
14632 dictcnt++;
14633
14634 dictfiles[dictcnt - 1] = filename;
14635 }
14636 else
14637 {
14638 // do not allow --keyspace w/ a directory
14639
14640 if (keyspace == 1)
14641 {
14642 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14643
14644 return (-1);
14645 }
14646
14647 char **dictionary_files = NULL;
14648
14649 dictionary_files = scan_directory (filename);
14650
14651 if (dictionary_files != NULL)
14652 {
14653 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14654
14655 for (int d = 0; dictionary_files[d] != NULL; d++)
14656 {
14657 char *l1_filename = dictionary_files[d];
14658
14659 struct stat l1_stat;
14660
14661 if (stat (l1_filename, &l1_stat) == -1)
14662 {
14663 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14664
14665 return (-1);
14666 }
14667
14668 if (S_ISREG (l1_stat.st_mode))
14669 {
14670 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14671
14672 dictcnt++;
14673
14674 dictfiles[dictcnt - 1] = strdup (l1_filename);
14675 }
14676 }
14677 }
14678
14679 local_free (dictionary_files);
14680 }
14681 }
14682
14683 if (dictcnt < 1)
14684 {
14685 log_error ("ERROR: No usable dictionary file found.");
14686
14687 return (-1);
14688 }
14689
14690 if (increment)
14691 {
14692 maskcnt = 0;
14693
14694 uint mask_min = increment_min; // we can't reject smaller masks here
14695 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14696
14697 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14698 {
14699 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14700
14701 if (cur_mask == NULL) break;
14702
14703 masks[maskcnt] = cur_mask;
14704
14705 maskcnt++;
14706
14707 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14708 }
14709 }
14710 }
14711
14712 data.pw_min = pw_min;
14713 data.pw_max = pw_max;
14714
14715 /**
14716 * weak hash check
14717 */
14718
14719 if (weak_hash_threshold >= salts_cnt)
14720 {
14721 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14722
14723 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14724 {
14725 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14726 }
14727 }
14728
14729 // Display hack, guarantee that there is at least one \r before real start
14730
14731 if (data.quiet == 0) log_info_nn ("");
14732
14733 /**
14734 * status and monitor threads
14735 */
14736
14737 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14738
14739 hc_thread_t i_thread = 0;
14740
14741 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14742 {
14743 hc_thread_create (i_thread, thread_keypress, &benchmark);
14744 }
14745
14746 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14747
14748 uint ni_threads_cnt = 0;
14749
14750 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14751
14752 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14753
14754 ni_threads_cnt++;
14755
14756 /**
14757 * Outfile remove
14758 */
14759
14760 if (keyspace == 0)
14761 {
14762 if (outfile_check_timer != 0)
14763 {
14764 if (data.outfile_check_directory != NULL)
14765 {
14766 if ((hash_mode != 5200) &&
14767 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14768 (hash_mode != 9000))
14769 {
14770 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14771
14772 ni_threads_cnt++;
14773 }
14774 else
14775 {
14776 outfile_check_timer = 0;
14777 }
14778 }
14779 else
14780 {
14781 outfile_check_timer = 0;
14782 }
14783 }
14784 }
14785
14786 /**
14787 * Inform the user if we got some hashes remove because of the pot file remove feature
14788 */
14789
14790 if (data.quiet == 0)
14791 {
14792 if (potfile_remove_cracks > 0)
14793 {
14794 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14795 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14796 }
14797 }
14798
14799 data.outfile_check_timer = outfile_check_timer;
14800
14801 /**
14802 * main loop
14803 */
14804
14805 char **induction_dictionaries = NULL;
14806
14807 int induction_dictionaries_cnt = 0;
14808
14809 hcstat_table_t *root_table_buf = NULL;
14810 hcstat_table_t *markov_table_buf = NULL;
14811
14812 uint initial_restore_done = 0;
14813
14814 data.maskcnt = maskcnt;
14815
14816 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14817 {
14818 if (data.devices_status == STATUS_CRACKED) break;
14819
14820 data.devices_status = STATUS_INIT;
14821
14822 if (maskpos > rd->maskpos)
14823 {
14824 rd->dictpos = 0;
14825 }
14826
14827 rd->maskpos = maskpos;
14828 data.maskpos = maskpos;
14829
14830 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14831 {
14832 char *mask = masks[maskpos];
14833
14834 if (mask_from_file == 1)
14835 {
14836 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14837
14838 char *str_ptr;
14839 uint str_pos;
14840
14841 uint mask_offset = 0;
14842
14843 uint separator_cnt;
14844
14845 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14846 {
14847 str_ptr = strstr (mask + mask_offset, ",");
14848
14849 if (str_ptr == NULL) break;
14850
14851 str_pos = str_ptr - mask;
14852
14853 // escaped separator, i.e. "\,"
14854
14855 if (str_pos > 0)
14856 {
14857 if (mask[str_pos - 1] == '\\')
14858 {
14859 separator_cnt --;
14860
14861 mask_offset = str_pos + 1;
14862
14863 continue;
14864 }
14865 }
14866
14867 // reset the offset
14868
14869 mask_offset = 0;
14870
14871 mask[str_pos] = '\0';
14872
14873 switch (separator_cnt)
14874 {
14875 case 0:
14876 mp_reset_usr (mp_usr, 0);
14877
14878 custom_charset_1 = mask;
14879 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14880 break;
14881
14882 case 1:
14883 mp_reset_usr (mp_usr, 1);
14884
14885 custom_charset_2 = mask;
14886 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14887 break;
14888
14889 case 2:
14890 mp_reset_usr (mp_usr, 2);
14891
14892 custom_charset_3 = mask;
14893 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14894 break;
14895
14896 case 3:
14897 mp_reset_usr (mp_usr, 3);
14898
14899 custom_charset_4 = mask;
14900 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
14901 break;
14902 }
14903
14904 mask = mask + str_pos + 1;
14905 }
14906 }
14907
14908 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
14909 {
14910 if (maskpos > 0)
14911 {
14912 local_free (css_buf);
14913 local_free (data.root_css_buf);
14914 local_free (data.markov_css_buf);
14915
14916 local_free (masks[maskpos - 1]);
14917 }
14918
14919 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
14920
14921 data.mask = mask;
14922 data.css_cnt = css_cnt;
14923 data.css_buf = css_buf;
14924
14925 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
14926
14927 memset (uniq_tbls, 0, sizeof (uniq_tbls));
14928
14929 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
14930
14931 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
14932 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
14933
14934 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
14935
14936 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
14937
14938 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
14939 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
14940
14941 data.root_css_buf = root_css_buf;
14942 data.markov_css_buf = markov_css_buf;
14943
14944 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
14945
14946 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
14947
14948 local_free (root_table_buf);
14949 local_free (markov_table_buf);
14950
14951 // args
14952
14953 for (uint device_id = 0; device_id < devices_cnt; device_id++)
14954 {
14955 hc_device_param_t *device_param = &data.devices_param[device_id];
14956
14957 device_param->kernel_params_mp[0] = &device_param->d_combs;
14958 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
14959 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
14960
14961 device_param->kernel_params_mp_buf64[3] = 0;
14962 device_param->kernel_params_mp_buf32[4] = css_cnt;
14963 device_param->kernel_params_mp_buf32[5] = 0;
14964 device_param->kernel_params_mp_buf32[6] = 0;
14965 device_param->kernel_params_mp_buf32[7] = 0;
14966
14967 if (attack_mode == ATTACK_MODE_HYBRID1)
14968 {
14969 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
14970 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
14971 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
14972 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
14973 }
14974 else if (attack_mode == ATTACK_MODE_HYBRID2)
14975 {
14976 device_param->kernel_params_mp_buf32[5] = 0;
14977 device_param->kernel_params_mp_buf32[6] = 0;
14978 device_param->kernel_params_mp_buf32[7] = 0;
14979 }
14980
14981 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
14982 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
14983 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
14984
14985 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);
14986 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);
14987 }
14988 }
14989 else if (attack_mode == ATTACK_MODE_BF)
14990 {
14991 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
14992
14993 if (increment)
14994 {
14995 for (uint i = 0; i < dictcnt; i++)
14996 {
14997 local_free (dictfiles[i]);
14998 }
14999
15000 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15001 {
15002 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15003
15004 if (l1_filename == NULL) break;
15005
15006 dictcnt++;
15007
15008 dictfiles[dictcnt - 1] = l1_filename;
15009 }
15010 }
15011 else
15012 {
15013 dictcnt++;
15014
15015 dictfiles[dictcnt - 1] = mask;
15016 }
15017
15018 if (dictcnt == 0)
15019 {
15020 log_error ("ERROR: Mask is too small");
15021
15022 return (-1);
15023 }
15024 }
15025 }
15026
15027 free (induction_dictionaries);
15028
15029 // induction_dictionaries_cnt = 0; // implied
15030
15031 if (attack_mode != ATTACK_MODE_BF)
15032 {
15033 if (keyspace == 0)
15034 {
15035 induction_dictionaries = scan_directory (induction_directory);
15036
15037 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15038 }
15039 }
15040
15041 if (induction_dictionaries_cnt)
15042 {
15043 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15044 }
15045
15046 /**
15047 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15048 */
15049 if (keyspace == 1)
15050 {
15051 if ((maskcnt > 1) || (dictcnt > 1))
15052 {
15053 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15054
15055 return (-1);
15056 }
15057 }
15058
15059 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15060 {
15061 char *subid = logfile_generate_subid ();
15062
15063 data.subid = subid;
15064
15065 logfile_sub_msg ("START");
15066
15067 data.devices_status = STATUS_INIT;
15068
15069 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15070 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15071 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15072
15073 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15074
15075 data.cpt_pos = 0;
15076
15077 data.cpt_start = time (NULL);
15078
15079 data.cpt_total = 0;
15080
15081 if (data.restore == 0)
15082 {
15083 rd->words_cur = skip;
15084
15085 skip = 0;
15086
15087 data.skip = 0;
15088 }
15089
15090 data.ms_paused = 0;
15091
15092 data.words_cur = rd->words_cur;
15093
15094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15095 {
15096 hc_device_param_t *device_param = &data.devices_param[device_id];
15097
15098 device_param->speed_pos = 0;
15099
15100 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15101 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15102 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15103
15104 device_param->gpu_power = device_param->gpu_power_user;
15105 device_param->gpu_blocks = device_param->gpu_blocks_user;
15106
15107 device_param->outerloop_pos = 0;
15108 device_param->outerloop_left = 0;
15109 device_param->innerloop_pos = 0;
15110 device_param->innerloop_left = 0;
15111
15112 // some more resets:
15113
15114 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15115
15116 memset (device_param->pws_buf, 0, device_param->size_pws);
15117
15118 device_param->pw_cnt = 0;
15119 device_param->pws_cnt = 0;
15120
15121 device_param->words_off = 0;
15122 device_param->words_done = 0;
15123 }
15124
15125 data.gpu_blocks_div = 0;
15126
15127 // figure out some workload
15128
15129 if (attack_mode == ATTACK_MODE_STRAIGHT)
15130 {
15131 if (data.wordlist_mode == WL_MODE_FILE)
15132 {
15133 char *dictfile = NULL;
15134
15135 if (induction_dictionaries_cnt)
15136 {
15137 dictfile = induction_dictionaries[0];
15138 }
15139 else
15140 {
15141 dictfile = dictfiles[dictpos];
15142 }
15143
15144 data.dictfile = dictfile;
15145
15146 logfile_sub_string (dictfile);
15147
15148 for (uint i = 0; i < rp_files_cnt; i++)
15149 {
15150 logfile_sub_var_string ("rulefile", rp_files[i]);
15151 }
15152
15153 FILE *fd2 = fopen (dictfile, "rb");
15154
15155 if (fd2 == NULL)
15156 {
15157 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15158
15159 return (-1);
15160 }
15161
15162 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15163
15164 fclose (fd2);
15165
15166 if (data.words_cnt == 0)
15167 {
15168 if (data.devices_status == STATUS_CRACKED) break;
15169 if (data.devices_status == STATUS_ABORTED) break;
15170
15171 dictpos++;
15172
15173 continue;
15174 }
15175 }
15176 }
15177 else if (attack_mode == ATTACK_MODE_COMBI)
15178 {
15179 char *dictfile = data.dictfile;
15180 char *dictfile2 = data.dictfile2;
15181
15182 logfile_sub_string (dictfile);
15183 logfile_sub_string (dictfile2);
15184
15185 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15186 {
15187 FILE *fd2 = fopen (dictfile, "rb");
15188
15189 if (fd2 == NULL)
15190 {
15191 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15192
15193 return (-1);
15194 }
15195
15196 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15197
15198 fclose (fd2);
15199 }
15200 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15201 {
15202 FILE *fd2 = fopen (dictfile2, "rb");
15203
15204 if (fd2 == NULL)
15205 {
15206 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15207
15208 return (-1);
15209 }
15210
15211 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15212
15213 fclose (fd2);
15214 }
15215
15216 if (data.words_cnt == 0)
15217 {
15218 if (data.devices_status == STATUS_CRACKED) break;
15219 if (data.devices_status == STATUS_ABORTED) break;
15220
15221 dictpos++;
15222
15223 continue;
15224 }
15225 }
15226 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15227 {
15228 char *dictfile = NULL;
15229
15230 if (induction_dictionaries_cnt)
15231 {
15232 dictfile = induction_dictionaries[0];
15233 }
15234 else
15235 {
15236 dictfile = dictfiles[dictpos];
15237 }
15238
15239 data.dictfile = dictfile;
15240
15241 char *mask = data.mask;
15242
15243 logfile_sub_string (dictfile);
15244 logfile_sub_string (mask);
15245
15246 FILE *fd2 = fopen (dictfile, "rb");
15247
15248 if (fd2 == NULL)
15249 {
15250 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15251
15252 return (-1);
15253 }
15254
15255 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15256
15257 fclose (fd2);
15258
15259 if (data.words_cnt == 0)
15260 {
15261 if (data.devices_status == STATUS_CRACKED) break;
15262 if (data.devices_status == STATUS_ABORTED) break;
15263
15264 dictpos++;
15265
15266 continue;
15267 }
15268 }
15269 else if (attack_mode == ATTACK_MODE_BF)
15270 {
15271 local_free (css_buf);
15272 local_free (data.root_css_buf);
15273 local_free (data.markov_css_buf);
15274
15275 char *mask = dictfiles[dictpos];
15276
15277 logfile_sub_string (mask);
15278
15279 // base
15280
15281 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15282
15283 if (opts_type & OPTS_TYPE_PT_UNICODE)
15284 {
15285 uint css_cnt_unicode = css_cnt * 2;
15286
15287 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15288
15289 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15290 {
15291 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15292
15293 css_buf_unicode[j + 1].cs_buf[0] = 0;
15294 css_buf_unicode[j + 1].cs_len = 1;
15295 }
15296
15297 free (css_buf);
15298
15299 css_buf = css_buf_unicode;
15300 css_cnt = css_cnt_unicode;
15301 }
15302
15303 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15304
15305 uint mask_min = pw_min;
15306 uint mask_max = pw_max;
15307
15308 if (opts_type & OPTS_TYPE_PT_UNICODE)
15309 {
15310 mask_min *= 2;
15311 mask_max *= 2;
15312 }
15313
15314 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15315 {
15316 if (css_cnt < mask_min)
15317 {
15318 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15319 }
15320
15321 if (css_cnt > mask_max)
15322 {
15323 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15324 }
15325
15326 // skip to next mask
15327
15328 dictpos++;
15329
15330 rd->dictpos = dictpos;
15331
15332 logfile_sub_msg ("STOP");
15333
15334 continue;
15335 }
15336
15337 uint save_css_cnt = css_cnt;
15338
15339 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15340 {
15341 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15342 {
15343 uint salt_len = (uint) data.salts_buf[0].salt_len;
15344 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15345
15346 uint css_cnt_salt = css_cnt + salt_len;
15347
15348 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15349
15350 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15351
15352 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15353 {
15354 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15355 css_buf_salt[j].cs_len = 1;
15356 }
15357
15358 free (css_buf);
15359
15360 css_buf = css_buf_salt;
15361 css_cnt = css_cnt_salt;
15362 }
15363 }
15364
15365 data.mask = mask;
15366 data.css_cnt = css_cnt;
15367 data.css_buf = css_buf;
15368
15369 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15370
15371 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15372
15373 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15374
15375 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15376
15377 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15378 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15379
15380 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15381
15382 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15383
15384 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15385 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15386
15387 data.root_css_buf = root_css_buf;
15388 data.markov_css_buf = markov_css_buf;
15389
15390 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15391
15392 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15393
15394 local_free (root_table_buf);
15395 local_free (markov_table_buf);
15396
15397 // copy + args
15398
15399 uint css_cnt_l = css_cnt;
15400 uint css_cnt_r;
15401
15402 if (attack_exec == ATTACK_EXEC_ON_GPU)
15403 {
15404 if (save_css_cnt < 6)
15405 {
15406 css_cnt_r = 1;
15407 }
15408 else if (save_css_cnt == 6)
15409 {
15410 css_cnt_r = 2;
15411 }
15412 else
15413 {
15414 if (opts_type & OPTS_TYPE_PT_UNICODE)
15415 {
15416 if (save_css_cnt == 8 || save_css_cnt == 10)
15417 {
15418 css_cnt_r = 2;
15419 }
15420 else
15421 {
15422 css_cnt_r = 4;
15423 }
15424 }
15425 else
15426 {
15427 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15428 {
15429 css_cnt_r = 3;
15430 }
15431 else
15432 {
15433 css_cnt_r = 4;
15434 }
15435 }
15436 }
15437 }
15438 else
15439 {
15440 css_cnt_r = 1;
15441
15442 /* unfinished code?
15443 int sum = css_buf[css_cnt_r - 1].cs_len;
15444
15445 for (uint i = 1; i < 4 && i < css_cnt; i++)
15446 {
15447 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15448
15449 css_cnt_r++;
15450
15451 sum *= css_buf[css_cnt_r - 1].cs_len;
15452 }
15453 */
15454 }
15455
15456 css_cnt_l -= css_cnt_r;
15457
15458 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15459
15460 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15461 {
15462 hc_device_param_t *device_param = &data.devices_param[device_id];
15463
15464 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15465 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15466 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15467
15468 device_param->kernel_params_mp_l_buf64[3] = 0;
15469 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15470 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15471 device_param->kernel_params_mp_l_buf32[6] = 0;
15472 device_param->kernel_params_mp_l_buf32[7] = 0;
15473 device_param->kernel_params_mp_l_buf32[8] = 0;
15474
15475 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15476 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15477 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15478 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15479
15480 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15481 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15482 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15483
15484 device_param->kernel_params_mp_r_buf64[3] = 0;
15485 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15486 device_param->kernel_params_mp_r_buf32[5] = 0;
15487 device_param->kernel_params_mp_r_buf32[6] = 0;
15488 device_param->kernel_params_mp_r_buf32[7] = 0;
15489
15490 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]);
15491 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]);
15492 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]);
15493
15494 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]);
15495 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]);
15496 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]);
15497
15498 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);
15499 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);
15500 }
15501 }
15502
15503 uint64_t words_base = data.words_cnt;
15504
15505 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15506 {
15507 if (data.gpu_rules_cnt)
15508 {
15509 words_base /= data.gpu_rules_cnt;
15510 }
15511 }
15512 else if (data.attack_kern == ATTACK_KERN_COMBI)
15513 {
15514 if (data.combs_cnt)
15515 {
15516 words_base /= data.combs_cnt;
15517 }
15518 }
15519 else if (data.attack_kern == ATTACK_KERN_BF)
15520 {
15521 if (data.bfs_cnt)
15522 {
15523 words_base /= data.bfs_cnt;
15524 }
15525 }
15526
15527 data.words_base = words_base;
15528
15529 if (keyspace == 1)
15530 {
15531 log_info ("%llu", (unsigned long long int) words_base);
15532
15533 return (0);
15534 }
15535
15536 if (data.words_cur > data.words_base)
15537 {
15538 log_error ("ERROR: restore value greater keyspace");
15539
15540 return (-1);
15541 }
15542
15543 if (data.words_cur)
15544 {
15545 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15546 {
15547 for (uint i = 0; i < data.salts_cnt; i++)
15548 {
15549 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15550 }
15551 }
15552 else if (data.attack_kern == ATTACK_KERN_COMBI)
15553 {
15554 for (uint i = 0; i < data.salts_cnt; i++)
15555 {
15556 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15557 }
15558 }
15559 else if (data.attack_kern == ATTACK_KERN_BF)
15560 {
15561 for (uint i = 0; i < data.salts_cnt; i++)
15562 {
15563 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15564 }
15565 }
15566 }
15567
15568 /*
15569 * Inform user about possible slow speeds
15570 */
15571
15572 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15573 {
15574 if (data.words_base < gpu_blocks_all)
15575 {
15576 if (quiet == 0)
15577 {
15578 log_info ("");
15579 log_info ("ATTENTION!");
15580 log_info (" The wordlist or mask you are using is too small.");
15581 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15582 log_info (" The cracking speed will drop.");
15583 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15584 log_info ("");
15585 }
15586 }
15587 }
15588
15589 /*
15590 * Update loopback file
15591 */
15592
15593 if (loopback == 1)
15594 {
15595 time_t now;
15596
15597 time (&now);
15598
15599 uint random_num = get_random_num (0, 9999);
15600
15601 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15602
15603 data.loopback_file = loopback_file;
15604 }
15605
15606 /*
15607 * Update dictionary statistic
15608 */
15609
15610 if (keyspace == 0)
15611 {
15612 dictstat_fp = fopen (dictstat, "wb");
15613
15614 if (dictstat_fp)
15615 {
15616 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15617
15618 fclose (dictstat_fp);
15619 }
15620 }
15621
15622 data.devices_status = STATUS_RUNNING;
15623
15624 if (initial_restore_done == 0)
15625 {
15626 if (data.restore_disable == 0) cycle_restore ();
15627
15628 initial_restore_done = 1;
15629 }
15630
15631 hc_timer_set (&data.timer_running);
15632
15633 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15634 {
15635 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15636 {
15637 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15638 if (quiet == 0) fflush (stdout);
15639 }
15640 }
15641 else if (wordlist_mode == WL_MODE_STDIN)
15642 {
15643 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15644 if (data.quiet == 0) log_info ("");
15645 }
15646
15647 time_t runtime_start;
15648
15649 time (&runtime_start);
15650
15651 data.runtime_start = runtime_start;
15652
15653 /**
15654 * create cracker threads
15655 */
15656
15657 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15658
15659 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15660 {
15661 hc_device_param_t *device_param = &devices_param[device_id];
15662
15663 device_param->device_id = device_id;
15664
15665 if (wordlist_mode == WL_MODE_STDIN)
15666 {
15667 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15668 }
15669 else
15670 {
15671 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15672 }
15673 }
15674
15675 // wait for crack threads to exit
15676
15677 hc_thread_wait (devices_cnt, c_threads);
15678
15679 local_free (c_threads);
15680
15681 data.restore = 0;
15682
15683 // finalize task
15684
15685 logfile_sub_var_uint ("status-after-work", data.devices_status);
15686
15687 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15688
15689 if (data.devices_status == STATUS_CRACKED) break;
15690 if (data.devices_status == STATUS_ABORTED) break;
15691
15692 if (data.devices_status == STATUS_BYPASS)
15693 {
15694 data.devices_status = STATUS_RUNNING;
15695 }
15696
15697 if (induction_dictionaries_cnt)
15698 {
15699 unlink (induction_dictionaries[0]);
15700 }
15701
15702 free (induction_dictionaries);
15703
15704 if (attack_mode != ATTACK_MODE_BF)
15705 {
15706 induction_dictionaries = scan_directory (induction_directory);
15707
15708 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15709 }
15710
15711 if (benchmark == 0)
15712 {
15713 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15714 {
15715 if (quiet == 0) clear_prompt ();
15716
15717 if (quiet == 0) log_info ("");
15718
15719 if (status == 1)
15720 {
15721 status_display ();
15722 }
15723 else
15724 {
15725 if (quiet == 0) status_display ();
15726 }
15727
15728 if (quiet == 0) log_info ("");
15729 }
15730 }
15731
15732 if (attack_mode == ATTACK_MODE_BF)
15733 {
15734 dictpos++;
15735
15736 rd->dictpos = dictpos;
15737 }
15738 else
15739 {
15740 if (induction_dictionaries_cnt)
15741 {
15742 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15743 }
15744 else
15745 {
15746 dictpos++;
15747
15748 rd->dictpos = dictpos;
15749 }
15750 }
15751
15752 time_t runtime_stop;
15753
15754 time (&runtime_stop);
15755
15756 data.runtime_stop = runtime_stop;
15757
15758 logfile_sub_uint (runtime_start);
15759 logfile_sub_uint (runtime_stop);
15760
15761 logfile_sub_msg ("STOP");
15762
15763 global_free (subid);
15764 }
15765
15766 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15767
15768 if (data.devices_status == STATUS_CRACKED) break;
15769 if (data.devices_status == STATUS_ABORTED) break;
15770 if (data.devices_status == STATUS_QUIT) break;
15771
15772 if (data.devices_status == STATUS_BYPASS)
15773 {
15774 data.devices_status = STATUS_RUNNING;
15775 }
15776 }
15777
15778 // 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
15779
15780 if (attack_mode == ATTACK_MODE_STRAIGHT)
15781 {
15782 if (data.wordlist_mode == WL_MODE_FILE)
15783 {
15784 if (data.dictfile == NULL)
15785 {
15786 if (dictfiles != NULL)
15787 {
15788 data.dictfile = dictfiles[0];
15789
15790 hc_timer_set (&data.timer_running);
15791 }
15792 }
15793 }
15794 }
15795 // NOTE: combi is okay because it is already set beforehand
15796 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15797 {
15798 if (data.dictfile == NULL)
15799 {
15800 if (dictfiles != NULL)
15801 {
15802 hc_timer_set (&data.timer_running);
15803
15804 data.dictfile = dictfiles[0];
15805 }
15806 }
15807 }
15808 else if (attack_mode == ATTACK_MODE_BF)
15809 {
15810 if (data.mask == NULL)
15811 {
15812 hc_timer_set (&data.timer_running);
15813
15814 data.mask = masks[0];
15815 }
15816 }
15817
15818 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15819 {
15820 data.devices_status = STATUS_EXHAUSTED;
15821 }
15822
15823 // if cracked / aborted remove last induction dictionary
15824
15825 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15826 {
15827 struct stat induct_stat;
15828
15829 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15830 {
15831 unlink (induction_dictionaries[file_pos]);
15832 }
15833 }
15834
15835 // wait for non-interactive threads
15836
15837 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15838 {
15839 hc_thread_wait (1, &ni_threads[thread_idx]);
15840 }
15841
15842 local_free (ni_threads);
15843
15844 // wait for interactive threads
15845
15846 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15847 {
15848 hc_thread_wait (1, &i_thread);
15849 }
15850
15851 // we dont need restore file anymore
15852 if (data.restore_disable == 0)
15853 {
15854 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15855 {
15856 unlink (eff_restore_file);
15857 unlink (new_restore_file);
15858 }
15859 else
15860 {
15861 cycle_restore ();
15862 }
15863 }
15864
15865 // finally save left hashes
15866
15867 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
15868 {
15869 save_hash ();
15870 }
15871
15872 /**
15873 * Clean up
15874 */
15875
15876 if (benchmark == 1)
15877 {
15878 status_benchmark ();
15879
15880 log_info ("");
15881 }
15882 else
15883 {
15884 if (quiet == 0) clear_prompt ();
15885
15886 if (quiet == 0) log_info ("");
15887
15888 if (status == 1)
15889 {
15890 status_display ();
15891 }
15892 else
15893 {
15894 if (quiet == 0) status_display ();
15895 }
15896
15897 if (quiet == 0) log_info ("");
15898 }
15899
15900 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15901 {
15902 hc_device_param_t *device_param = &data.devices_param[device_id];
15903
15904 local_free (device_param->result);
15905
15906 local_free (device_param->pw_caches);
15907
15908 local_free (device_param->combs_buf);
15909
15910 local_free (device_param->hooks_buf);
15911
15912 local_free (device_param->device_name);
15913
15914 local_free (device_param->device_version);
15915
15916 local_free (device_param->driver_version);
15917
15918 if (device_param->pws_buf) myfree (device_param->pws_buf);
15919 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
15920 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
15921 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
15922 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
15923 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
15924 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
15925 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
15926 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
15927 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
15928 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
15929 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
15930 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
15931 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
15932 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
15933 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
15934 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
15935 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
15936 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
15937 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
15938 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
15939 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
15940 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
15941 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
15942 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
15943 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
15944 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
15945 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
15946
15947 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
15948 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
15949 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
15950 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
15951 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
15952 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
15953 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
15954 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
15955
15956 if (device_param->program) hc_clReleaseProgram (device_param->program);
15957 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
15958 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
15959 if (device_param->context) hc_clReleaseContext (device_param->context);
15960 }
15961
15962 // reset default fan speed
15963
15964 if (gpu_temp_disable == 0)
15965 {
15966 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
15967 {
15968 hc_thread_mutex_lock (mux_adl);
15969
15970 for (uint i = 0; i < data.devices_cnt; i++)
15971 {
15972 if (data.hm_device[i].fan_supported == 1)
15973 {
15974 int fanspeed = temp_retain_fanspeed_value[i];
15975
15976 if (fanspeed == -1) continue;
15977
15978 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
15979
15980 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
15981 }
15982 }
15983
15984 hc_thread_mutex_unlock (mux_adl);
15985 }
15986 }
15987
15988 // reset power tuning
15989
15990 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
15991 {
15992 hc_thread_mutex_lock (mux_adl);
15993
15994 for (uint i = 0; i < data.devices_cnt; i++)
15995 {
15996 if (data.hm_device[i].od_version == 6)
15997 {
15998 // check powertune capabilities first, if not available then skip device
15999
16000 int powertune_supported = 0;
16001
16002 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16003 {
16004 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16005
16006 return (-1);
16007 }
16008
16009 if (powertune_supported != 0)
16010 {
16011 // powercontrol settings
16012
16013 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16014 {
16015 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16016
16017 return (-1);
16018 }
16019
16020 // clocks
16021
16022 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16023
16024 performance_state->iNumberOfPerformanceLevels = 2;
16025
16026 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16027 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16028 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16029 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16030
16031 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16032 {
16033 log_info ("ERROR: Failed to restore ADL performance state");
16034
16035 return (-1);
16036 }
16037
16038 local_free (performance_state);
16039 }
16040 }
16041 }
16042
16043 hc_thread_mutex_unlock (mux_adl);
16044 }
16045
16046 if (gpu_temp_disable == 0)
16047 {
16048 if (vendor_id == VENDOR_ID_NV)
16049 {
16050 #ifdef LINUX
16051 hc_NVML_nvmlShutdown ();
16052 #endif
16053
16054 #ifdef WIN
16055 NvAPI_Unload ();
16056 #endif
16057 }
16058
16059 if (vendor_id == VENDOR_ID_AMD)
16060 {
16061 hc_ADL_Main_Control_Destroy (data.hm_dll);
16062
16063 hm_close_amd (data.hm_dll);
16064 }
16065 }
16066
16067 // free memory
16068
16069 local_free (masks);
16070
16071 local_free (dictstat_base);
16072
16073 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16074 {
16075 pot_t *pot_ptr = &pot[pot_pos];
16076
16077 hash_t *hash = &pot_ptr->hash;
16078
16079 local_free (hash->digest);
16080
16081 if (isSalted)
16082 {
16083 local_free (hash->salt);
16084 }
16085 }
16086
16087 local_free (pot);
16088
16089 local_free (all_gpu_rules_cnt);
16090 local_free (all_gpu_rules_buf);
16091
16092 local_free (wl_data->buf);
16093 local_free (wl_data);
16094
16095 local_free (bitmap_s1_a);
16096 local_free (bitmap_s1_b);
16097 local_free (bitmap_s1_c);
16098 local_free (bitmap_s1_d);
16099 local_free (bitmap_s2_a);
16100 local_free (bitmap_s2_b);
16101 local_free (bitmap_s2_c);
16102 local_free (bitmap_s2_d);
16103
16104 local_free (temp_retain_fanspeed_value);
16105 local_free (od_clock_mem_status);
16106 local_free (od_power_control_status);
16107
16108 global_free (devices_param);
16109
16110 global_free (gpu_rules_buf);
16111
16112 global_free (root_css_buf);
16113 global_free (markov_css_buf);
16114
16115 global_free (digests_buf);
16116 global_free (digests_shown);
16117 global_free (digests_shown_tmp);
16118
16119 global_free (salts_buf);
16120 global_free (salts_shown);
16121
16122 global_free (esalts_buf);
16123
16124 global_free (words_progress_done);
16125 global_free (words_progress_rejected);
16126 global_free (words_progress_restored);
16127
16128 if (pot_fp) fclose (pot_fp);
16129
16130 if (data.devices_status == STATUS_QUIT) break;
16131 }
16132
16133 // destroy others mutex
16134
16135 hc_thread_mutex_delete (mux_dispatcher);
16136 hc_thread_mutex_delete (mux_counter);
16137 hc_thread_mutex_delete (mux_display);
16138 hc_thread_mutex_delete (mux_adl);
16139
16140 // free memory
16141
16142 local_free (eff_restore_file);
16143 local_free (new_restore_file);
16144
16145 local_free (rd);
16146
16147 // loopback
16148
16149 local_free (loopback_file);
16150
16151 if (loopback == 1) unlink (loopback_file);
16152
16153 // induction directory
16154
16155 if (induction_dir == NULL)
16156 {
16157 if (attack_mode != ATTACK_MODE_BF)
16158 {
16159 if (rmdir (induction_directory) == -1)
16160 {
16161 if (errno == ENOENT)
16162 {
16163 // good, we can ignore
16164 }
16165 else if (errno == ENOTEMPTY)
16166 {
16167 // good, we can ignore
16168 }
16169 else
16170 {
16171 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16172
16173 return (-1);
16174 }
16175 }
16176
16177 local_free (induction_directory);
16178 }
16179 }
16180
16181 // outfile-check directory
16182
16183 if (outfile_check_dir == NULL)
16184 {
16185 if (rmdir (outfile_check_directory) == -1)
16186 {
16187 if (errno == ENOENT)
16188 {
16189 // good, we can ignore
16190 }
16191 else if (errno == ENOTEMPTY)
16192 {
16193 // good, we can ignore
16194 }
16195 else
16196 {
16197 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16198
16199 return (-1);
16200 }
16201 }
16202
16203 local_free (outfile_check_directory);
16204 }
16205
16206 time_t proc_stop;
16207
16208 time (&proc_stop);
16209
16210 logfile_top_uint (proc_start);
16211 logfile_top_uint (proc_stop);
16212
16213 logfile_top_msg ("STOP");
16214
16215 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16216 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16217
16218 if (data.devices_status == STATUS_ABORTED) return 2;
16219 if (data.devices_status == STATUS_QUIT) return 2;
16220 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16221 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16222 if (data.devices_status == STATUS_CRACKED) return 0;
16223
16224 return -1;
16225 }
Hashcat additions to support pwdhash